CUDA 驱动程序 API :: CUDA 工具包文档

6.13. 内存管理

本节介绍底层 CUDA 驱动程序应用程序编程接口的内存管理函数。

类

struct CUmemDecompressParams: 描述构成单个解压缩操作的参数的结构体。

枚举

enum CUmemDecompressAlgorithm: CU_DEVICE_ATTRIBUTE_MEM_DECOMPRESS_ALGORITHM_MASK 的位掩码。

函数

CUresult cuArray3DCreate ( CUarray* pHandle, const CUDA_ARRAY3D_DESCRIPTOR* pAllocateArray ): 创建 3D CUDA 数组。
CUresult cuArray3DGetDescriptor ( CUDA_ARRAY3D_DESCRIPTOR* pArrayDescriptor, CUarray hArray ): 获取 3D CUDA 数组描述符。
CUresult cuArrayCreate ( CUarray* pHandle, const CUDA_ARRAY_DESCRIPTOR* pAllocateArray ): 创建 1D 或 2D CUDA 数组。
CUresult cuArrayDestroy ( CUarray hArray ): 销毁 CUDA 数组。
CUresult cuArrayGetDescriptor ( CUDA_ARRAY_DESCRIPTOR* pArrayDescriptor, CUarray hArray ): 获取 1D 或 2D CUDA 数组描述符。
CUresult cuArrayGetMemoryRequirements ( CUDA_ARRAY_MEMORY_REQUIREMENTS* memoryRequirements, CUarray array, CUdevice device ): 返回 CUDA 数组的内存需求。
CUresult cuArrayGetPlane ( CUarray* pPlaneArray, CUarray hArray, unsigned int planeIdx ): 从 CUDA 数组获取 CUDA 数组平面。
CUresult cuArrayGetSparseProperties ( CUDA_ARRAY_SPARSE_PROPERTIES* sparseProperties, CUarray array ): 返回稀疏 CUDA 数组的布局属性。
CUresult cuDeviceGetByPCIBusId ( CUdevice* dev, const char* pciBusId ): 返回计算设备的句柄。
CUresult cuDeviceGetPCIBusId ( char* pciBusId, int len, CUdevice dev ): 返回设备的 PCI 总线 ID 字符串。
CUresult cuDeviceRegisterAsyncNotification ( CUdevice device, CUasyncCallback callbackFunc, void* userData, CUasyncCallbackHandle* callback ): 注册一个回调函数以接收异步通知。
CUresult cuDeviceUnregisterAsyncNotification ( CUdevice device, CUasyncCallbackHandle callback ): 取消注册异步通知回调。
CUresult cuIpcCloseMemHandle ( CUdeviceptr dptr ): 尝试关闭使用 cuIpcOpenMemHandle 映射的内存。
CUresult cuIpcGetEventHandle ( CUipcEventHandle* pHandle, CUevent event ): 获取先前分配的事件的进程间句柄。
CUresult cuIpcGetMemHandle ( CUipcMemHandle* pHandle, CUdeviceptr dptr ): 获取现有设备内存分配的进程间内存句柄。
CUresult cuIpcOpenEventHandle ( CUevent* phEvent, CUipcEventHandle handle ): 打开一个进程间事件句柄，以便在当前进程中使用。
CUresult cuIpcOpenMemHandle ( CUdeviceptr* pdptr, CUipcMemHandle handle, unsigned int Flags ): 打开从另一个进程导出的进程间内存句柄，并返回可在本地进程中使用的设备指针。
CUresult cuMemAlloc ( CUdeviceptr* dptr, size_t bytesize ): 分配设备内存。
CUresult cuMemAllocHost ( void** pp, size_t bytesize ): 分配页锁定主机内存。
CUresult cuMemAllocManaged ( CUdeviceptr* dptr, size_t bytesize, unsigned int flags ): 分配将由统一内存系统自动管理的内存。
CUresult cuMemAllocPitch ( CUdeviceptr* dptr, size_t* pPitch, size_t WidthInBytes, size_t Height, unsigned int ElementSizeBytes ): 分配带步幅的设备内存。
CUresult cuMemBatchDecompressAsync ( CUmemDecompressParams* paramsArray, size_t count, unsigned int flags, size_t* errorIndex, CUstream stream ): 提交一批 count 独立的解压缩操作。
CUresult cuMemFree ( CUdeviceptr dptr ): 释放设备内存。
CUresult cuMemFreeHost ( void* p ): 释放页锁定主机内存。
CUresult cuMemGetAddressRange ( CUdeviceptr* pbase, size_t* psize, CUdeviceptr dptr ): 获取有关内存分配的信息。
CUresult cuMemGetHandleForAddressRange ( void* handle, CUdeviceptr dptr, size_t size, CUmemRangeHandleType handleType, unsigned long long flags ): 检索地址范围的句柄。
CUresult cuMemGetInfo ( size_t* free, size_t* total ): 获取可用和总内存。
CUresult cuMemHostAlloc ( void** pp, size_t bytesize, unsigned int Flags ): 分配页锁定主机内存。
CUresult cuMemHostGetDevicePointer ( CUdeviceptr* pdptr, void* p, unsigned int Flags ): 返回映射的固定内存的设备指针。
CUresult cuMemHostGetFlags ( unsigned int* pFlags, void* p ): 返回用于固定分配的标志。
CUresult cuMemHostRegister ( void* p, size_t bytesize, unsigned int Flags ): 注册现有主机内存范围以供 CUDA 使用。
CUresult cuMemHostUnregister ( void* p ): 取消注册使用 cuMemHostRegister 注册的内存范围。
CUresult cuMemcpy ( CUdeviceptr dst, CUdeviceptr src, size_t ByteCount ): 复制内存。
CUresult cuMemcpy2D ( const CUDA_MEMCPY2D* pCopy ): 复制 2D 数组的内存。
CUresult cuMemcpy2DAsync ( const CUDA_MEMCPY2D* pCopy, CUstream hStream ): 复制 2D 数组的内存。
CUresult cuMemcpy2DUnaligned ( const CUDA_MEMCPY2D* pCopy ): 复制 2D 数组的内存。
CUresult cuMemcpy3D ( const CUDA_MEMCPY3D* pCopy ): 复制 3D 数组的内存。
CUresult cuMemcpy3DAsync ( const CUDA_MEMCPY3D* pCopy, CUstream hStream ): 复制 3D 数组的内存。
CUresult cuMemcpy3DBatchAsync ( size_t numOps, CUDA_MEMCPY3D_BATCH_OP* opList, size_t* failIdx, unsigned long long flags, CUstream hStream ): 异步执行一批 3D 内存复制。
CUresult cuMemcpy3DPeer ( const CUDA_MEMCPY3D_PEER* pCopy ): 在上下文之间复制内存。
CUresult cuMemcpy3DPeerAsync ( const CUDA_MEMCPY3D_PEER* pCopy, CUstream hStream ): 异步在上下文之间复制内存。
CUresult cuMemcpyAsync ( CUdeviceptr dst, CUdeviceptr src, size_t ByteCount, CUstream hStream ): 异步复制内存。
CUresult cuMemcpyAtoA ( CUarray dstArray, size_t dstOffset, CUarray srcArray, size_t srcOffset, size_t ByteCount ): 从数组复制内存到数组。
CUresult cuMemcpyAtoD ( CUdeviceptr dstDevice, CUarray srcArray, size_t srcOffset, size_t ByteCount ): 从数组复制内存到设备。
CUresult cuMemcpyAtoH ( void* dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount ): 从数组复制内存到主机。
CUresult cuMemcpyAtoHAsync ( void* dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount, CUstream hStream ): 从数组复制内存到主机。
CUresult cuMemcpyBatchAsync ( CUdeviceptr* dsts, CUdeviceptr* srcs, size_t* sizes, size_t count, CUmemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, size_t* failIdx, CUstream hStream ): 异步执行批量内存复制操作。
CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount ): 从设备复制内存到数组。
CUresult cuMemcpyDtoD ( CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount ): 从设备复制内存到设备。
CUresult cuMemcpyDtoDAsync ( CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream ): 从设备复制内存到设备。
CUresult cuMemcpyDtoH ( void* dstHost, CUdeviceptr srcDevice, size_t ByteCount ): 从设备复制内存到主机。
CUresult cuMemcpyDtoHAsync ( void* dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream ): 从设备复制内存到主机。
CUresult cuMemcpyHtoA ( CUarray dstArray, size_t dstOffset, const void* srcHost, size_t ByteCount ): 从主机复制内存到数组。
CUresult cuMemcpyHtoAAsync ( CUarray dstArray, size_t dstOffset, const void* srcHost, size_t ByteCount, CUstream hStream ): 从主机复制内存到数组。
CUresult cuMemcpyHtoD ( CUdeviceptr dstDevice, const void* srcHost, size_t ByteCount ): 从主机复制内存到设备。
CUresult cuMemcpyHtoDAsync ( CUdeviceptr dstDevice, const void* srcHost, size_t ByteCount, CUstream hStream ): 从主机复制内存到设备。
CUresult cuMemcpyPeer ( CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount ): 在两个上下文之间复制设备内存。
CUresult cuMemcpyPeerAsync ( CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount, CUstream hStream ): 在两个上下文之间异步复制设备内存。
CUresult cuMemsetD16 ( CUdeviceptr dstDevice, unsigned short us, size_t N ): 初始化设备内存。
CUresult cuMemsetD16Async ( CUdeviceptr dstDevice, unsigned short us, size_t N, CUstream hStream ): 设置设备内存。
CUresult cuMemsetD2D16 ( CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height ): 初始化设备内存。
CUresult cuMemsetD2D16Async ( CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height, CUstream hStream ): 设置设备内存。
CUresult cuMemsetD2D32 ( CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height ): 初始化设备内存。
CUresult cuMemsetD2D32Async ( CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height, CUstream hStream ): 设置设备内存。
CUresult cuMemsetD2D8 ( CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height ): 初始化设备内存。
CUresult cuMemsetD2D8Async ( CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, CUstream hStream ): 设置设备内存。
CUresult cuMemsetD32 ( CUdeviceptr dstDevice, unsigned int ui, size_t N ): 初始化设备内存。
CUresult cuMemsetD32Async ( CUdeviceptr dstDevice, unsigned int ui, size_t N, CUstream hStream ): 设置设备内存。
CUresult cuMemsetD8 ( CUdeviceptr dstDevice, unsigned char uc, size_t N ): 初始化设备内存。
CUresult cuMemsetD8Async ( CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream ): 设置设备内存。
CUresult cuMipmappedArrayCreate ( CUmipmappedArray* pHandle, const CUDA_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc, unsigned int numMipmapLevels ): 创建一个 CUDA mipmapped 数组。
CUresult cuMipmappedArrayDestroy ( CUmipmappedArray hMipmappedArray ): 销毁一个 CUDA mipmapped 数组。
CUresult cuMipmappedArrayGetLevel ( CUarray* pLevelArray, CUmipmappedArray hMipmappedArray, unsigned int level ): 获取 CUDA mipmapped 数组的 mipmap 层级。
CUresult cuMipmappedArrayGetMemoryRequirements ( CUDA_ARRAY_MEMORY_REQUIREMENTS* memoryRequirements, CUmipmappedArray mipmap, CUdevice device ): 返回 CUDA mipmapped 数组的内存需求。
CUresult cuMipmappedArrayGetSparseProperties ( CUDA_ARRAY_SPARSE_PROPERTIES* sparseProperties, CUmipmappedArray mipmap ): 返回稀疏 CUDA mipmapped 数组的布局属性。

枚举

enum CUmemDecompressAlgorithm

值

CU_MEM_DECOMPRESS_UNSUPPORTED = 0: 不支持解压缩。
CU_MEM_DECOMPRESS_ALGORITHM_DEFLATE = 1<<0: 支持 Deflate。
CU_MEM_DECOMPRESS_ALGORITHM_SNAPPY = 1<<1: 支持 Snappy。

函数

CUresult cuArray3DCreate ( CUarray* pHandle, const CUDA_ARRAY3D_DESCRIPTOR* pAllocateArray )

创建一个 3D CUDA 数组。

参数

pHandle: - 返回的数组
pAllocateArray: - 3D 数组描述符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY, CUDA_ERROR_UNKNOWN

描述

根据 CUDA_ARRAY3D_DESCRIPTOR 结构体创建一个 CUDA 数组，pAllocateArray并在*pHandle中返回新 CUDA 数组的句柄。CUDA_ARRAY3D_DESCRIPTOR 定义如下：

‎    typedef struct {
              unsigned int Width;
              unsigned int Height;
              unsigned int Depth;
              CUarray_format Format;
              unsigned int NumChannels;
              unsigned int Flags;
          } CUDA_ARRAY3D_DESCRIPTOR;

其中

Width, Height和Depth是 CUDA 数组的宽度、高度和深度（以元素为单位）；可以分配以下类型的 CUDA 数组
- 如果Height和Depth范围均为零，则分配 1D 数组。
- 如果只有Depth范围为零，则分配 2D 数组。
- 如果所有三个范围均为非零，则分配 3D 数组。
- 如果只有Height为零且设置了 CUDA_ARRAY3D_LAYERED 标志，则分配 1D 分层 CUDA 数组。每个层都是一个 1D 数组。层数由深度范围决定。
- 如果所有三个范围均为非零且设置了 CUDA_ARRAY3D_LAYERED 标志，则分配 2D 分层 CUDA 数组。每个层都是一个 2D 数组。层数由深度范围决定。
- 如果所有三个范围均为非零且设置了 CUDA_ARRAY3D_CUBEMAP 标志，则分配 cubemap CUDA 数组。Width必须等于Height和Depth必须为 6。Cubemap 是一种特殊的 2D 分层 CUDA 数组，其中六层表示立方体的六个面。内存中六层的顺序与 CUarray_cubemap_face 中列出的顺序相同。
- 如果所有三个范围均为非零，并且同时设置了 CUDA_ARRAY3D_CUBEMAP 和 CUDA_ARRAY3D_LAYERED 标志，则分配 cubemap 分层 CUDA 数组。Width必须等于Height和Depth必须是 6 的倍数。Cubemap 分层 CUDA 数组是一种特殊的 2D 分层 CUDA 数组，它由 cubemap 的集合组成。前六层表示第一个 cubemap，接下来的六层构成第二个 cubemap，依此类推。

Format 指定元素的格式；CUarray_format 定义为

‎    typedef enum CUarray_format_enum {
              CU_AD_FORMAT_UNSIGNED_INT8 = 0x01,
              CU_AD_FORMAT_UNSIGNED_INT16 = 0x02,
              CU_AD_FORMAT_UNSIGNED_INT32 = 0x03,
              CU_AD_FORMAT_SIGNED_INT8 = 0x08,
              CU_AD_FORMAT_SIGNED_INT16 = 0x09,
              CU_AD_FORMAT_SIGNED_INT32 = 0x0a,
              CU_AD_FORMAT_HALF = 0x10,
              CU_AD_FORMAT_FLOAT = 0x20,
              CU_AD_FORMAT_NV12 = 0xb0, 
              CU_AD_FORMAT_UNORM_INT8X1 = 0xc0, 
              CU_AD_FORMAT_UNORM_INT8X2 = 0xc1, 
              CU_AD_FORMAT_UNORM_INT8X4 = 0xc2, 
              CU_AD_FORMAT_UNORM_INT16X1 = 0xc3, 
              CU_AD_FORMAT_UNORM_INT16X2 = 0xc4, 
              CU_AD_FORMAT_UNORM_INT16X4 = 0xc5, 
              CU_AD_FORMAT_SNORM_INT8X1 = 0xc6, 
              CU_AD_FORMAT_SNORM_INT8X2 = 0xc7, 
              CU_AD_FORMAT_SNORM_INT8X4 = 0xc8, 
              CU_AD_FORMAT_SNORM_INT16X1 = 0xc9,
              CU_AD_FORMAT_SNORM_INT16X2 = 0xca,
              CU_AD_FORMAT_SNORM_INT16X4 = 0xcb,
              CU_AD_FORMAT_BC1_UNORM = 0x91,
              CU_AD_FORMAT_BC1_UNORM_SRGB = 0x92,
              CU_AD_FORMAT_BC2_UNORM = 0x93,
              CU_AD_FORMAT_BC2_UNORM_SRGB = 0x94,
              CU_AD_FORMAT_BC3_UNORM = 0x95,
              CU_AD_FORMAT_BC3_UNORM_SRGB = 0x96,
              CU_AD_FORMAT_BC4_UNORM = 0x97,
              CU_AD_FORMAT_BC4_SNORM = 0x98,
              CU_AD_FORMAT_BC5_UNORM = 0x99,
              CU_AD_FORMAT_BC5_SNORM = 0x9a,
              CU_AD_FORMAT_BC6H_UF16 = 0x9b,
              CU_AD_FORMAT_BC6H_SF16 = 0x9c,
              CU_AD_FORMAT_BC7_UNORM = 0x9d,
              CU_AD_FORMAT_BC7_UNORM_SRGB = 0x9e,
              CU_AD_FORMAT_P010 = 0x9f,
              CU_AD_FORMAT_P016 = 0xa1,
              CU_AD_FORMAT_NV16 = 0xa2,
              CU_AD_FORMAT_P210 = 0xa3,
              CU_AD_FORMAT_P216 = 0xa4,
              CU_AD_FORMAT_YUY2 = 0xa5,
              CU_AD_FORMAT_Y210 = 0xa6,
              CU_AD_FORMAT_Y216 = 0xa7,
              CU_AD_FORMAT_AYUV = 0xa8,
              CU_AD_FORMAT_Y410 = 0xa9,
              CU_AD_FORMAT_Y416 = 0xb1,
              CU_AD_FORMAT_Y444_PLANAR8 = 0xb2,
              CU_AD_FORMAT_Y444_PLANAR10 = 0xb3,
              CU_AD_FORMAT_YUV444_8bit_SemiPlanar = 0xb4,
              CU_AD_FORMAT_YUV444_16bit_SemiPlanar = 0xb5,
              CU_AD_FORMAT_UNORM_INT_101010_2 = 0x50,
          } CUarray_format;

NumChannels指定每个 CUDA 数组元素打包的组件数；它可以是 1、2 或 4；

Flags 可以设置为
- CUDA_ARRAY3D_LAYERED 以启用分层 CUDA 数组的创建。如果设置了此标志，则Depth指定层数，而不是 3D 数组的深度。
- CUDA_ARRAY3D_SURFACE_LDST 以启用绑定到 CUDA 数组的表面引用。如果未设置此标志，则当尝试将 CUDA 数组绑定到表面引用时，cuSurfRefSetArray 将会失败。
- CUDA_ARRAY3D_CUBEMAP 以启用 cubemap 的创建。如果设置了此标志，则Width必须等于Height和Depth必须为 6。如果也设置了 CUDA_ARRAY3D_LAYERED 标志，则Depth必须是 6 的倍数。
- CUDA_ARRAY3D_TEXTURE_GATHER 指示 CUDA 数组将用于纹理 Gather 操作。纹理 Gather 只能在 2D CUDA 数组上执行。

Width, Height和Depth必须满足下表列出的某些大小要求。所有值均以元素为单位指定。请注意，为了简洁起见，未指定设备属性的完整名称。例如，TEXTURE1D_WIDTH 指的是设备属性 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH。

请注意，如果设置了 CUDA_ARRAY3D_TEXTURE_GATHER 标志，则 2D CUDA 数组具有不同的大小要求。Width和Height在这种情况下，必须分别不大于 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH 和 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT。

CUDA 数组类型	必须始终满足的有效范围 {(宽度范围，以元素为单位), (高度范围), (深度范围)}	设置 CUDA_ARRAY3D_SURFACE_LDST 后的有效范围 {(宽度范围，以元素为单位), (高度范围), (深度范围)}
1D	{ (1,TEXTURE1D_WIDTH), 0, 0 }	{ (1,SURFACE1D_WIDTH), 0, 0 }
2D	{ (1,TEXTURE2D_WIDTH), (1,TEXTURE2D_HEIGHT), 0 }	{ (1,SURFACE2D_WIDTH), (1,SURFACE2D_HEIGHT), 0 }
3D	{ (1,TEXTURE3D_WIDTH), (1,TEXTURE3D_HEIGHT), (1,TEXTURE3D_DEPTH) } OR { (1,TEXTURE3D_WIDTH_ALTERNATE), (1,TEXTURE3D_HEIGHT_ALTERNATE), (1,TEXTURE3D_DEPTH_ALTERNATE) }	{ (1,SURFACE3D_WIDTH), (1,SURFACE3D_HEIGHT), (1,SURFACE3D_DEPTH) }
1D 分层	{ (1,TEXTURE1D_LAYERED_WIDTH), 0, (1,TEXTURE1D_LAYERED_LAYERS) }	{ (1,SURFACE1D_LAYERED_WIDTH), 0, (1,SURFACE1D_LAYERED_LAYERS) }
2D 分层	{ (1,TEXTURE2D_LAYERED_WIDTH), (1,TEXTURE2D_LAYERED_HEIGHT), (1,TEXTURE2D_LAYERED_LAYERS) }	{ (1,SURFACE2D_LAYERED_WIDTH), (1,SURFACE2D_LAYERED_HEIGHT), (1,SURFACE2D_LAYERED_LAYERS) }
Cubemap	{ (1,TEXTURECUBEMAP_WIDTH), (1,TEXTURECUBEMAP_WIDTH), 6 }	{ (1,SURFACECUBEMAP_WIDTH), (1,SURFACECUBEMAP_WIDTH), 6 }
Cubemap 分层	{ (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_LAYERS) }	{ (1,SURFACECUBEMAP_LAYERED_WIDTH), (1,SURFACECUBEMAP_LAYERED_WIDTH), (1,SURFACECUBEMAP_LAYERED_LAYERS) }

以下是 CUDA 数组描述的示例

包含 2048 个浮点数的 CUDA 数组的描述

‎    CUDA_ARRAY3D_DESCRIPTOR desc;
          desc.Format = CU_AD_FORMAT_FLOAT;
          desc.NumChannels = 1;
          desc.Width = 2048;
          desc.Height = 0;
          desc.Depth = 0;

包含 64 x 64 浮点数的 CUDA 数组的描述

‎    CUDA_ARRAY3D_DESCRIPTOR desc;
          desc.Format = CU_AD_FORMAT_FLOAT;
          desc.NumChannels = 1;
          desc.Width = 64;
          desc.Height = 64;
          desc.Depth = 0;

包含widthxheightxdepth个 64 位、4x16 位 float16 的 CUDA 数组的描述

‎    CUDA_ARRAY3D_DESCRIPTOR desc;
          desc.Format = CU_AD_FORMAT_HALF;
          desc.NumChannels = 4;
          desc.Width = width;
          desc.Height = height;
          desc.Depth = depth;

注意

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

另请参阅

cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMalloc3DArray

CUresult cuArray3DGetDescriptor ( CUDA_ARRAY3D_DESCRIPTOR* pArrayDescriptor, CUarray hArray )

获取 3D CUDA 数组描述符。

参数

pArrayDescriptor: - 返回的 3D 数组描述符
hArray: - 要获取描述符的 3D 数组

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE, CUDA_ERROR_CONTEXT_IS_DESTROYED

描述

返回值在*pArrayDescriptor包含 CUDA 数组格式和维度的描述符。hArray它对于已传递 CUDA 数组，但需要知道 CUDA 数组参数以进行验证或其他目的的子例程非常有用。

此函数可以对 1D 和 2D 数组调用，在这种情况下，Height和/或Depth描述符结构的成员将设置为 0。

注意

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

另请参阅

cuArray3DCreate, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaArrayGetInfo

CUresult cuArrayCreate ( CUarray* pHandle, const CUDA_ARRAY_DESCRIPTOR* pAllocateArray )

创建 1D 或 2D CUDA 数组。

参数

pHandle: - 返回的数组
pAllocateArray: - 数组描述符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY, CUDA_ERROR_UNKNOWN

描述

根据 CUDA_ARRAY_DESCRIPTOR 结构创建 CUDA 数组。pAllocateArray并在*pHandleCUDA_ARRAY_DESCRIPTOR 定义为

‎    typedef struct {
              unsigned int Width;
              unsigned int Height;
              CUarray_format Format;
              unsigned int NumChannels;
          } CUDA_ARRAY_DESCRIPTOR;

其中

Width和Height是 CUDA 数组的宽度和高度（以元素为单位）；如果高度为 0，则 CUDA 数组为一维，否则为二维；

Format 指定元素的格式；CUarray_format 定义为

‎    typedef enum CUarray_format_enum {
              CU_AD_FORMAT_UNSIGNED_INT8 = 0x01,
              CU_AD_FORMAT_UNSIGNED_INT16 = 0x02,
              CU_AD_FORMAT_UNSIGNED_INT32 = 0x03,
              CU_AD_FORMAT_SIGNED_INT8 = 0x08,
              CU_AD_FORMAT_SIGNED_INT16 = 0x09,
              CU_AD_FORMAT_SIGNED_INT32 = 0x0a,
              CU_AD_FORMAT_HALF = 0x10,
              CU_AD_FORMAT_FLOAT = 0x20,
              CU_AD_FORMAT_NV12 = 0xb0, 
              CU_AD_FORMAT_UNORM_INT8X1 = 0xc0, 
              CU_AD_FORMAT_UNORM_INT8X2 = 0xc1, 
              CU_AD_FORMAT_UNORM_INT8X4 = 0xc2, 
              CU_AD_FORMAT_UNORM_INT16X1 = 0xc3, 
              CU_AD_FORMAT_UNORM_INT16X2 = 0xc4, 
              CU_AD_FORMAT_UNORM_INT16X4 = 0xc5, 
              CU_AD_FORMAT_SNORM_INT8X1 = 0xc6, 
              CU_AD_FORMAT_SNORM_INT8X2 = 0xc7, 
              CU_AD_FORMAT_SNORM_INT8X4 = 0xc8, 
              CU_AD_FORMAT_SNORM_INT16X1 = 0xc9,
              CU_AD_FORMAT_SNORM_INT16X2 = 0xca,
              CU_AD_FORMAT_SNORM_INT16X4 = 0xcb,
              CU_AD_FORMAT_BC1_UNORM = 0x91,
              CU_AD_FORMAT_BC1_UNORM_SRGB = 0x92,
              CU_AD_FORMAT_BC2_UNORM = 0x93,
              CU_AD_FORMAT_BC2_UNORM_SRGB = 0x94,
              CU_AD_FORMAT_BC3_UNORM = 0x95,
              CU_AD_FORMAT_BC3_UNORM_SRGB = 0x96,
              CU_AD_FORMAT_BC4_UNORM = 0x97,
              CU_AD_FORMAT_BC4_SNORM = 0x98,
              CU_AD_FORMAT_BC5_UNORM = 0x99,
              CU_AD_FORMAT_BC5_SNORM = 0x9a,
              CU_AD_FORMAT_BC6H_UF16 = 0x9b,
              CU_AD_FORMAT_BC6H_SF16 = 0x9c,
              CU_AD_FORMAT_BC7_UNORM = 0x9d,
              CU_AD_FORMAT_BC7_UNORM_SRGB = 0x9e,
              CU_AD_FORMAT_P010 = 0x9f,
              CU_AD_FORMAT_P016 = 0xa1,
              CU_AD_FORMAT_NV16 = 0xa2,
              CU_AD_FORMAT_P210 = 0xa3,
              CU_AD_FORMAT_P216 = 0xa4,
              CU_AD_FORMAT_YUY2 = 0xa5,
              CU_AD_FORMAT_Y210 = 0xa6,
              CU_AD_FORMAT_Y216 = 0xa7,
              CU_AD_FORMAT_AYUV = 0xa8,
              CU_AD_FORMAT_Y410 = 0xa9,
              CU_AD_FORMAT_Y416 = 0xb1,
              CU_AD_FORMAT_Y444_PLANAR8 = 0xb2,
              CU_AD_FORMAT_Y444_PLANAR10 = 0xb3,
              CU_AD_FORMAT_YUV444_8bit_SemiPlanar = 0xb4,
              CU_AD_FORMAT_YUV444_16bit_SemiPlanar = 0xb5,
              CU_AD_FORMAT_UNORM_INT_101010_2 = 0x50,
         } CUarray_format;

NumChannels指定每个 CUDA 数组元素打包的组件数；它可以是 1、2 或 4；

以下是 CUDA 数组描述的示例

包含 2048 个浮点数的 CUDA 数组的描述

‎    CUDA_ARRAY_DESCRIPTOR desc;
          desc.Format = CU_AD_FORMAT_FLOAT;
          desc.NumChannels = 1;
          desc.Width = 2048;
          desc.Height = 1;

包含 64 x 64 浮点数的 CUDA 数组的描述

‎    CUDA_ARRAY_DESCRIPTOR desc;
          desc.Format = CU_AD_FORMAT_FLOAT;
          desc.NumChannels = 1;
          desc.Width = 64;
          desc.Height = 64;

包含widthxheight个 64 位、4x16 位 float16 的 CUDA 数组的描述

‎    CUDA_ARRAY_DESCRIPTOR desc;
          desc.Format = CU_AD_FORMAT_HALF;
          desc.NumChannels = 4;
          desc.Width = width;
          desc.Height = height;

包含widthxheight16 位元素 CUDA 数组，每个元素由两个 8 位无符号字符组成

‎    CUDA_ARRAY_DESCRIPTOR arrayDesc;
          desc.Format = CU_AD_FORMAT_UNSIGNED_INT8;
          desc.NumChannels = 2;
          desc.Width = width;
          desc.Height = height;

注意

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

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMallocArray

CUresult cuArrayDestroy ( CUarray hArray )

销毁 CUDA 数组。

参数

hArray: - 要销毁的数组

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_HANDLE, CUDA_ERROR_ARRAY_IS_MAPPED, CUDA_ERROR_CONTEXT_IS_DESTROYED

描述

销毁 CUDA 数组hArray.

注意

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

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaFreeArray

CUresult cuArrayGetDescriptor ( CUDA_ARRAY_DESCRIPTOR* pArrayDescriptor, CUarray hArray )

获取 1D 或 2D CUDA 数组描述符。

参数

pArrayDescriptor: - 返回的数组描述符
hArray: - 要获取描述符的数组

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

注意

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

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaArrayGetInfo

CUresult cuArrayGetMemoryRequirements ( CUDA_ARRAY_MEMORY_REQUIREMENTS* memoryRequirements, CUarray array, CUdevice device )

返回 CUDA 数组的内存需求。

参数

memoryRequirements: - 指向 CUDA_ARRAY_MEMORY_REQUIREMENTS 的指针
array: - 要获取内存需求的 CUDA 数组
device: - 获取内存需求的设备

返回值

CUDA_SUCCESS CUDA_ERROR_INVALID_VALUE

描述

返回 CUDA 数组的内存需求，存储在memoryRequirements如果 CUDA 数组未使用标志 CUDA_ARRAY3D_DEFERRED_MAPPING 分配，则将返回 CUDA_ERROR_INVALID_VALUE。

在 CUDA_ARRAY_MEMORY_REQUIREMENTS::size 中返回的值表示 CUDA 数组的总大小。在 CUDA_ARRAY_MEMORY_REQUIREMENTS::alignment 中返回的值表示映射 CUDA 数组所需的对齐方式。

另请参阅

cuMipmappedArrayGetMemoryRequirements, cuMemMapArrayAsync

CUresult cuArrayGetPlane ( CUarray* pPlaneArray, CUarray hArray, unsigned int planeIdx )

从 CUDA 数组获取 CUDA 数组平面。

参数

pPlaneArray: - 返回的 CUDA 数组，由planeIdx
hArray: - 多平面 CUDA 数组
planeIdx: - 平面索引

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

返回值在pPlaneArray引用的 CUDA 数组，该数组表示 CUDA 数组的单个格式平面hArray.

如果planeIdx大于此数组中的最大平面数，或者如果数组没有多平面格式，例如：CU_AD_FORMAT_NV12，则返回 CUDA_ERROR_INVALID_VALUE。

请注意，如果hArray的格式为 CU_AD_FORMAT_NV12，则传入 0 作为planeIdx会返回一个与hArray大小相同的 CUDA 数组，但只有一个通道，格式为 CU_AD_FORMAT_UNSIGNED_INT8。如果为planeIdx传入 1，则返回的 CUDA 数组的高度和宽度是hArray的一半，具有两个通道，格式为 CU_AD_FORMAT_UNSIGNED_INT8。

注意

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

另请参阅

cuArrayCreate, cudaArrayGetPlane

CUresult cuArrayGetSparseProperties ( CUDA_ARRAY_SPARSE_PROPERTIES* sparseProperties, CUarray array )

返回稀疏 CUDA 数组的布局属性。

参数

sparseProperties: - 指向 CUDA_ARRAY_SPARSE_PROPERTIES 的指针
array: - 要获取稀疏属性的 CUDA 数组

返回值

CUDA_SUCCESS CUDA_ERROR_INVALID_VALUE

描述

返回稀疏 CUDA 数组的布局属性，存储在sparseProperties如果 CUDA 数组未使用标志 CUDA_ARRAY3D_SPARSE 分配，则将返回 CUDA_ERROR_INVALID_VALUE。

如果在 CUDA_ARRAY_SPARSE_PROPERTIES::flags 中返回的值包含 CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL，则 CUDA_ARRAY_SPARSE_PROPERTIES::miptailSize 表示数组的总大小。否则，它将为零。此外，在 CUDA_ARRAY_SPARSE_PROPERTIES::miptailFirstLevel 中返回的值始终为零。请注意，array必须使用 cuArrayCreate 或 cuArray3DCreate 分配。对于使用 cuMipmappedArrayGetLevel 获取的 CUDA 数组，将返回 CUDA_ERROR_INVALID_VALUE。相反，必须使用 cuMipmappedArrayGetSparseProperties 来获取array所属的整个 CUDA mipmapped 数组的稀疏属性。

另请参阅

cuMipmappedArrayGetSparseProperties, cuMemMapArrayAsync

CUresult cuDeviceGetByPCIBusId ( CUdevice* dev, const char* pciBusId )

返回计算设备的句柄。

参数

dev: - 返回的设备句柄
pciBusId: - 以下形式之一的字符串：[domain]:[bus]:[device].[function] [domain]:[bus]:[device] [bus]:[device].[function]，其中domain, bus, device和function均为十六进制值

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE

描述

返回值在*device给定 PCI 总线 ID 字符串的设备句柄。

注意

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

另请参阅

cuDeviceGet, cuDeviceGetAttribute, cuDeviceGetPCIBusId, cudaDeviceGetByPCIBusId

CUresult cuDeviceGetPCIBusId ( char* pciBusId, int len, CUdevice dev )

返回设备的 PCI 总线 ID 字符串。

参数

pciBusId: - 返回的设备标识符字符串，格式如下：[domain]:[bus]:[device].[function]，其中domain, bus, device和function均为十六进制值。pciBusId 应足够大以存储 13 个字符，包括空终止符。
len: - 要存储在其中的字符串的最大长度name
dev: - 获取标识符字符串的设备

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE

描述

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

注意

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

另请参阅

cuDeviceGet, cuDeviceGetAttribute, cuDeviceGetByPCIBusId, cudaDeviceGetPCIBusId

CUresult cuDeviceRegisterAsyncNotification ( CUdevice device, CUasyncCallback callbackFunc, void* userData, CUasyncCallbackHandle* callback )

注册一个回调函数以接收异步通知。

参数

device: - 要在其上注册回调的设备
callbackFunc: - 要注册为回调的函数
userData: - 指向用户数据的通用指针。这会传递到回调函数中。
callback: - 表示已注册回调实例的句柄

返回值

CUDA_SUCCESS CUDA_ERROR_NOT_SUPPORTED CUDA_ERROR_INVALID_DEVICE CUDA_ERROR_INVALID_VALUE CUDA_ERROR_NOT_PERMITTED CUDA_ERROR_UNKNOWN

描述

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

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

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

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

注意

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

另请参阅

cuDeviceUnregisterAsyncNotification

CUresult cuDeviceUnregisterAsyncNotification ( CUdevice device, CUasyncCallbackHandle callback )

注销异步通知回调。

参数

device: - 要从中移除回调的设备callback.
callback: - 要取消注册以接收异步通知的回调实例。

返回值

CUDA_SUCCESS CUDA_ERROR_NOT_SUPPORTED CUDA_ERROR_INVALID_DEVICE CUDA_ERROR_INVALID_VALUE CUDA_ERROR_NOT_PERMITTED CUDA_ERROR_UNKNOWN

描述

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

注意

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

另请参阅

cuDeviceRegisterAsyncNotification

CUresult cuIpcCloseMemHandle ( CUdeviceptr dptr )

尝试关闭使用 cuIpcOpenMemHandle 映射的内存。

参数

dptr: - 由 cuIpcOpenMemHandle 返回的设备指针

返回值

CUDA_SUCCESS, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_MAP_FAILED, CUDA_ERROR_INVALID_HANDLE, CUDA_ERROR_INVALID_VALUE

描述

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

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

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

另请参阅

cuMemAlloc, cuMemFree, cuIpcGetEventHandle, cuIpcOpenEventHandle, cuIpcGetMemHandle, cuIpcOpenMemHandle, cudaIpcCloseMemHandle

CUresult cuIpcGetEventHandle ( CUipcEventHandle* pHandle, CUevent event )

获取先前分配的事件的进程间句柄。

参数

pHandle: - 指向用户分配的 CUipcEventHandle 的指针，用于在其中返回不透明的事件句柄
event: - 使用 CU_EVENT_INTERPROCESS 和 CU_EVENT_DISABLE_TIMING 标志分配的事件。

返回值

CUDA_SUCCESS, CUDA_ERROR_INVALID_HANDLE, CUDA_ERROR_OUT_OF_MEMORY, CUDA_ERROR_MAP_FAILED, CUDA_ERROR_INVALID_VALUE

描述

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

在导入进程中打开事件后，cuEventRecord、cuEventSynchronize、cuStreamWaitEvent 和 cuEventQuery 可以在任一进程中使用。在使用 cuEventDestroy 释放导出的事件后，对导入的事件执行操作将导致未定义的行为。

另请参阅

cuEventCreate, cuEventDestroy, cuEventSynchronize, cuEventQuery, cuStreamWaitEvent, cuIpcOpenEventHandle, cuIpcGetMemHandle, cuIpcOpenMemHandle, cuIpcCloseMemHandle, cudaIpcGetEventHandle

CUresult cuIpcGetMemHandle ( CUipcMemHandle* pHandle, CUdeviceptr dptr )

获取现有设备内存分配的进程间内存句柄。

参数

pHandle: - 指向用户分配的 CUipcMemHandle 的指针，用于在其中返回句柄。
dptr: - 指向先前分配的设备内存的基指针

返回值

CUDA_SUCCESS, CUDA_ERROR_INVALID_HANDLE, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_OUT_OF_MEMORY, CUDA_ERROR_MAP_FAILED, CUDA_ERROR_INVALID_VALUE

描述

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

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

另请参阅

cuMemAlloc, cuMemFree, cuIpcGetEventHandle, cuIpcOpenEventHandle, cuIpcOpenMemHandle, cuIpcCloseMemHandle, cudaIpcGetMemHandle

CUresult cuIpcOpenEventHandle ( CUevent* phEvent, CUipcEventHandle handle )

打开进程间事件句柄以在当前进程中使用。

参数

phEvent: - 返回导入的事件
handle: - 要打开的进程间句柄

返回值

CUDA_SUCCESS, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_MAP_FAILED, CUDA_ERROR_PEER_ACCESS_UNSUPPORTED, CUDA_ERROR_INVALID_HANDLE, CUDA_ERROR_INVALID_VALUE

描述

使用 cuIpcGetEventHandle 打开从另一个进程导出的进程间事件句柄。此函数返回一个 CUevent，其行为类似于本地创建的事件，并指定了 CU_EVENT_DISABLE_TIMING 标志。此事件必须使用 cuEventDestroy 释放。

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

另请参阅

cuEventCreate, cuEventDestroy, cuEventSynchronize, cuEventQuery, cuStreamWaitEvent, cuIpcGetEventHandle, cuIpcGetMemHandle, cuIpcOpenMemHandle, cuIpcCloseMemHandle, cudaIpcOpenEventHandle

CUresult cuIpcOpenMemHandle ( CUdeviceptr* pdptr, CUipcMemHandle handle, unsigned int Flags )

打开从另一个进程导出的进程间内存句柄，并返回可在本地进程中使用的设备指针。

参数

pdptr: - 返回的设备指针
handle: - 要打开的 CUipcMemHandle
Flags: - 此操作的标志。必须指定为 CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS

返回值

CUDA_SUCCESS, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_MAP_FAILED, CUDA_ERROR_INVALID_HANDLE, CUDA_ERROR_TOO_MANY_PEERS, CUDA_ERROR_INVALID_VALUE

描述

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

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

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

从 cuIpcOpenMemHandle 返回的内存必须使用 cuIpcCloseMemHandle 释放。

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

注意

不保证在以下位置返回的地址*pdptr。handle.

另请参阅

cuMemAlloc, cuMemFree, cuIpcGetEventHandle, cuIpcOpenEventHandle, cuIpcGetMemHandle, cuIpcCloseMemHandle, cuCtxEnablePeerAccess, cuDeviceCanAccessPeer, cudaIpcOpenMemHandle

CUresult cuMemAlloc ( CUdeviceptr* dptr, size_t bytesize )

分配设备内存。

参数

dptr: - 返回的设备指针
bytesize: - 请求的分配大小（以字节为单位）

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY

描述

分配bytesize设备上的字节线性内存，并在以下位置返回*dptr指向已分配内存的指针。分配的内存适合任何类型的变量。内存未清除。如果bytesize为 0，则 cuMemAlloc() 返回 CUDA_ERROR_INVALID_VALUE。

注意

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

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMalloc

CUresult cuMemAllocHost ( void** pp, size_t bytesize )

分配页锁定主机内存。

参数

pp: - 返回的主机内存指针
bytesize: - 请求的分配大小（以字节为单位）

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY

描述

分配bytesize字节的主机内存，这些内存是页锁定的并且可以被设备访问。驱动程序跟踪使用此函数分配的虚拟内存范围，并自动加速对 cuMemcpy() 等函数的调用。由于内存可以直接被设备访问，因此与使用 malloc() 等函数获得的可分页内存相比，它可以以更高的带宽进行读取或写入。

在 CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES 为 true 的系统上，cuMemAllocHost 可能不会页锁定已分配的内存。

使用 cuMemAllocHost() 页锁定过多的内存可能会降低系统性能，因为它减少了系统可用于分页的内存量。因此，此函数最好谨慎使用，以分配用于主机和设备之间数据交换的暂存区。

请注意，使用 cuMemAllocHost() 分配的所有主机内存将自动立即供支持统一寻址的所有设备上的所有上下文访问（可以使用 CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING 查询）。可用于从这些上下文访问此主机内存的设备指针始终等于返回的主机指针*pp。有关更多详细信息，请参阅统一寻址。

注意

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

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMallocHost

CUresult cuMemAllocManaged ( CUdeviceptr* dptr, size_t bytesize, unsigned int flags )

分配将由统一内存系统自动管理的内存。

参数

dptr: - 返回的设备指针
bytesize: - 请求的分配大小（以字节为单位）
flags: - 必须是 CU_MEM_ATTACH_GLOBAL 或 CU_MEM_ATTACH_HOST 之一

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_NOT_SUPPORTED, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY

描述

分配bytesize设备上托管内存的字节数，并在*dptr返回指向已分配内存的指针。如果设备不支持分配托管内存，则返回 CUDA_ERROR_NOT_SUPPORTED。可以使用设备属性 CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY 查询对托管内存的支持。分配的内存适当地对齐以适应任何类型的变量。内存未被清除。如果bytesize为 0，cuMemAllocManaged 返回 CUDA_ERROR_INVALID_VALUE。该指针在 CPU 和系统中所有支持托管内存的 GPU 上均有效。对该指针的所有访问都必须遵守统一内存编程模型。

flags指定此分配的默认流关联。flags必须是 CU_MEM_ATTACH_GLOBAL 或 CU_MEM_ATTACH_HOST 之一。如果指定了 CU_MEM_ATTACH_GLOBAL，则可以从任何设备上的任何流访问此内存。如果指定了 CU_MEM_ATTACH_HOST，则不应从设备属性 CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS 值为零的设备访问此分配；需要显式调用 cuStreamAttachMemAsync 以启用对此类设备上的访问。

如果稍后通过 cuStreamAttachMemAsync 将关联更改为单个流，则当该流被销毁时，将恢复在 cuMemAllocManaged 期间指定的默认关联。对于 __managed__ 变量，默认关联始终为 CU_MEM_ATTACH_GLOBAL。请注意，销毁流是异步操作，因此，在流中的所有工作完成之前，默认关联的更改不会发生。

使用 cuMemAllocManaged 分配的内存应使用 cuMemFree 释放。

对于设备属性 CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS 值为非零的 GPU，设备内存可能会过度分配。为了给其他分配腾出空间，统一内存驱动程序可能会随时将此类 GPU 上的托管内存从设备内存中换出到主机内存中。

在所有 GPU 的设备属性 CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS 值为非零的系统中，托管内存可能不会在此 API 返回时填充，而可能在访问时填充。在此类系统中，托管内存可以随时迁移到任何处理器的内存中。统一内存驱动程序将采用启发式方法来维护数据局部性，并在最大程度上防止过多的页面错误。应用程序还可以通过 cuMemAdvise 指导驱动程序有关内存使用模式。应用程序还可以通过 cuMemPrefetchAsync 显式地将内存迁移到所需的处理器内存中。

在多 GPU 系统中，如果所有 GPU 的设备属性 CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS 值为零，并且所有 GPU 彼此之间都具有对等支持，则托管内存的物理存储将在调用 cuMemAllocManaged 时处于活动状态的 GPU 上创建。所有其他 GPU 将通过 PCIe 总线上的对等映射以降低的带宽引用数据。统一内存驱动程序不会在此类 GPU 之间迁移内存。

在多 GPU 系统中，并非所有 GPU 都彼此具有对等支持，并且至少有一个 GPU 的设备属性 CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS 值为零，则为托管内存选择的物理存储位置取决于系统。

在 Linux 上，只要当前活动上下文集位于彼此具有对等支持或设备属性 CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS 值为非零的设备上，则选择的位置将是设备内存。如果 GPU 上存在活动上下文，而该 GPU 的设备属性值不为零，并且它与其他具有活动上下文的设备之间没有对等支持，则物理存储的位置将为“零复制”或主机内存。请注意，这意味着如果在新 GPU 上创建了一个上下文，该 GPU 的设备属性值不为零，并且不支持与至少一个其他具有活动上下文的设备进行对等，则位于设备内存中的托管内存将迁移到主机内存。反过来，这意味着如果主机内存不足以迁移所有托管分配，则上下文创建可能会失败。
在 Windows 上，物理存储始终在“零复制”或主机内存中创建。所有 GPU 将以降低的带宽通过 PCIe 总线引用数据。在这种情况下，建议使用环境变量 CUDA_VISIBLE_DEVICES 将 CUDA 限制为仅使用那些具有对等支持的 GPU。或者，用户还可以将 CUDA_MANAGED_FORCE_DEVICE_ALLOC 设置为非零值，以强制驱动程序始终使用设备内存进行物理存储。当此环境变量设置为非零值时，在该进程中在支持托管内存的设备上创建的所有上下文都必须彼此对等兼容。如果在支持托管内存且与先前在其上创建上下文的任何其他托管内存支持设备不兼容的设备上创建上下文，则上下文创建将失败，即使这些上下文已被销毁。这些环境变量在 CUDA 编程指南的“CUDA 环境变量”部分中进行了描述。
在 ARM 上，Drive PX-2 的离散 GPU 上不提供托管内存。

注意

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

另请参阅

CUresult cuMemAllocPitch ( CUdeviceptr* dptr, size_t* pPitch, size_t WidthInBytes, size_t Height, unsigned int ElementSizeBytes )

分配带跨距的设备内存。

参数

dptr: - 返回的设备指针
pPitch: - 返回分配的跨距（以字节为单位）
WidthInBytes: - 请求的分配宽度（以字节为单位）
Height: - 请求的分配高度（以行数计）
ElementSizeBytes: - 范围最大读取/写入大小

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY

描述

分配至少WidthInBytes * Height设备上的字节线性内存，并在以下位置返回*dptr指向已分配内存的指针。该函数可能会填充分配，以确保任何给定行中的对应指针在地址从一行更新到另一行时，继续满足合并的对齐要求。ElementSizeBytes指定将在内存范围内执行的最大读取和写入的大小。ElementSizeBytes可以是 4、8 或 16（因为合并的内存事务在其他数据大小上是不可能的）。如果ElementSizeBytes小于内核的实际读取/写入大小，则内核将正确运行，但速度可能会降低。在*pPitch中返回的跨距由 cuMemAllocPitch() 返回，是分配的宽度（以字节为单位）。跨距的预期用途是作为分配的单独参数，用于计算 2D 数组中的地址。给定类型为 T 的数组元素的行和列，地址计算为

‎   T* pElement = (T*)((char*)BaseAddress + Row * Pitch) + Column;

由 cuMemAllocPitch() 返回的跨距保证在所有情况下都与 cuMemcpy2D() 一起使用。对于 2D 数组的分配，建议程序员考虑使用 cuMemAllocPitch() 执行跨距分配。由于硬件中的对齐限制，如果应用程序将在设备内存的不同区域（无论是线性内存还是 CUDA 数组）之间执行 2D 内存复制，则尤其如此。

由 cuMemAllocPitch() 返回的跨距的字节对齐保证匹配或超过使用 cuTexRefSetAddress2D() 进行纹理绑定的对齐要求。

注意

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

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMallocPitch

CUresult cuMemBatchDecompressAsync ( CUmemDecompressParams* paramsArray, size_t count, unsigned int flags, size_t* errorIndex, CUstream stream )

提交一批count独立的解压缩操作。

参数

paramsArray: 描述独立解压缩操作的结构数组。
count: 中条目的数量paramsArray数组。
flags: 必须为 0。
errorIndex: 在paramsArray中，此函数返回的错误与之相关的解压缩操作的索引。如果index为 SIZE_MAX 并且返回的值不是 CUDA_SUCCESS，则此函数返回的错误应被视为不特定于特定解压缩操作的常规错误。可能是NULL，在这种情况下，如果发生错误，将不会记录索引。
stream: 将在其中排队工作的流。

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

每个count解压缩操作都由paramsArray数组中的单个条目描述。提交批处理后，该函数将返回，并且解压缩将相对于 CPU 异步发生。对于 CUDA 驱动程序中的工作完成跟踪机制，该批处理将被视为单个工作单元，并根据流语义进行处理，即，无法查询批处理中各个解压缩操作的完成情况。

每个 CUmemDecompressParams.src、CUmemDecompressParams.dst 和 CUmemDecompressParams.dstActBytes 指向的内存，都必须能够与硬件解压缩功能一起使用。也就是说，对于每个上述指针，指针属性 CU_POINTER_ATTRIBUTE_IS_MEM_DECOMPRESS_CAPABLE 应给出非零值。为了确保这一点，支持指针的内存应已使用以下 CUDA 内存分配器之一分配：* cuMemAlloc() * cuMemCreate()，使用标志 CU_MEM_CREATE_USAGE_HW_DECOMPRESS * cuMemAllocFromPoolAsync()，从使用标志 CU_MEM_POOL_CREATE_USAGE_HW_DECOMPRESS 创建的池中分配。此外，CUmemDecompressParams.src、CUmemDecompressParams.dst 和 CUmemDecompressParams.dstActBytes 都必须可以从与创建stream的上下文关联的设备访问。有关如何确保这一点的更多信息，请参阅有关感兴趣的分配器的文档。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
此函数对于大多数用例都表现出异步行为。
此函数使用标准的默认流语义。

另请参阅

cuMemAlloc, cuMemPoolCreate, cuMemAllocFromPoolAsync

CUresult cuMemFree ( CUdeviceptr dptr )

释放设备内存。

参数

dptr: - 要释放的内存指针

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

释放由dptr，必须是由先前调用以下内存分配 API 之一返回的指针 - cuMemAlloc(), cuMemAllocPitch(), cuMemAllocManaged(), cuMemAllocAsync(), cuMemAllocFromPoolAsync()

注意 - 当指针通过 cuMemAllocAsync 或 cuMemAllocFromPoolAsync 分配时，此 API 不会执行任何隐式同步。调用者必须确保在调用 cuMemFree 之前，对这些指针的所有访问均已完成。为了获得最佳性能和内存重用，用户应使用 cuMemFreeAsync 来释放通过流排序内存分配器分配的内存。对于所有其他指针，此 API 可能会执行隐式同步。

注意

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

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemAllocManaged, cuMemAllocAsync, cuMemAllocFromPoolAsync, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemFreeAsync, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaFree

CUresult cuMemFreeHost ( void* p )

释放页锁定主机内存。

参数

p: - 要释放的内存指针

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

释放由p，必须是由先前调用 cuMemAllocHost() 返回的指针。

注意

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

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaFreeHost

CUresult cuMemGetAddressRange ( CUdeviceptr* pbase, size_t* psize, CUdeviceptr dptr )

获取有关内存分配的信息。

参数

pbase: - 返回的基地址
psize: - 返回的设备内存分配大小
dptr: - 要查询的设备指针

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_NOT_FOUND, CUDA_ERROR_INVALID_VALUE

描述

返回分配的基地址，存储在*pbase中，以及大小，存储在*psize中。此分配是由 cuMemAlloc() 或 cuMemAllocPitch() 完成的，并且包含输入指针dptr。两个参数pbase和psize都是可选的。如果其中一个为 NULL，则会被忽略。

注意

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

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32

CUresult cuMemGetHandleForAddressRange ( void* handle, CUdeviceptr dptr, size_t size, CUmemRangeHandleType handleType, unsigned long long flags )

检索地址范围的句柄。

参数

handle: - 指向将存储返回句柄的位置的指针。
dptr: - 指向有效的 CUDA 设备分配的指针。必须与主机页面大小对齐。
size: - 地址范围的长度。必须与主机页面大小对齐。
handleType: - 请求的句柄类型（定义类型和大小handle输出参数）
flags: - 当请求 CUmemRangeHandleType::CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD 时，该值可以是 CU_MEM_RANGE_FLAG_DMA_BUF_MAPPING_TYPE_PCIE，否则为 0。

返回值

CUDA_SUCCESS CUDA_ERROR_INVALID_VALUE CUDA_ERROR_NOT_SUPPORTED

描述

获取指定类型的地址范围句柄。地址范围必须通过先前调用 cuMemAlloc 或 cuMemAddressReserve 获得。如果地址范围是通过 cuMemAddressReserve 获得的，则还必须通过 cuMemMap 完全映射。地址范围必须通过先前在 Tegra 上调用 cuMemAllocHost 或 cuMemHostAlloc 获得。

用户必须确保dptr和size与主机页面大小对齐。

当请求 CUmemRangeHandleType::CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD 时，用户应通过使用 CU_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORTED 设备属性来查询平台是否支持 dma_buf，然后再调用此 API。这个handle将被解释为指向整数的指针，用于存储 dma_buf 文件描述符。当地址范围由 cuMemAddressReserve 分配时，用户必须确保整个地址范围都被支持和映射。支持地址范围的所有物理分配必须驻留在同一设备上，并具有相同的分配属性。用户还需要每次当与先前查询的 VA 范围相对应的底层物理分配发生更改时，检索新的句柄。

对于 CUmemRangeHandleType::CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD，用户可以将标志设置为 CU_MEM_RANGE_FLAG_DMA_BUF_MAPPING_TYPE_PCIE。当在受支持的平台上设置此标志时，将给出通过 PCIE BAR1 映射的 DMA_BUF 句柄，否则将返回错误。

CUresult cuMemGetInfo ( size_t* free, size_t* total )

获取可用和总内存。

参数

free: - 返回的可用内存（以字节为单位）
total: - 返回的总内存（以字节为单位）

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

返回值在*total当前上下文可用的总内存量。返回到*free设备上根据操作系统报告的可用内存量。CUDA 不保证能够分配操作系统报告的所有可用内存。在多租户情况下，返回的可用内存估计值容易出现竞争条件，即在估计和报告可用内存的时间之间，由不同进程或同一进程中的不同线程完成的新分配/释放将导致报告的可用值与实际可用内存之间存在偏差。

Tegra 上的集成 GPU 与 CPU 和 SoC 的其他组件共享内存。API 返回的可用和总值不包括某些平台上操作系统维护的 SWAP 内存空间。当 GPU 或 CPU 分配或访问内存时，操作系统可能会将某些内存页面移动到交换区域。有关如何在 Tegra 上计算总内存和可用内存的信息，请参阅 Tegra 应用程序说明。

注意

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

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMemGetInfo

CUresult cuMemHostAlloc ( void** pp, size_t bytesize, unsigned int Flags )

分配页锁定主机内存。

参数

pp: - 返回的主机内存指针
bytesize: - 请求的分配大小（以字节为单位）
Flags: - 分配请求的标志

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY

描述

分配bytesize字节的主机内存，该内存已页锁定并且设备可访问。驱动程序跟踪使用此函数分配的虚拟内存范围，并自动加速对诸如 cuMemcpyHtoD() 之类函数的调用。由于设备可以直接访问内存，因此与使用 malloc() 等函数获得的可分页内存相比，它可以以更高的带宽进行读取或写入。

在 CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES 为 true 的系统上，cuMemHostAlloc 可能不会页锁定分配的内存。

页锁定过多的内存可能会降低系统性能，因为它减少了系统可用于分页的内存量。因此，此功能最好谨慎使用，以分配主机和设备之间数据交换的暂存区。

该Flags参数允许指定影响分配的不同选项，如下所示。

CU_MEMHOSTALLOC_PORTABLE：此调用返回的内存将被所有 CUDA 上下文视为固定内存，而不仅仅是执行分配的上下文。

CU_MEMHOSTALLOC_DEVICEMAP：将分配映射到 CUDA 地址空间。可以通过调用 cuMemHostGetDevicePointer() 来获取指向内存的设备指针。

CU_MEMHOSTALLOC_WRITECOMBINED：将内存分配为写组合 (WC)。在某些系统配置上，WC 内存可以通过 PCI Express 总线更快地传输，但大多数 CPU 无法有效地读取它。对于将由 CPU 写入并通过映射的固定内存或主机->设备传输由 GPU 读取的缓冲区，WC 内存是一个不错的选择。

所有这些标志彼此正交：开发人员可以分配可移植、已映射和/或写组合的内存，而没有任何限制。

在不支持映射锁定内存的设备上，CUDA 上下文可以指定 CU_MEMHOSTALLOC_DEVICEMAP 标志。失败会延迟到 cuMemHostGetDevicePointer()，因为内存可能通过 CU_MEMHOSTALLOC_PORTABLE 标志映射到其他 CUDA 上下文中。

通过此函数分配的内存必须使用 cuMemFreeHost() 释放。

请注意，所有使用 cuMemHostAlloc() 分配的主机内存将自动立即被所有支持统一寻址的设备上的所有上下文访问（可以使用 CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING 查询）。除非指定了标志 CU_MEMHOSTALLOC_WRITECOMBINED，否则可以从这些上下文访问此主机内存的设备指针始终等于返回的主机指针。*pp如果指定了标志 CU_MEMHOSTALLOC_WRITECOMBINED，则即使上下文支持统一寻址，也必须使用函数 cuMemHostGetDevicePointer() 来查询设备指针。有关更多详细信息，请参阅统一寻址。

注意

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

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaHostAlloc

CUresult cuMemHostGetDevicePointer ( CUdeviceptr* pdptr, void* p, unsigned int Flags )

返回映射锁定内存的设备指针。

参数

pdptr: - 返回的设备指针
p: - 主机指针
Flags: - 选项 (必须为 0)

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

返回设备指针，pdptr对应于由 cuMemHostAlloc 分配的p映射的、锁定的主机缓冲区。

如果内存分配时未指定 CU_MEMHOSTALLOC_DEVICEMAP 标志，或者在不支持映射锁定内存的 GPU 上调用该函数，cuMemHostGetDevicePointer() 将会失败。

对于设备属性 CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM 的值为非零的设备，也可以使用主机指针从设备访问内存。pcuMemHostGetDevicePointer() 返回的设备指针可能与原始主机指针匹配，也可能不匹配，p具体取决于应用程序可见的设备。如果应用程序可见的所有设备的设备属性值都为非零，则 cuMemHostGetDevicePointer() 返回的设备指针将与原始指针匹配。p如果应用程序可见的任何设备的设备属性值为零，则 cuMemHostGetDevicePointer() 返回的设备指针将与原始主机指针不匹配，p但只要启用了统一虚拟寻址，它就适用于所有设备。在这种系统中，在设备属性值为非零的设备上，使用这两个指针中的任何一个访问内存都是有效的。但是请注意，此类设备应仅使用两个指针之一访问内存，而不是同时使用两者。

Flags为未来版本提供。目前，它必须设置为 0。

注意

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

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaHostGetDevicePointer

CUresult cuMemHostGetFlags ( unsigned int* pFlags, void* p )

返回用于锁定分配的标志。

参数

pFlags: - 返回的标志字
p: - 主机指针

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

返回在分配锁定的主机缓冲区时pFlags指定的标志。p映射的、锁定的主机缓冲区。

如果指针不属于由 cuMemAllocHost() 或 cuMemHostAlloc() 执行的分配，cuMemHostGetFlags() 将会失败。

注意

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

另请参阅

cuMemAllocHost, cuMemHostAlloc, cudaHostGetFlags

CUresult cuMemHostRegister ( void* p, size_t bytesize, unsigned int Flags )

注册现有的主机内存范围以供 CUDA 使用。

参数

p: - 要页锁定的内存的主机指针
bytesize: - 要页锁定的地址范围的大小（以字节为单位）
Flags: - 分配请求的标志

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY, CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED, CUDA_ERROR_NOT_PERMITTED, CUDA_ERROR_NOT_SUPPORTED

描述

页锁定由p和bytesize指定的内存范围，并根据Flags的指定将其映射到设备。此内存范围也添加到与 cuMemHostAlloc 相同的跟踪机制中，以自动加速对诸如 cuMemcpyHtoD() 等函数的调用。由于设备可以直接访问内存，因此与未注册的页表内存相比，它可以以更高的带宽进行读写。页锁定过多的内存可能会降低系统性能，因为它减少了系统可用于分页的内存量。因此，此函数最好谨慎使用，用于注册主机和设备之间数据交换的暂存区。

在 CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES 为 true 的系统上，cuMemHostRegister 不会页锁定由ptr指定的内存范围，而只会填充未填充的页面。

该Flags参数允许指定影响分配的不同选项，如下所示。

CU_MEMHOSTREGISTER_PORTABLE：此调用返回的内存将被所有 CUDA 上下文（而不仅仅是执行分配的上下文）视为锁定内存。

CU_MEMHOSTREGISTER_DEVICEMAP：将分配映射到 CUDA 地址空间。可以通过调用 cuMemHostGetDevicePointer() 获取指向内存的设备指针。

CU_MEMHOSTREGISTER_IOMEMORY：指针被视为指向某些 I/O 内存空间，例如第三方设备的 PCI Express 资源。

CU_MEMHOSTREGISTER_READ_ONLY：指针被视为指向设备视为只读的内存。在没有 CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES 的平台上，需要此标志才能将映射到 CPU 的内存注册为只读。可以从设备属性 CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED 查询对此标志使用的支持。将此标志与当前上下文关联的设备（该设备未设置此属性）一起使用将导致 cuMemHostRegister 报错 CUDA_ERROR_NOT_SUPPORTED。

所有这些标志彼此正交：开发人员可以页锁定可移植或映射的内存，而没有任何限制。

在不支持映射锁定内存的设备上，CUDA 上下文可以指定 CU_MEMHOSTREGISTER_DEVICEMAP 标志。失败会延迟到 cuMemHostGetDevicePointer()，因为内存可能通过 CU_MEMHOSTREGISTER_PORTABLE 标志映射到其他 CUDA 上下文中。

对于设备属性 CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM 的值为非零的设备，也可以使用主机指针从设备访问内存。pcuMemHostGetDevicePointer() 返回的设备指针可能与原始主机指针匹配，也可能不匹配，ptr具体取决于应用程序可见的设备。如果应用程序可见的所有设备的设备属性值都为非零，则 cuMemHostGetDevicePointer() 返回的设备指针将与原始指针匹配。ptr如果应用程序可见的任何设备的设备属性值为零，则 cuMemHostGetDevicePointer() 返回的设备指针将与原始主机指针不匹配，ptr但只要启用了统一虚拟寻址，它就适用于所有设备。在这种系统中，在设备属性值为非零的设备上，使用这两个指针中的任何一个访问内存都是有效的。但是请注意，此类设备应仅使用两个指针之一访问内存，而不是同时使用两者。

由此函数页锁定的内存必须使用 cuMemHostUnregister() 取消注册。

注意

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

另请参阅

cuMemHostUnregister, cuMemHostGetFlags, cuMemHostGetDevicePointer, cudaHostRegister

CUresult cuMemHostUnregister ( void* p )

取消注册使用 cuMemHostRegister 注册的内存范围。

参数

p: - 要取消注册的内存的主机指针

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY, CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED,

描述

取消映射基地址由p指定的内存范围，并使其再次可分页。

基地址必须与 cuMemHostRegister() 指定的地址相同。

注意

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

另请参阅

cuMemHostRegister, cudaHostUnregister

CUresult cuMemcpy ( CUdeviceptr dst, CUdeviceptr src, size_t ByteCount )

复制内存。

参数

dst: - 目标统一虚拟地址空间指针
src: - 源统一虚拟地址空间指针
ByteCount: - 内存复制大小（以字节为单位）

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

在两个指针之间复制数据。dst和src分别是目标和源的基指针。ByteCount指定要复制的字节数。请注意，此函数从指针值推断传输类型（主机到主机、主机到设备、设备到设备或设备到主机）。此函数仅允许在支持统一寻址的上下文中使用。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。
请求的内存区域必须完全在 CUDA 中注册，或者对于主机可分页传输，则完全不注册。跨越同时在 CUDA 中注册和未注册的分配的内存区域不受支持，并将返回 CUDA_ERROR_INVALID_VALUE。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMemcpy, cudaMemcpyToSymbol, cudaMemcpyFromSymbol

CUresult cuMemcpy2D ( const CUDA_MEMCPY2D* pCopy )

复制 2D 数组的内存。

参数

pCopy: - 内存复制的参数

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

根据中指定的参数执行 2D 内存复制pCopy。CUDA_MEMCPY2D 结构的定义如下

‎   typedef struct CUDA_MEMCPY2D_st {
            unsigned int srcXInBytes, srcY;
            CUmemorytype srcMemoryType;
                const void *srcHost;
                CUdeviceptr srcDevice;
                CUarray srcArray;
                unsigned int srcPitch;
      
            unsigned int dstXInBytes, dstY;
            CUmemorytype dstMemoryType;
                void *dstHost;
                CUdeviceptr dstDevice;
                CUarray dstArray;
                unsigned int dstPitch;
      
            unsigned int WidthInBytes;
            unsigned int Height;
         } CUDA_MEMCPY2D;

其中

srcMemoryType 和 dstMemoryType 分别指定源和目标的内存类型；CUmemorytype_enum 定义为

‎   typedef enum CUmemorytype_enum {
            CU_MEMORYTYPE_HOST = 0x01,
            CU_MEMORYTYPE_DEVICE = 0x02,
            CU_MEMORYTYPE_ARRAY = 0x03,
            CU_MEMORYTYPE_UNIFIED = 0x04
         } CUmemorytype;

如果 srcMemoryType 是 CU_MEMORYTYPE_UNIFIED，则 srcDevice 和 srcPitch 指定源数据的（统一虚拟地址空间）基地址和应用的每行字节数。srcArray 被忽略。此值只能在调用上下文中支持统一寻址时使用。

如果 srcMemoryType 是 CU_MEMORYTYPE_HOST，则 srcHost 和 srcPitch 指定源数据的（主机）基地址和应用的每行字节数。srcArray 被忽略。

如果 srcMemoryType 是 CU_MEMORYTYPE_DEVICE，则 srcDevice 和 srcPitch 指定源数据的（设备）基地址和应用的每行字节数。srcArray 被忽略。

如果 srcMemoryType 是 CU_MEMORYTYPE_ARRAY，则 srcArray 指定源数据的句柄。srcHost、srcDevice 和 srcPitch 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_HOST，则 dstHost 和 dstPitch 指定目标数据的（主机）基地址和应用的每行字节数。dstArray 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_UNIFIED，则 dstDevice 和 dstPitch 指定源数据的（统一虚拟地址空间）基地址和应用的每行字节数。dstArray 被忽略。此值只能在调用上下文中支持统一寻址时使用。

如果 dstMemoryType 是 CU_MEMORYTYPE_DEVICE，则 dstDevice 和 dstPitch 指定目标数据的（设备）基地址和应用的每行字节数。dstArray 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_ARRAY，则 dstArray 指定目标数据的句柄。dstHost、dstDevice 和 dstPitch 被忽略。

srcXInBytes 和 srcY 指定复制的源数据基地址。

对于主机指针，起始地址为

‎  void* Start = (void*)((char*)srcHost+srcY*srcPitch + srcXInBytes);

对于设备指针，起始地址为

‎  CUdeviceptr Start = srcDevice+srcY*srcPitch+srcXInBytes;

对于 CUDA 数组，srcXInBytes 必须可以被数组元素大小整除。

dstXInBytes 和 dstY 指定复制的目标数据基地址。

对于主机指针，基地址为

‎  void* dstStart = (void*)((char*)dstHost+dstY*dstPitch + dstXInBytes);

对于设备指针，起始地址为

‎  CUdeviceptr dstStart = dstDevice+dstY*dstPitch+dstXInBytes;

对于 CUDA 数组，dstXInBytes 必须可以被数组元素大小整除。

WidthInBytes 和 Height 指定正在执行的 2D 复制的宽度（以字节为单位）和高度。
如果指定，srcPitch 必须大于或等于 WidthInBytes + srcXInBytes，并且 dstPitch 必须大于或等于 WidthInBytes + dstXInBytes。

cuMemcpy2D() 如果任何跨距大于允许的最大值（CU_DEVICE_ATTRIBUTE_MAX_PITCH），则返回错误。cuMemAllocPitch() 返回的跨距始终适用于 cuMemcpy2D()。在设备内内存复制（设备到设备，CUDA 数组到设备，CUDA 数组到 CUDA 数组）中，对于非 cuMemAllocPitch() 计算的跨距，cuMemcpy2D() 可能会失败。cuMemcpy2DUnaligned() 没有此限制，但在 cuMemcpy2D() 将返回错误代码的情况下，运行速度可能会明显降低。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync

CUresult cuMemcpy2DAsync ( const CUDA_MEMCPY2D* pCopy, CUstream hStream )

复制 2D 数组的内存。

参数

pCopy: - 内存复制的参数
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

根据中指定的参数执行 2D 内存复制pCopy。CUDA_MEMCPY2D 结构的定义如下

‎   typedef struct CUDA_MEMCPY2D_st {
            unsigned int srcXInBytes, srcY;
            CUmemorytype srcMemoryType;
            const void *srcHost;
            CUdeviceptr srcDevice;
            CUarray srcArray;
            unsigned int srcPitch;
            unsigned int dstXInBytes, dstY;
            CUmemorytype dstMemoryType;
            void *dstHost;
            CUdeviceptr dstDevice;
            CUarray dstArray;
            unsigned int dstPitch;
            unsigned int WidthInBytes;
            unsigned int Height;
         } CUDA_MEMCPY2D;

其中

srcMemoryType 和 dstMemoryType 分别指定源和目标的内存类型；CUmemorytype_enum 定义为

‎   typedef enum CUmemorytype_enum {
            CU_MEMORYTYPE_HOST = 0x01,
            CU_MEMORYTYPE_DEVICE = 0x02,
            CU_MEMORYTYPE_ARRAY = 0x03,
            CU_MEMORYTYPE_UNIFIED = 0x04
         } CUmemorytype;

如果 srcMemoryType 是 CU_MEMORYTYPE_HOST，则 srcHost 和 srcPitch 指定源数据的（主机）基地址和应用的每行字节数。srcArray 被忽略。

如果 srcMemoryType 是 CU_MEMORYTYPE_DEVICE，则 srcDevice 和 srcPitch 指定源数据的（设备）基地址和应用的每行字节数。srcArray 被忽略。

如果 srcMemoryType 是 CU_MEMORYTYPE_ARRAY，则 srcArray 指定源数据的句柄。srcHost、srcDevice 和 srcPitch 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_HOST，则 dstHost 和 dstPitch 指定目标数据的（主机）基地址和应用的每行字节数。dstArray 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_DEVICE，则 dstDevice 和 dstPitch 指定目标数据的（设备）基地址和应用的每行字节数。dstArray 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_ARRAY，则 dstArray 指定目标数据的句柄。dstHost、dstDevice 和 dstPitch 被忽略。

srcXInBytes 和 srcY 指定复制的源数据基地址。

对于主机指针，起始地址为

‎  void* Start = (void*)((char*)srcHost+srcY*srcPitch + srcXInBytes);

对于设备指针，起始地址为

‎  CUdeviceptr Start = srcDevice+srcY*srcPitch+srcXInBytes;

对于 CUDA 数组，srcXInBytes 必须可以被数组元素大小整除。

dstXInBytes 和 dstY 指定复制的目标数据基地址。

对于主机指针，基地址为

‎  void* dstStart = (void*)((char*)dstHost+dstY*dstPitch + dstXInBytes);

对于设备指针，起始地址为

‎  CUdeviceptr dstStart = dstDevice+dstY*dstPitch+dstXInBytes;

对于 CUDA 数组，dstXInBytes 必须可以被数组元素大小整除。

WidthInBytes 和 Height 指定正在执行的 2D 复制的宽度（以字节为单位）和高度。
如果指定，srcPitch 必须大于或等于 WidthInBytes + srcXInBytes，并且 dstPitch 必须大于或等于 WidthInBytes + dstXInBytes。
如果指定，srcPitch 必须大于或等于 WidthInBytes + srcXInBytes，并且 dstPitch 必须大于或等于 WidthInBytes + dstXInBytes。
如果指定，srcHeight 必须大于或等于 Height + srcY，并且 dstHeight 必须大于或等于 Height + dstY。

cuMemcpy2DAsync() 如果任何跨距大于允许的最大值（CU_DEVICE_ATTRIBUTE_MAX_PITCH），则返回错误。cuMemAllocPitch() 返回的跨距始终适用于 cuMemcpy2D()。在设备内内存复制（设备到设备，CUDA 数组到设备，CUDA 数组到 CUDA 数组）中，对于非 cuMemAllocPitch() 计算的跨距，cuMemcpy2DAsync() 可能会失败。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
此函数对于大多数用例都表现出异步行为。
此函数使用标准的默认流语义。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync

CUresult cuMemcpy2DUnaligned ( const CUDA_MEMCPY2D* pCopy )

复制 2D 数组的内存。

参数

pCopy: - 内存复制的参数

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

根据中指定的参数执行 2D 内存复制pCopy。CUDA_MEMCPY2D 结构的定义如下

‎   typedef struct CUDA_MEMCPY2D_st {
            unsigned int srcXInBytes, srcY;
            CUmemorytype srcMemoryType;
            const void *srcHost;
            CUdeviceptr srcDevice;
            CUarray srcArray;
            unsigned int srcPitch;
            unsigned int dstXInBytes, dstY;
            CUmemorytype dstMemoryType;
            void *dstHost;
            CUdeviceptr dstDevice;
            CUarray dstArray;
            unsigned int dstPitch;
            unsigned int WidthInBytes;
            unsigned int Height;
         } CUDA_MEMCPY2D;

其中

srcMemoryType 和 dstMemoryType 分别指定源和目标的内存类型；CUmemorytype_enum 定义为

‎   typedef enum CUmemorytype_enum {
            CU_MEMORYTYPE_HOST = 0x01,
            CU_MEMORYTYPE_DEVICE = 0x02,
            CU_MEMORYTYPE_ARRAY = 0x03,
            CU_MEMORYTYPE_UNIFIED = 0x04
         } CUmemorytype;

如果 srcMemoryType 是 CU_MEMORYTYPE_HOST，则 srcHost 和 srcPitch 指定源数据的（主机）基地址和应用的每行字节数。srcArray 被忽略。

如果 srcMemoryType 是 CU_MEMORYTYPE_DEVICE，则 srcDevice 和 srcPitch 指定源数据的（设备）基地址和应用的每行字节数。srcArray 被忽略。

如果 srcMemoryType 是 CU_MEMORYTYPE_ARRAY，则 srcArray 指定源数据的句柄。srcHost、srcDevice 和 srcPitch 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_HOST，则 dstHost 和 dstPitch 指定目标数据的（主机）基地址和应用的每行字节数。dstArray 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_DEVICE，则 dstDevice 和 dstPitch 指定目标数据的（设备）基地址和应用的每行字节数。dstArray 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_ARRAY，则 dstArray 指定目标数据的句柄。dstHost、dstDevice 和 dstPitch 被忽略。

srcXInBytes 和 srcY 指定复制的源数据基地址。

对于主机指针，起始地址为

‎  void* Start = (void*)((char*)srcHost+srcY*srcPitch + srcXInBytes);

对于设备指针，起始地址为

‎  CUdeviceptr Start = srcDevice+srcY*srcPitch+srcXInBytes;

对于 CUDA 数组，srcXInBytes 必须可以被数组元素大小整除。

dstXInBytes 和 dstY 指定复制的目标数据基地址。

对于主机指针，基地址为

‎  void* dstStart = (void*)((char*)dstHost+dstY*dstPitch + dstXInBytes);

对于设备指针，起始地址为

‎  CUdeviceptr dstStart = dstDevice+dstY*dstPitch+dstXInBytes;

对于 CUDA 数组，dstXInBytes 必须可以被数组元素大小整除。

WidthInBytes 和 Height 指定正在执行的 2D 复制的宽度（以字节为单位）和高度。
如果指定，srcPitch 必须大于或等于 WidthInBytes + srcXInBytes，并且 dstPitch 必须大于或等于 WidthInBytes + dstXInBytes。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DFromArray

CUresult cuMemcpy3D ( const CUDA_MEMCPY3D* pCopy )

复制 3D 数组的内存。

参数

pCopy: - 内存复制的参数

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

根据中指定的参数执行 3D 内存复制pCopy。CUDA_MEMCPY3D 结构的定义如下

‎        typedef struct CUDA_MEMCPY3D_st {
      
                  unsigned int srcXInBytes, srcY, srcZ;
                  unsigned int srcLOD;
                  CUmemorytype srcMemoryType;
                      const void *srcHost;
                      CUdeviceptr srcDevice;
                      CUarray srcArray;
                      unsigned int srcPitch;  // ignored when src is array
                      unsigned int srcHeight; // ignored when src is array; may be 0 if Depth==1
      
                  unsigned int dstXInBytes, dstY, dstZ;
                  unsigned int dstLOD;
                  CUmemorytype dstMemoryType;
                      void *dstHost;
                      CUdeviceptr dstDevice;
                      CUarray dstArray;
                      unsigned int dstPitch;  // ignored when dst is array
                      unsigned int dstHeight; // ignored when dst is array; may be 0 if Depth==1
      
                  unsigned int WidthInBytes;
                  unsigned int Height;
                  unsigned int Depth;
              } CUDA_MEMCPY3D;

其中

srcMemoryType 和 dstMemoryType 分别指定源和目标的内存类型；CUmemorytype_enum 定义为

‎   typedef enum CUmemorytype_enum {
            CU_MEMORYTYPE_HOST = 0x01,
            CU_MEMORYTYPE_DEVICE = 0x02,
            CU_MEMORYTYPE_ARRAY = 0x03,
            CU_MEMORYTYPE_UNIFIED = 0x04
         } CUmemorytype;

如果 srcMemoryType 是 CU_MEMORYTYPE_HOST，则 srcHost、srcPitch 和 srcHeight 指定源数据的（主机）基地址、每行字节数以及 3D 数组的每个 2D 切片的高度。srcArray 被忽略。

如果 srcMemoryType 是 CU_MEMORYTYPE_DEVICE，则 srcDevice、srcPitch 和 srcHeight 指定源数据的（设备）基地址、每行字节数以及 3D 数组的每个 2D 切片的高度。srcArray 被忽略。

如果 srcMemoryType 是 CU_MEMORYTYPE_ARRAY，则 srcArray 指定源数据的句柄。srcHost、srcDevice、srcPitch 和 srcHeight 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_HOST，则 dstHost 和 dstPitch 指定目标数据的（主机）基地址、每行字节数以及 3D 数组的每个 2D 切片的高度。dstArray 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_DEVICE，则 dstDevice 和 dstPitch 指定目标数据的（设备）基地址、每行字节数以及 3D 数组的每个 2D 切片的高度。dstArray 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_ARRAY，则 dstArray 指定目标数据的句柄。dstHost、dstDevice、dstPitch 和 dstHeight 被忽略。

srcXInBytes、srcY 和 srcZ 指定复制的源数据基地址。

对于主机指针，起始地址为

‎  void* Start = (void*)((char*)srcHost+(srcZ*srcHeight+srcY)*srcPitch + srcXInBytes);

对于设备指针，起始地址为

‎  CUdeviceptr Start = srcDevice+(srcZ*srcHeight+srcY)*srcPitch+srcXInBytes;

对于 CUDA 数组，srcXInBytes 必须可以被数组元素大小整除。

dstXInBytes、dstY 和 dstZ 指定复制的目标数据基地址。

对于主机指针，基地址为

‎  void* dstStart = (void*)((char*)dstHost+(dstZ*dstHeight+dstY)*dstPitch + dstXInBytes);

对于设备指针，起始地址为

‎  CUdeviceptr dstStart = dstDevice+(dstZ*dstHeight+dstY)*dstPitch+dstXInBytes;

对于 CUDA 数组，dstXInBytes 必须可以被数组元素大小整除。

WidthInBytes、Height 和 Depth 指定正在执行的 3D 复制的宽度（以字节为单位）、高度和深度。
如果指定，srcPitch 必须大于或等于 WidthInBytes + srcXInBytes，并且 dstPitch 必须大于或等于 WidthInBytes + dstXInBytes。
如果指定，srcHeight 必须大于或等于 Height + srcY，并且 dstHeight 必须大于或等于 Height + dstY。

cuMemcpy3D() 如果任何跨距大于允许的最大值（CU_DEVICE_ATTRIBUTE_MAX_PITCH），则返回错误。

CUDA_MEMCPY3D 结构的 srcLOD 和 dstLOD 成员必须设置为 0。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMemcpy3D

CUresult cuMemcpy3DAsync ( const CUDA_MEMCPY3D* pCopy, CUstream hStream )

复制 3D 数组的内存。

参数

pCopy: - 内存复制的参数
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

根据中指定的参数执行 3D 内存复制pCopy。CUDA_MEMCPY3D 结构的定义如下

‎        typedef struct CUDA_MEMCPY3D_st {
      
                  unsigned int srcXInBytes, srcY, srcZ;
                  unsigned int srcLOD;
                  CUmemorytype srcMemoryType;
                      const void *srcHost;
                      CUdeviceptr srcDevice;
                      CUarray srcArray;
                      unsigned int srcPitch;  // ignored when src is array
                      unsigned int srcHeight; // ignored when src is array; may be 0 if Depth==1
      
                  unsigned int dstXInBytes, dstY, dstZ;
                  unsigned int dstLOD;
                  CUmemorytype dstMemoryType;
                      void *dstHost;
                      CUdeviceptr dstDevice;
                      CUarray dstArray;
                      unsigned int dstPitch;  // ignored when dst is array
                      unsigned int dstHeight; // ignored when dst is array; may be 0 if Depth==1
      
                  unsigned int WidthInBytes;
                  unsigned int Height;
                  unsigned int Depth;
              } CUDA_MEMCPY3D;

其中

srcMemoryType 和 dstMemoryType 分别指定源和目标的内存类型；CUmemorytype_enum 定义为

‎   typedef enum CUmemorytype_enum {
            CU_MEMORYTYPE_HOST = 0x01,
            CU_MEMORYTYPE_DEVICE = 0x02,
            CU_MEMORYTYPE_ARRAY = 0x03,
            CU_MEMORYTYPE_UNIFIED = 0x04
         } CUmemorytype;

如果 srcMemoryType 是 CU_MEMORYTYPE_ARRAY，则 srcArray 指定源数据的句柄。srcHost、srcDevice、srcPitch 和 srcHeight 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_HOST，则 dstHost 和 dstPitch 指定目标数据的（主机）基地址、每行字节数以及 3D 数组的每个 2D 切片的高度。dstArray 被忽略。

如果 dstMemoryType 是 CU_MEMORYTYPE_ARRAY，则 dstArray 指定目标数据的句柄。dstHost、dstDevice、dstPitch 和 dstHeight 被忽略。

srcXInBytes、srcY 和 srcZ 指定复制的源数据基地址。

对于主机指针，起始地址为

‎  void* Start = (void*)((char*)srcHost+(srcZ*srcHeight+srcY)*srcPitch + srcXInBytes);

对于设备指针，起始地址为

‎  CUdeviceptr Start = srcDevice+(srcZ*srcHeight+srcY)*srcPitch+srcXInBytes;

对于 CUDA 数组，srcXInBytes 必须可以被数组元素大小整除。

dstXInBytes、dstY 和 dstZ 指定复制的目标数据基地址。

对于主机指针，基地址为

‎  void* dstStart = (void*)((char*)dstHost+(dstZ*dstHeight+dstY)*dstPitch + dstXInBytes);

对于设备指针，起始地址为

‎  CUdeviceptr dstStart = dstDevice+(dstZ*dstHeight+dstY)*dstPitch+dstXInBytes;

对于 CUDA 数组，dstXInBytes 必须可以被数组元素大小整除。

WidthInBytes、Height 和 Depth 指定正在执行的 3D 复制的宽度（以字节为单位）、高度和深度。
如果指定，srcPitch 必须大于或等于 WidthInBytes + srcXInBytes，并且 dstPitch 必须大于或等于 WidthInBytes + dstXInBytes。
如果指定，srcHeight 必须大于或等于 Height + srcY，并且 dstHeight 必须大于或等于 Height + dstY。

cuMemcpy3DAsync() 如果任何 pitch 大于允许的最大值（CU_DEVICE_ATTRIBUTE_MAX_PITCH），则返回错误。

CUDA_MEMCPY3D 结构的 srcLOD 和 dstLOD 成员必须设置为 0。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
此函数对于大多数用例都表现出异步行为。
此函数使用标准的默认流语义。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemcpy3DAsync

CUresult cuMemcpy3DBatchAsync ( size_t numOps, CUDA_MEMCPY3D_BATCH_OP* opList, size_t* failIdx, unsigned long long flags, CUstream hStream )

异步执行一批 3D 内存复制。

参数

numOps: - memcpy 操作的总数。
opList: - 大小为numOps的数组，包含实际的 memcpy 操作。
failIdx: - 指向一个位置的指针，用于返回遇到故障的复制操作的索引。如果错误不属于任何特定的复制操作，则该值将为 SIZE_MAX。
flags: - 供将来使用的标志，现在必须为零。
hStream: - 用于将操作排队的流。不得为默认 NULL 流。

返回值

CUDA_SUCCESS CUDA_ERROR_DEINITIALIZED CUDA_ERROR_NOT_INITIALIZED CUDA_ERROR_INVALID_VALUE

描述

执行一批内存复制。整个批处理按照流顺序执行，但批处理中的复制操作不保证以任何特定顺序执行。请注意，这意味着在批处理中指定任何依赖性复制操作将导致未定义的行为。

按照opList数组中指定的执行内存复制。此数组的长度在numOps中指定。此数组中的每个条目都描述一个复制操作。其中包括复制操作的源操作数和目标操作数，分别在 CUDA_MEMCPY3D_BATCH_OP::src 和 CUDA_MEMCPY3D_BATCH_OP::dst 中指定。复制操作的源操作数和目标操作数可以是指针或 CUDA 数组。复制操作的宽度、高度和深度在 CUDA_MEMCPY3D_BATCH_OP::extent 中指定。复制操作的宽度、高度和深度以元素为单位指定，且不得为零。对于指针到指针的复制，元素大小被视为 1。对于指针到 CUDA 数组或反之亦然的复制，元素大小由 CUDA 数组确定。对于 CUDA 数组到 CUDA 数组的复制，两个 CUDA 数组的元素大小必须匹配。

对于给定的操作数，如果 CUmemcpy3DOperand::type 指定为 CU_MEMCPY_OPERAND_TYPE_POINTER，则将使用 CUmemcpy3DOperand::op::ptr。CUmemcpy3DOperand::op::ptr::ptr 字段必须包含复制应开始的指针。CUmemcpy3DOperand::op::ptr::rowLength 字段指定每行元素的长度，并且必须为零或大于或等于 CUDA_MEMCPY3D_BATCH_OP::extent::width 中指定的复制宽度。CUmemcpy3DOperand::op::ptr::layerHeight 字段指定每层的高度，并且必须为零或大于或等于 CUDA_MEMCPY3D_BATCH_OP::extent::height 中指定的复制高度。当这些值中的任何一个为零时，操作数的该方面被视为根据复制范围紧密打包。对于设备上托管内存指针，其中 CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS 为 true，或者对于设备上系统分配的可分页内存，其中 CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS 为 true，可以使用 CUmemcpy3DOperand::op::ptr::locHint 字段来提示操作数的位置。

如果操作数的类型指定为 CU_MEMCPY_OPERAND_TYPE_ARRAY，则将使用 CUmemcpy3DOperand::op::array。CUmemcpy3DOperand::op::array::array 字段指定 CUDA 数组，而 CUmemcpy3DOperand::op::array::offset 指定复制开始位置在该数组中的 3D 偏移量。

CUmemcpyAttributes::srcAccessOrder 指示与属性关联的复制操作要遵守的源访问顺序。如果源访问顺序设置为 CU_MEMCPY_SRC_ACCESS_ORDER_STREAM，则将按照流顺序访问源。如果源访问顺序设置为 CU_MEMCPY_SRC_ACCESS_ORDER_DURING_API_CALL，则表示对源指针的访问可以不按流顺序进行，并且所有访问都必须在 API 调用返回之前完成。此标志适用于临时源（例如，堆栈变量），当已知流中先前的操作无法访问内存，并且内存的生命周期仅限于声明源变量的作用域时。指定此标志允许驱动程序优化复制操作，并消除用户在 API 调用后同步流的需要。如果源访问顺序设置为 CU_MEMCPY_SRC_ACCESS_ORDER_ANY，则表示对源指针的访问可以不按流顺序进行，并且访问甚至可以在 API 调用返回后发生。此标志适用于在 CUDA 外部分配的主机指针（例如，通过 malloc 分配），当已知流中先前的操作无法访问内存时。指定此标志允许驱动程序在某些平台上优化复制操作。中的每个内存复制操作opList都必须具有有效的 srcAccessOrder 设置，否则此 API 将返回 CUDA_ERROR_INVALID_VALUE。

CUmemcpyAttributes::flags 字段可用于为复制操作指定某些标志。设置 CU_MEMCPY_FLAG_PREFER_OVERLAP_WITH_COMPUTE 标志表示关联的复制操作应尽可能与任何计算工作重叠。请注意，此标志是一个提示，并且可以根据平台和复制操作的其他参数而被忽略。

如果在解析批处理时遇到任何错误，则将在failIdx.

注意

请注意，此函数也可能返回先前异步启动的错误代码。
此函数对于大多数用例都表现出异步行为。
请求的内存区域必须完全在 CUDA 中注册，或者对于主机可分页传输，则完全不注册。跨越同时在 CUDA 中注册和未注册的分配的内存区域不受支持，并将返回 CUDA_ERROR_INVALID_VALUE。

CUresult cuMemcpy3DPeer ( const CUDA_MEMCPY3D_PEER* pCopy )

在上下文之间复制内存。

参数

pCopy: - 内存复制的参数

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

根据中指定的参数执行 3D 内存复制pCopy。有关其参数的文档，请参阅 CUDA_MEMCPY3D_PEER 结构的定义。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。

另请参阅

cuMemcpyDtoD, cuMemcpyPeer, cuMemcpyDtoDAsync, cuMemcpyPeerAsync, cuMemcpy3DPeerAsync, cudaMemcpy3DPeer

CUresult cuMemcpy3DPeerAsync ( const CUDA_MEMCPY3D_PEER* pCopy, CUstream hStream )

异步地在上下文之间复制内存。

参数

pCopy: - 内存复制的参数
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

根据中指定的参数执行 3D 内存复制pCopy。有关其参数的文档，请参阅 CUDA_MEMCPY3D_PEER 结构的定义。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
此函数对于大多数用例都表现出异步行为。
此函数使用标准的默认流语义。

另请参阅

cuMemcpyDtoD, cuMemcpyPeer, cuMemcpyDtoDAsync, cuMemcpyPeerAsync, cuMemcpy3DPeerAsync, cudaMemcpy3DPeerAsync

CUresult cuMemcpyAsync ( CUdeviceptr dst, CUdeviceptr src, size_t ByteCount, CUstream hStream )

异步复制内存。

参数

dst: - 目标统一虚拟地址空间指针
src: - 源统一虚拟地址空间指针
ByteCount: - 内存复制大小（以字节为单位）
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

注意

请注意，此函数也可能返回先前异步启动的错误代码。
此函数对于大多数用例都表现出异步行为。
此函数使用标准的默认流语义。
请求的内存区域必须完全在 CUDA 中注册，或者对于主机可分页传输，则完全不注册。跨越同时在 CUDA 中注册和未注册的分配的内存区域不受支持，并将返回 CUDA_ERROR_INVALID_VALUE。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemcpyAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync

CUresult cuMemcpyAtoA ( CUarray dstArray, size_t dstOffset, CUarray srcArray, size_t srcOffset, size_t ByteCount )

将内存从数组复制到数组。

参数

dstArray: - 目标数组
dstOffset: - 目标数组的字节偏移量
srcArray: - 源数组
srcOffset: - 源数组的字节偏移量
ByteCount: - 内存复制大小（以字节为单位）

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将一个 1D CUDA 数组复制到另一个。dstArray和srcArray分别指定复制操作的目标和源 CUDA 数组的句柄。dstOffset和srcOffset指定 CUDA 数组中目标和源的字节偏移量。ByteCount是要复制的字节数。CUDA 数组中元素的大小格式不必相同，但元素的大小必须相同；并且 count 必须能被该大小整除。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMemcpyArrayToArray

CUresult cuMemcpyAtoD ( CUdeviceptr dstDevice, CUarray srcArray, size_t srcOffset, size_t ByteCount )

从数组复制内存到设备。

参数

dstDevice: - 目标设备指针
srcArray: - 源数组
srcOffset: - 源数组的字节偏移量
ByteCount: - 内存复制大小（以字节为单位）

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

从一个 1D CUDA 数组复制到设备内存。dstDevice指定目标基址指针，并且必须与 CUDA 数组元素自然对齐。srcArray和srcOffset指定 CUDA 数组句柄和复制开始的数组字节偏移量。ByteCount指定要复制的字节数，并且必须可以被数组元素大小整除。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMemcpyFromArray

CUresult cuMemcpyAtoH ( void* dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount )

从数组复制内存到主机。

参数

dstHost: - 目标设备指针
srcArray: - 源数组
srcOffset: - 源数组的字节偏移量
ByteCount: - 内存复制大小（以字节为单位）

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

从一个 1D CUDA 数组复制到主机内存。dstHost指定目标基址指针。srcArray和srcOffset指定 CUDA 数组句柄和源数据的起始字节偏移量。ByteCount指定要复制的字节数。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。
请求的内存区域必须完全在 CUDA 中注册，或者对于主机可分页传输，则完全不注册。跨越同时在 CUDA 中注册和未注册的分配的内存区域不受支持，并将返回 CUDA_ERROR_INVALID_VALUE。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMemcpyFromArray

CUresult cuMemcpyAtoHAsync ( void* dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount, CUstream hStream )

从数组复制内存到主机。

参数

dstHost: - 目标指针
srcArray: - 源数组
srcOffset: - 源数组的字节偏移量
ByteCount: - 内存复制大小（以字节为单位）
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

注意

请注意，此函数也可能返回先前异步启动的错误代码。
此函数对于大多数用例都表现出异步行为。
此函数使用标准的默认流语义。
请求的内存区域必须完全在 CUDA 中注册，或者对于主机可分页传输，则完全不注册。跨越同时在 CUDA 中注册和未注册的分配的内存区域不受支持，并将返回 CUDA_ERROR_INVALID_VALUE。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemcpyFromArrayAsync

CUresult cuMemcpyBatchAsync ( CUdeviceptr* dsts, CUdeviceptr* srcs, size_t* sizes, size_t count, CUmemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, size_t* failIdx, CUstream hStream )

异步执行一批内存复制操作。

参数

dsts: - 目标指针数组。
srcs: - memcpy 源指针数组。
sizes: - memcpy 操作的大小数组。
count: - 的大小dsts, srcs和sizes数组
attrs: - memcpy 属性数组。
attrsIdxs: - 索引数组，用于指定attrs数组中的每个条目应用于哪些复制操作。attrs[k] 中指定的属性将应用于从 attrsIdxs[k] 到 attrsIdxs[k+1] - 1 的复制操作。此外，attrs[numAttrs-1] 将应用于从 attrsIdxs[numAttrs-1] 到 count - 1 的复制操作。
numAttrs: - 的大小attrs和attrsIdxs数组。
failIdx: - 指向一个位置的指针，用于返回遇到故障的复制操作的索引。如果错误不属于任何特定的复制操作，则该值将为 SIZE_MAX。
hStream: - 将操作排队的流。不能是遗留 NULL 流。

返回值

CUDA_SUCCESS CUDA_ERROR_DEINITIALIZED CUDA_ERROR_NOT_INITIALIZED CUDA_ERROR_INVALID_VALUE

描述

执行一批内存复制操作。批处理作为一个整体按流顺序执行，但批处理中的复制操作不保证以任何特定顺序执行。此 API 仅支持指针到指针的复制。对于涉及 CUDA 数组的复制，请参阅 cuMemcpy3DBatchAsync。

执行从srcs中指定的源缓冲区到dsts中指定的目标缓冲区的内存复制操作。sizes中指定了每次复制的大小。count。所有三个数组的长度必须相同，由

指定。由于不保证批处理中复制操作的顺序，因此在批处理中指定任何依赖复制操作将导致未定义的行为。attrs批处理中的每个复制操作都必须与attrsIdxs数组中指定的一组属性关联。此数组中的每个条目可以应用于多个复制操作。这可以通过在attrs数组中指定attrs和attrsIdxs数组中的相应条目应用于的第一个复制操作的索引来完成。和numAttrs的长度必须相同，由numAttrs指定。例如，如果一个批处理在 dst/src/sizes 中列出了 10 个复制操作，其中前 6 个具有一组属性，其余 4 个具有另一组属性，则attrsIdxs将为 2，attrs将为 {0, 6}，并且attrsIdxs将包含两组属性。请注意，count中的第一个条目必须始终为 0。此外，每个条目必须大于前一个条目，并且最后一个条目应小于numAttrs。count.

此外，

必须小于或等于

如果在解析批处理时遇到任何错误，则将在failIdx.

注意

请注意，此函数也可能返回先前异步启动的错误代码。
此函数对于大多数用例都表现出异步行为。
请求的内存区域必须完全在 CUDA 中注册，或者对于主机可分页传输，则完全不注册。跨越同时在 CUDA 中注册和未注册的分配的内存区域不受支持，并将返回 CUDA_ERROR_INVALID_VALUE。

。CUmemcpyAttributes::srcAccessOrder 指示要为与属性关联的复制操作观察的源访问顺序。如果源访问顺序设置为 CU_MEMCPY_SRC_ACCESS_ORDER_STREAM，则将按流顺序访问源。如果源访问顺序设置为 CU_MEMCPY_SRC_ACCESS_ORDER_DURING_API_CALL，则表示对源指针的访问可能不按流顺序，并且所有访问都必须在 API 调用返回之前完成。此标志适用于临时源（例如，堆栈变量），当已知流中没有先前的操作可以访问内存，并且内存的生命周期也限制在声明源变量的作用域内时。指定此标志允许驱动程序优化复制操作，并消除用户在 API 调用后同步流的需要。如果源访问顺序设置为 CU_MEMCPY_SRC_ACCESS_ORDER_ANY，则表示对源指针的访问可能不按流顺序，并且访问甚至可以在 API 调用返回后发生。此标志适用于在 CUDA 外部分配的主机指针（例如，通过 malloc），当已知流中没有先前的操作可以访问内存时。指定此标志允许驱动程序在某些平台上优化复制操作。批处理中的每个 memcpy 操作都必须具有有效的 CUmemcpyAttributes，包括相应的 srcAccessOrder 设置，否则 API 将返回 CUDA_ERROR_INVALID_VALUE。

。CUmemcpyAttributes::srcLocHint 和 CUmemcpyAttributes::dstLocHint 允许应用程序在操作数没有固定位置时，为复制操作的操作数指定提示位置。也就是说，这些提示仅适用于 CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS 为 true 的设备上的托管内存指针，或者 CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS 为 true 的设备上的系统分配的可分页内存。对于其他情况，这些提示将被忽略。

参数

dstArray: - 目标数组
dstOffset: - 目标数组的字节偏移量
CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount ): 从设备复制内存到数组。
ByteCount: - 内存复制大小（以字节为单位）

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

srcDevicedstArray和dstOffset- 源设备指针 CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount ) 从设备内存复制到 1D CUDA 数组。ByteCount指定要复制的字节数。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMemcpyToArray

CUresult cuMemcpyDtoD ( CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount )

从设备到设备复制内存。

参数

dstDevice: - 目标设备指针
CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount ): 从设备复制内存到数组。
ByteCount: - 内存复制大小（以字节为单位）

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

从设备内存复制到设备内存。dstDevice和 CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount ) 分别是目标和源的基址指针。ByteCount指定要复制的字节数。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMemcpy, cudaMemcpyToSymbol, cudaMemcpyFromSymbol

CUresult cuMemcpyDtoDAsync ( CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream )

从设备到设备复制内存。

参数

dstDevice: - 目标设备指针
CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount ): 从设备复制内存到数组。
ByteCount: - 内存复制大小（以字节为单位）
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

注意

请注意，此函数也可能返回先前异步启动的错误代码。
此函数对于大多数用例都表现出异步行为。
此函数使用标准的默认流语义。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemcpyAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync

CUresult cuMemcpyDtoH ( void* dstHost, CUdeviceptr srcDevice, size_t ByteCount )

从设备到主机复制内存。

参数

dstHost: - 目标主机指针
CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount ): 从设备复制内存到数组。
ByteCount: - 内存复制大小（以字节为单位）

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

从设备复制到主机内存。dstHost和 CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount ) 分别指定目标和源的基址指针。ByteCount指定要复制的字节数。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。
请求的内存区域必须完全在 CUDA 中注册，或者对于主机可分页传输，则完全不注册。跨越同时在 CUDA 中注册和未注册的分配的内存区域不受支持，并将返回 CUDA_ERROR_INVALID_VALUE。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMemcpy, cudaMemcpyFromSymbol

CUresult cuMemcpyDtoHAsync ( void* dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream )

从设备到主机复制内存。

参数

dstHost: - 目标主机指针
CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount ): 从设备复制内存到数组。
ByteCount: - 内存复制大小（以字节为单位）
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

注意

请注意，此函数也可能返回先前异步启动的错误代码。
此函数对于大多数用例都表现出异步行为。
此函数使用标准的默认流语义。
请求的内存区域必须完全在 CUDA 中注册，或者对于主机可分页传输，则完全不注册。跨越同时在 CUDA 中注册和未注册的分配的内存区域不受支持，并将返回 CUDA_ERROR_INVALID_VALUE。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemcpyAsync, cudaMemcpyFromSymbolAsync

CUresult cuMemcpyHtoA ( CUarray dstArray, size_t dstOffset, const void* srcHost, size_t ByteCount )

从主机到数组复制内存。

参数

dstArray: - 目标数组
dstOffset: - 目标数组的字节偏移量
srcHost: - 源主机指针
ByteCount: - 内存复制大小（以字节为单位）

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

从主机内存复制到 1D CUDA 数组。dstArray和dstOffset指定 CUDA 数组句柄和目标数据的起始字节偏移量。pSrc指定源的基地址。ByteCount指定要复制的字节数。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。
请求的内存区域必须完全在 CUDA 中注册，或者对于主机可分页传输，则完全不注册。跨越同时在 CUDA 中注册和未注册的分配的内存区域不受支持，并将返回 CUDA_ERROR_INVALID_VALUE。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMemcpyToArray

CUresult cuMemcpyHtoAAsync ( CUarray dstArray, size_t dstOffset, const void* srcHost, size_t ByteCount, CUstream hStream )

从主机到数组复制内存。

参数

dstArray: - 目标数组
dstOffset: - 目标数组的字节偏移量
srcHost: - 源主机指针
ByteCount: - 内存复制大小（以字节为单位）
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

从主机内存复制到 1D CUDA 数组。dstArray和dstOffset指定 CUDA 数组句柄和目标数据的起始字节偏移量。srcHost指定源的基地址。ByteCount指定要复制的字节数。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
此函数对于大多数用例都表现出异步行为。
此函数使用标准的默认流语义。
请求的内存区域必须完全在 CUDA 中注册，或者对于主机可分页传输，则完全不注册。跨越同时在 CUDA 中注册和未注册的分配的内存区域不受支持，并将返回 CUDA_ERROR_INVALID_VALUE。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemcpyToArrayAsync

CUresult cuMemcpyHtoD ( CUdeviceptr dstDevice, const void* srcHost, size_t ByteCount )

从主机到设备复制内存。

参数

dstDevice: - 目标设备指针
srcHost: - 源主机指针
ByteCount: - 内存复制大小（以字节为单位）

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

从主机内存复制到设备内存。dstDevice和srcHost分别是目标和源的基地址。ByteCount指定要复制的字节数。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。
请求的内存区域必须完全在 CUDA 中注册，或者对于主机可分页传输，则完全不注册。跨越同时在 CUDA 中注册和未注册的分配的内存区域不受支持，并将返回 CUDA_ERROR_INVALID_VALUE。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMemcpy, cudaMemcpyToSymbol

CUresult cuMemcpyHtoDAsync ( CUdeviceptr dstDevice, const void* srcHost, size_t ByteCount, CUstream hStream )

从主机到设备复制内存。

参数

dstDevice: - 目标设备指针
srcHost: - 源主机指针
ByteCount: - 内存复制大小（以字节为单位）
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

从主机内存复制到设备内存。dstDevice和srcHost分别是目标和源的基地址。ByteCount指定要复制的字节数。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
此函数对于大多数用例都表现出异步行为。
此函数使用标准的默认流语义。
请求的内存区域必须完全在 CUDA 中注册，或者对于主机可分页传输，则完全不注册。跨越同时在 CUDA 中注册和未注册的分配的内存区域不受支持，并将返回 CUDA_ERROR_INVALID_VALUE。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemcpyAsync, cudaMemcpyToSymbolAsync

CUresult cuMemcpyPeer ( CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount )

在两个上下文之间复制设备内存。

参数

dstDevice: - 目标设备指针
dstContext: - 目标上下文
CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount ): 从设备复制内存到数组。
srcContext: - 源上下文
ByteCount: - 内存复制大小（以字节为单位）

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将内存从一个上下文中的设备内存复制到另一个上下文中的设备内存。dstDevice是目标内存的基设备指针，并且dstContext是目标上下文。 CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount ) 是源内存的基设备指针，并且srcContext是源指针。ByteCount指定要复制的字节数。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
在大多数用例中，此函数表现出同步行为。

另请参阅

cuMemcpyDtoD, cuMemcpy3DPeer, cuMemcpyDtoDAsync, cuMemcpyPeerAsync, cuMemcpy3DPeerAsync, cudaMemcpyPeer

CUresult cuMemcpyPeerAsync ( CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount, CUstream hStream )

异步在两个上下文之间复制设备内存。

参数

dstDevice: - 目标设备指针
dstContext: - 目标上下文
CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount ): 从设备复制内存到数组。
srcContext: - 源上下文
ByteCount: - 内存复制大小（以字节为单位）
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

注意

请注意，此函数也可能返回先前异步启动的错误代码。
此函数对于大多数用例都表现出异步行为。
此函数使用标准的默认流语义。

另请参阅

cuMemcpyDtoD, cuMemcpyPeer, cuMemcpy3DPeer, cuMemcpyDtoDAsync, cuMemcpy3DPeerAsync, cudaMemcpyPeerAsync

CUresult cuMemsetD16 ( CUdeviceptr dstDevice, unsigned short us, size_t N )

初始化设备内存。

参数

dstDevice: - 目标设备指针
us: - 要设置的值
N: - 元素数量

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将N16 位值的内存范围设置为指定值us。dstDevice指针必须是双字节对齐的。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
另请参阅 memset 同步细节。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemset

CUresult cuMemsetD16Async ( CUdeviceptr dstDevice, unsigned short us, size_t N, CUstream hStream )

设置设备内存。

参数

dstDevice: - 目标设备指针
us: - 要设置的值
N: - 元素数量
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将N16 位值的内存范围设置为指定值us。dstDevice指针必须是双字节对齐的。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
另请参阅 memset 同步细节。
此函数使用标准的默认流语义。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemset

CUresult cuMemsetD2D16 ( CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height )

初始化设备内存。

参数

dstDevice: - 目标设备指针
dstPitch: - 目标设备指针的跨距（如果Height为 1，则未使用）
us: - 要设置的值
Width: - 行的宽度
Height: - 行数

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

设置Width16 位值的内存范围设置为指定值us. Height的 2D 内存范围，指定要设置的行数，以及dstPitch指定每行之间的字节数。dstDevice指针和dstPitch偏移量必须是双字节对齐的。当跨距是由 cuMemAllocPitch() 返回的跨距时，此函数执行速度最快。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
另请参阅 memset 同步细节。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemset2D

CUresult cuMemsetD2D16Async ( CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height, CUstream hStream )

设置设备内存。

参数

dstDevice: - 目标设备指针
dstPitch: - 目标设备指针的跨距（如果Height为 1，则未使用）
us: - 要设置的值
Width: - 行的宽度
Height: - 行数
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

注意

请注意，此函数也可能返回先前异步启动的错误代码。
另请参阅 memset 同步细节。
此函数使用标准的默认流语义。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemset2DAsync

CUresult cuMemsetD2D32 ( CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height )

初始化设备内存。

参数

dstDevice: - 目标设备指针
dstPitch: - 目标设备指针的跨距（如果Height为 1，则未使用）
ui: - 要设置的值
Width: - 行的宽度
Height: - 行数

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

设置Width将 32 位值设置为指定值ui. Height的 2D 内存范围，指定要设置的行数，以及dstPitch指定每行之间的字节数。dstDevice指针和dstPitch偏移量必须是四字节对齐的。当 pitch 是由 cuMemAllocPitch() 返回的值时，此函数执行速度最快。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
另请参阅 memset 同步细节。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemset2D

CUresult cuMemsetD2D32Async ( CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height, CUstream hStream )

设置设备内存。

参数

dstDevice: - 目标设备指针
dstPitch: - 目标设备指针的跨距（如果Height为 1，则未使用）
ui: - 要设置的值
Width: - 行的宽度
Height: - 行数
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

注意

请注意，此函数也可能返回先前异步启动的错误代码。
另请参阅 memset 同步细节。
此函数使用标准的默认流语义。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemset2DAsync

CUresult cuMemsetD2D8 ( CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height )

初始化设备内存。

参数

dstDevice: - 目标设备指针
dstPitch: - 目标设备指针的跨距（如果Height为 1，则未使用）
uc: - 要设置的值
Width: - 行的宽度
Height: - 行数

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

设置Width将 8 位值设置为指定值uc. Height的 2D 内存范围，指定要设置的行数，以及dstPitch指定每行之间的字节数。当 pitch 是由 cuMemAllocPitch() 返回的值时，此函数执行速度最快。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
另请参阅 memset 同步细节。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemset2D

CUresult cuMemsetD2D8Async ( CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, CUstream hStream )

设置设备内存。

参数

dstDevice: - 目标设备指针
dstPitch: - 目标设备指针的跨距（如果Height为 1，则未使用）
uc: - 要设置的值
Width: - 行的宽度
Height: - 行数
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

注意

请注意，此函数也可能返回先前异步启动的错误代码。
另请参阅 memset 同步细节。
此函数使用标准的默认流语义。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemset2DAsync

CUresult cuMemsetD32 ( CUdeviceptr dstDevice, unsigned int ui, size_t N )

初始化设备内存。

参数

dstDevice: - 目标设备指针
ui: - 要设置的值
N: - 元素数量

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将N将 32 位值设置为指定值ui。dstDevice指针必须是四字节对齐的。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
另请参阅 memset 同步细节。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32Async, cudaMemset

CUresult cuMemsetD32Async ( CUdeviceptr dstDevice, unsigned int ui, size_t N, CUstream hStream )

设置设备内存。

参数

dstDevice: - 目标设备指针
ui: - 要设置的值
N: - 元素数量
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将N将 32 位值设置为指定值ui。dstDevice指针必须是四字节对齐的。

注意

请注意，此函数也可能返回先前异步启动的错误代码。
另请参阅 memset 同步细节。
此函数使用标准的默认流语义。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cudaMemsetAsync

CUresult cuMemsetD8 ( CUdeviceptr dstDevice, unsigned char uc, size_t N )

初始化设备内存。

参数

dstDevice: - 目标设备指针
uc: - 要设置的值
N: - 元素数量

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将N将 8 位值设置为指定值uc.

注意

请注意，此函数也可能返回先前异步启动的错误代码。
另请参阅 memset 同步细节。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cudaMemset

CUresult cuMemsetD8Async ( CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream )

设置设备内存。

参数

dstDevice: - 目标设备指针
uc: - 要设置的值
N: - 元素数量
hStream: - 流标识符

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将N将 8 位值设置为指定值uc.

注意

请注意，此函数也可能返回先前异步启动的错误代码。
另请参阅 memset 同步细节。
此函数使用标准的默认流语义。

另请参阅

cuArray3DCreate, cuArray3DGetDescriptor, cuArrayCreate, cuArrayDestroy, cuArrayGetDescriptor, cuMemAlloc, cuMemAllocHost, cuMemAllocPitch, cuMemcpy2D, cuMemcpy2DAsync, cuMemcpy2DUnaligned, cuMemcpy3D, cuMemcpy3DAsync, cuMemcpyAtoA, cuMemcpyAtoD, cuMemcpyAtoH, cuMemcpyAtoHAsync, cuMemcpyDtoA, cuMemcpyDtoD, cuMemcpyDtoDAsync, cuMemcpyDtoH, cuMemcpyDtoHAsync, cuMemcpyHtoA, cuMemcpyHtoAAsync, cuMemcpyHtoD, cuMemcpyHtoDAsync, cuMemFree, cuMemFreeHost, cuMemGetAddressRange, cuMemGetInfo, cuMemHostAlloc, cuMemHostGetDevicePointer, cuMemsetD2D8, cuMemsetD2D8Async, cuMemsetD2D16, cuMemsetD2D16Async, cuMemsetD2D32, cuMemsetD2D32Async, cuMemsetD8Async, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cudaMemsetAsync

CUresult cuMipmappedArrayCreate ( CUmipmappedArray* pHandle, const CUDA_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc, unsigned int numMipmapLevels )

Creates a CUDA mipmapped array.

参数

pHandle: - Returned mipmapped array
pMipmappedArrayDesc: - mipmapped array descriptor
numMipmapLevels: - Number of mipmap levels

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY, CUDA_ERROR_UNKNOWN

描述

Creates a CUDA mipmapped array according to the CUDA_ARRAY3D_DESCRIPTOR structurepMipmappedArrayDescand returns a handle to the new CUDA mipmapped array in*pHandle. numMipmapLevelsspecifies the number of mipmap levels to be allocated. This value is clamped to the range [1, 1 + floor(log2(max(width, height, depth)))].

The CUDA_ARRAY3D_DESCRIPTOR is defined as

‎    typedef struct {
              unsigned int Width;
              unsigned int Height;
              unsigned int Depth;
              CUarray_format Format;
              unsigned int NumChannels;
              unsigned int Flags;
          } CUDA_ARRAY3D_DESCRIPTOR;

其中

Width, Height和Depth是 CUDA 数组的宽度、高度和深度（以元素为单位）；可以分配以下类型的 CUDA 数组
- A 1D mipmapped array is allocated ifHeight和Depth范围均为零，则分配 1D 数组。
- A 2D mipmapped array is allocated if onlyDepth范围为零，则分配 2D 数组。
- A 3D mipmapped array is allocated if all three extents are non-zero.
- A 1D layered CUDA mipmapped array is allocated if onlyHeight为零且设置了 CUDA_ARRAY3D_LAYERED 标志，则分配 1D 分层 CUDA 数组。每个层都是一个 1D 数组。层数由深度范围决定。
- A 2D layered CUDA mipmapped array is allocated if all three extents are non-zero and the CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 2D array. The number of layers is determined by the depth extent.
- A cubemap CUDA mipmapped array is allocated if all three extents are non-zero and the CUDA_ARRAY3D_CUBEMAP flag is set.Width必须等于Height和Depth必须为 6。Cubemap 是一种特殊的 2D 分层 CUDA 数组，其中六层表示立方体的六个面。内存中六层的顺序与 CUarray_cubemap_face 中列出的顺序相同。
- A cubemap layered CUDA mipmapped array is allocated if all three extents are non-zero, and both, CUDA_ARRAY3D_CUBEMAP and CUDA_ARRAY3D_LAYERED flags are set.Width必须等于Height和Depth必须是 6 的倍数。Cubemap 分层 CUDA 数组是一种特殊的 2D 分层 CUDA 数组，它由 cubemap 的集合组成。前六层表示第一个 cubemap，接下来的六层构成第二个 cubemap，依此类推。

Format 指定元素的格式；CUarray_format 定义为

‎    typedef enum CUarray_format_enum {
              CU_AD_FORMAT_UNSIGNED_INT8 = 0x01,
              CU_AD_FORMAT_UNSIGNED_INT16 = 0x02,
              CU_AD_FORMAT_UNSIGNED_INT32 = 0x03,
              CU_AD_FORMAT_SIGNED_INT8 = 0x08,
              CU_AD_FORMAT_SIGNED_INT16 = 0x09,
              CU_AD_FORMAT_SIGNED_INT32 = 0x0a,
              CU_AD_FORMAT_HALF = 0x10,
              CU_AD_FORMAT_FLOAT = 0x20,
              CU_AD_FORMAT_NV12 = 0xb0, 
              CU_AD_FORMAT_UNORM_INT8X1 = 0xc0, 
              CU_AD_FORMAT_UNORM_INT8X2 = 0xc1, 
              CU_AD_FORMAT_UNORM_INT8X4 = 0xc2, 
              CU_AD_FORMAT_UNORM_INT16X1 = 0xc3, 
              CU_AD_FORMAT_UNORM_INT16X2 = 0xc4, 
              CU_AD_FORMAT_UNORM_INT16X4 = 0xc5, 
              CU_AD_FORMAT_SNORM_INT8X1 = 0xc6, 
              CU_AD_FORMAT_SNORM_INT8X2 = 0xc7, 
              CU_AD_FORMAT_SNORM_INT8X4 = 0xc8, 
              CU_AD_FORMAT_SNORM_INT16X1 = 0xc9,
              CU_AD_FORMAT_SNORM_INT16X2 = 0xca,
              CU_AD_FORMAT_SNORM_INT16X4 = 0xcb,
              CU_AD_FORMAT_BC1_UNORM = 0x91,
              CU_AD_FORMAT_BC1_UNORM_SRGB = 0x92,
              CU_AD_FORMAT_BC2_UNORM = 0x93,
              CU_AD_FORMAT_BC2_UNORM_SRGB = 0x94,
              CU_AD_FORMAT_BC3_UNORM = 0x95,
              CU_AD_FORMAT_BC3_UNORM_SRGB = 0x96,
              CU_AD_FORMAT_BC4_UNORM = 0x97,
              CU_AD_FORMAT_BC4_SNORM = 0x98,
              CU_AD_FORMAT_BC5_UNORM = 0x99,
              CU_AD_FORMAT_BC5_SNORM = 0x9a,
              CU_AD_FORMAT_BC6H_UF16 = 0x9b,
              CU_AD_FORMAT_BC6H_SF16 = 0x9c,
              CU_AD_FORMAT_BC7_UNORM = 0x9d,
              CU_AD_FORMAT_BC7_UNORM_SRGB = 0x9e,
              CU_AD_FORMAT_P010 = 0x9f,
              CU_AD_FORMAT_P016 = 0xa1,
              CU_AD_FORMAT_NV16 = 0xa2,
              CU_AD_FORMAT_P210 = 0xa3,
              CU_AD_FORMAT_P216 = 0xa4,
              CU_AD_FORMAT_YUY2 = 0xa5,
              CU_AD_FORMAT_Y210 = 0xa6,
              CU_AD_FORMAT_Y216 = 0xa7,
              CU_AD_FORMAT_AYUV = 0xa8,
              CU_AD_FORMAT_Y410 = 0xa9,
              CU_AD_FORMAT_Y416 = 0xb1,
              CU_AD_FORMAT_Y444_PLANAR8 = 0xb2,
              CU_AD_FORMAT_Y444_PLANAR10 = 0xb3,
              CU_AD_FORMAT_YUV444_8bit_SemiPlanar = 0xb4,
              CU_AD_FORMAT_YUV444_16bit_SemiPlanar = 0xb5,
              CU_AD_FORMAT_UNORM_INT_101010_2 = 0x50,
          } CUarray_format;

NumChannels指定每个 CUDA 数组元素打包的组件数；它可以是 1、2 或 4；

Flags 可以设置为
- CUDA_ARRAY3D_LAYERED to enable creation of layered CUDA mipmapped arrays. If this flag is set,Depth指定层数，而不是 3D 数组的深度。
- CUDA_ARRAY3D_SURFACE_LDST to enable surface references to be bound to individual mipmap levels of the CUDA mipmapped array. If this flag is not set, cuSurfRefSetArray will fail when attempting to bind a mipmap level of the CUDA mipmapped array to a surface reference.
- CUDA_ARRAY3D_CUBEMAP to enable creation of mipmapped cubemaps. If this flag is set,Width必须等于Height和Depth必须为 6。如果也设置了 CUDA_ARRAY3D_LAYERED 标志，则Depth必须是 6 的倍数。
- CUDA_ARRAY3D_TEXTURE_GATHER to indicate that the CUDA mipmapped array will be used for texture gather. Texture gather can only be performed on 2D CUDA mipmapped arrays.

Width, Height和Depthmust meet certain size requirements as listed in the following table. All values are specified in elements. Note that for brevity's sake, the full name of the device attribute is not specified. For ex., TEXTURE1D_MIPMAPPED_WIDTH refers to the device attribute CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH.

CUDA 数组类型	必须始终满足的有效范围 {(宽度范围，以元素为单位), (高度范围), (深度范围)}	设置 CUDA_ARRAY3D_SURFACE_LDST 后的有效范围 {(宽度范围，以元素为单位), (高度范围), (深度范围)}
1D	{ (1,TEXTURE1D_MIPMAPPED_WIDTH), 0, 0 }	{ (1,SURFACE1D_WIDTH), 0, 0 }
2D	{ (1,TEXTURE2D_MIPMAPPED_WIDTH), (1,TEXTURE2D_MIPMAPPED_HEIGHT), 0 }	{ (1,SURFACE2D_WIDTH), (1,SURFACE2D_HEIGHT), 0 }
3D	{ (1,TEXTURE3D_WIDTH), (1,TEXTURE3D_HEIGHT), (1,TEXTURE3D_DEPTH) } OR { (1,TEXTURE3D_WIDTH_ALTERNATE), (1,TEXTURE3D_HEIGHT_ALTERNATE), (1,TEXTURE3D_DEPTH_ALTERNATE) }	{ (1,SURFACE3D_WIDTH), (1,SURFACE3D_HEIGHT), (1,SURFACE3D_DEPTH) }
1D 分层	{ (1,TEXTURE1D_LAYERED_WIDTH), 0, (1,TEXTURE1D_LAYERED_LAYERS) }	{ (1,SURFACE1D_LAYERED_WIDTH), 0, (1,SURFACE1D_LAYERED_LAYERS) }
2D 分层	{ (1,TEXTURE2D_LAYERED_WIDTH), (1,TEXTURE2D_LAYERED_HEIGHT), (1,TEXTURE2D_LAYERED_LAYERS) }	{ (1,SURFACE2D_LAYERED_WIDTH), (1,SURFACE2D_LAYERED_HEIGHT), (1,SURFACE2D_LAYERED_LAYERS) }
Cubemap	{ (1,TEXTURECUBEMAP_WIDTH), (1,TEXTURECUBEMAP_WIDTH), 6 }	{ (1,SURFACECUBEMAP_WIDTH), (1,SURFACECUBEMAP_WIDTH), 6 }
Cubemap 分层	{ (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_LAYERS) }	{ (1,SURFACECUBEMAP_LAYERED_WIDTH), (1,SURFACECUBEMAP_LAYERED_WIDTH), (1,SURFACECUBEMAP_LAYERED_LAYERS) }

注意

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

另请参阅

cuMipmappedArrayDestroy, cuMipmappedArrayGetLevel, cuArrayCreate, cudaMallocMipmappedArray

CUresult cuMipmappedArrayDestroy ( CUmipmappedArray hMipmappedArray )

Destroys a CUDA mipmapped array.

参数

hMipmappedArray: - Mipmapped array to destroy

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_HANDLE, CUDA_ERROR_ARRAY_IS_MAPPED, CUDA_ERROR_CONTEXT_IS_DESTROYED

描述

Destroys the CUDA mipmapped arrayhMipmappedArray.

注意

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

另请参阅

cuMipmappedArrayCreate, cuMipmappedArrayGetLevel, cuArrayCreate, cudaFreeMipmappedArray

CUresult cuMipmappedArrayGetLevel ( CUarray* pLevelArray, CUmipmappedArray hMipmappedArray, unsigned int level )

Gets a mipmap level of a CUDA mipmapped array.

参数

pLevelArray: - Returned mipmap level CUDA array
hMipmappedArray: - CUDA mipmapped array
level: - Mipmap level

返回值

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

返回值在*pLevelArraya CUDA array that represents a single mipmap level of the CUDA mipmapped arrayhMipmappedArray.

如果levelis greater than the maximum number of levels in this mipmapped array, CUDA_ERROR_INVALID_VALUE is returned.

注意

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

另请参阅

cuMipmappedArrayCreate, cuMipmappedArrayDestroy, cuArrayCreate, cudaGetMipmappedArrayLevel

CUresult cuMipmappedArrayGetMemoryRequirements ( CUDA_ARRAY_MEMORY_REQUIREMENTS* memoryRequirements, CUmipmappedArray mipmap, CUdevice device )

Returns the memory requirements of a CUDA mipmapped array.

参数

memoryRequirements: - 指向 CUDA_ARRAY_MEMORY_REQUIREMENTS 的指针
mipmap: - CUDA mipmapped array to get the memory requirements of
device: - 获取内存需求的设备

返回值

CUDA_SUCCESS CUDA_ERROR_INVALID_VALUE

描述

Returns the memory requirements of a CUDA mipmapped array inmemoryRequirementsIf the CUDA mipmapped array is not allocated with flag CUDA_ARRAY3D_DEFERRED_MAPPING CUDA_ERROR_INVALID_VALUE will be returned.

The returned value in CUDA_ARRAY_MEMORY_REQUIREMENTS::size represents the total size of the CUDA mipmapped array. The returned value in CUDA_ARRAY_MEMORY_REQUIREMENTS::alignment represents the alignment necessary for mapping the CUDA mipmapped array.

另请参阅

cuArrayGetMemoryRequirements, cuMemMapArrayAsync

CUresult cuMipmappedArrayGetSparseProperties ( CUDA_ARRAY_SPARSE_PROPERTIES* sparseProperties, CUmipmappedArray mipmap )

Returns the layout properties of a sparse CUDA mipmapped array.

参数

sparseProperties: - 指向 CUDA_ARRAY_SPARSE_PROPERTIES 的指针
mipmap: - CUDA mipmapped array to get the sparse properties of

返回值

CUDA_SUCCESS CUDA_ERROR_INVALID_VALUE

描述

Returns the sparse array layout properties insparsePropertiesIf the CUDA mipmapped array is not allocated with flag CUDA_ARRAY3D_SPARSE CUDA_ERROR_INVALID_VALUE will be returned.

For non-layered CUDA mipmapped arrays, CUDA_ARRAY_SPARSE_PROPERTIES::miptailSize returns the size of the mip tail region. The mip tail region includes all mip levels whose width, height or depth is less than that of the tile. For layered CUDA mipmapped arrays, if CUDA_ARRAY_SPARSE_PROPERTIES::flags contains CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL, then CUDA_ARRAY_SPARSE_PROPERTIES::miptailSize specifies the size of the mip tail of all layers combined. Otherwise, CUDA_ARRAY_SPARSE_PROPERTIES::miptailSize specifies mip tail size per layer. The returned value of CUDA_ARRAY_SPARSE_PROPERTIES::miptailFirstLevel is valid only if CUDA_ARRAY_SPARSE_PROPERTIES::miptailSize is non-zero.

另请参阅

cuArrayGetSparseProperties, cuMemMapArrayAsync