CUDA Driver API :: CUDA Toolkit Documentation

6.13. 内存管理

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

类

struct CUmemDecompressParams: Structure describing the parameters that compose a single decompression operation.

枚举

enum CUmemDecompressAlgorithm: Bitmasks for CU_DEVICE_ATTRIBUTE_MEM_DECOMPRESS_ALGORITHM_MASK.

Functions

CUresult cuArray3DCreate ( CUarray* pHandle, const CUDA_ARRAY3D_DESCRIPTOR* pAllocateArray ): Creates a 3D CUDA array.
CUresult cuArray3DGetDescriptor ( CUDA_ARRAY3D_DESCRIPTOR* pArrayDescriptor, CUarray hArray ): Get a 3D CUDA array descriptor.
CUresult cuArrayCreate ( CUarray* pHandle, const CUDA_ARRAY_DESCRIPTOR* pAllocateArray ): Creates a 1D or 2D CUDA array.
CUresult cuArrayDestroy ( CUarray hArray ): Destroys a CUDA array.
CUresult cuArrayGetDescriptor ( CUDA_ARRAY_DESCRIPTOR* pArrayDescriptor, CUarray hArray ): Get a 1D or 2D CUDA array descriptor.
CUresult cuArrayGetMemoryRequirements ( CUDA_ARRAY_MEMORY_REQUIREMENTS* memoryRequirements, CUarray array, CUdevice device ): Returns the memory requirements of a CUDA array.
CUresult cuArrayGetPlane ( CUarray* pPlaneArray, CUarray hArray, unsigned int planeIdx ): Gets a CUDA array plane from a CUDA array.
CUresult cuArrayGetSparseProperties ( CUDA_ARRAY_SPARSE_PROPERTIES* sparseProperties, CUarray array ): Returns the layout properties of a sparse CUDA array.
CUresult cuDeviceGetByPCIBusId ( CUdevice* dev, const char* pciBusId ): Returns a handle to a compute device.
CUresult cuDeviceGetPCIBusId ( char* pciBusId, int len, CUdevice dev ): Returns a PCI Bus Id string for the device.
CUresult cuDeviceRegisterAsyncNotification ( CUdevice device, CUasyncCallback callbackFunc, void* userData, CUasyncCallbackHandle* callback ): Registers a callback function to receive async notifications.
CUresult cuDeviceUnregisterAsyncNotification ( CUdevice device, CUasyncCallbackHandle callback ): Unregisters an async notification callback.
CUresult cuIpcCloseMemHandle ( CUdeviceptr dptr ): Attempts to close memory mapped with cuIpcOpenMemHandle.
CUresult cuIpcGetEventHandle ( CUipcEventHandle* pHandle, CUevent event ): Gets an interprocess handle for a previously allocated event.
CUresult cuIpcGetMemHandle ( CUipcMemHandle* pHandle, CUdeviceptr dptr ): Gets an interprocess memory handle for an existing device memory allocation.
CUresult cuIpcOpenEventHandle ( CUevent* phEvent, CUipcEventHandle handle ): Opens an interprocess event handle for use in the current process.
CUresult cuIpcOpenMemHandle ( CUdeviceptr* pdptr, CUipcMemHandle handle, unsigned int Flags ): Opens an interprocess memory handle exported from another process and returns a device pointer usable in the local process.
CUresult cuMemAlloc ( CUdeviceptr* dptr, size_t bytesize ): Allocates device memory.
CUresult cuMemAllocHost ( void** pp, size_t bytesize ): Allocates page-locked host memory.
CUresult cuMemAllocManaged ( CUdeviceptr* dptr, size_t bytesize, unsigned int flags ): Allocates memory that will be automatically managed by the Unified Memory system.
CUresult cuMemAllocPitch ( CUdeviceptr* dptr, size_t* pPitch, size_t WidthInBytes, size_t Height, unsigned int ElementSizeBytes ): Allocates pitched device memory.
CUresult cuMemBatchDecompressAsync ( CUmemDecompressParams* paramsArray, size_t count, unsigned int flags, size_t* errorIndex, CUstream stream ): Submit a batch of count independent decompression operations.
CUresult cuMemFree ( CUdeviceptr dptr ): Frees device memory.
CUresult cuMemFreeHost ( void* p ): Frees page-locked host memory.
CUresult cuMemGetAddressRange ( CUdeviceptr* pbase, size_t* psize, CUdeviceptr dptr ): Get information on memory allocations.
CUresult cuMemGetHandleForAddressRange ( void* handle, CUdeviceptr dptr, size_t size, CUmemRangeHandleType handleType, unsigned long long flags ): Retrieve handle for an address range.
CUresult cuMemGetInfo ( size_t* free, size_t* total ): Gets free and total memory.
CUresult cuMemHostAlloc ( void** pp, size_t bytesize, unsigned int Flags ): Allocates page-locked host memory.
CUresult cuMemHostGetDevicePointer ( CUdeviceptr* pdptr, void* p, unsigned int Flags ): Passes back device pointer of mapped pinned memory.
CUresult cuMemHostGetFlags ( unsigned int* pFlags, void* p ): Passes back flags that were used for a pinned allocation.
CUresult cuMemHostRegister ( void* p, size_t bytesize, unsigned int Flags ): Registers an existing host memory range for use by CUDA.
CUresult cuMemHostUnregister ( void* p ): Unregisters a memory range that was registered with cuMemHostRegister.
CUresult cuMemcpy ( CUdeviceptr dst, CUdeviceptr src, size_t ByteCount ): Copies memory.
CUresult cuMemcpy2D ( const CUDA_MEMCPY2D* pCopy ): Copies memory for 2D arrays.
CUresult cuMemcpy2DAsync ( const CUDA_MEMCPY2D* pCopy, CUstream hStream ): Copies memory for 2D arrays.
CUresult cuMemcpy2DUnaligned ( const CUDA_MEMCPY2D* pCopy ): Copies memory for 2D arrays.
CUresult cuMemcpy3D ( const CUDA_MEMCPY3D* pCopy ): Copies memory for 3D arrays.
CUresult cuMemcpy3DAsync ( const CUDA_MEMCPY3D* pCopy, CUstream hStream ): Copies memory for 3D arrays.
CUresult cuMemcpy3DBatchAsync ( size_t numOps, CUDA_MEMCPY3D_BATCH_OP* opList, size_t* failIdx, unsigned long long flags, CUstream hStream ): Performs a batch of 3D memory copies asynchronously.
CUresult cuMemcpy3DPeer ( const CUDA_MEMCPY3D_PEER* pCopy ): Copies memory between contexts.
CUresult cuMemcpy3DPeerAsync ( const CUDA_MEMCPY3D_PEER* pCopy, CUstream hStream ): Copies memory between contexts asynchronously.
CUresult cuMemcpyAsync ( CUdeviceptr dst, CUdeviceptr src, size_t ByteCount, CUstream hStream ): Copies memory asynchronously.
CUresult cuMemcpyAtoA ( CUarray dstArray, size_t dstOffset, CUarray srcArray, size_t srcOffset, size_t ByteCount ): Copies memory from Array to Array.
CUresult cuMemcpyAtoD ( CUdeviceptr dstDevice, CUarray srcArray, size_t srcOffset, size_t ByteCount ): Copies memory from Array to Device.
CUresult cuMemcpyAtoH ( void* dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount ): Copies memory from Array to Host.
CUresult cuMemcpyAtoHAsync ( void* dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount, CUstream hStream ): Copies memory from Array to Host.
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 ): Performs a batch of memory copies asynchronously.
CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount ): Copies memory from Device to Array.
CUresult cuMemcpyDtoD ( CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount ): Copies memory from Device to Device.
CUresult cuMemcpyDtoDAsync ( CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream ): Copies memory from Device to Device.
CUresult cuMemcpyDtoH ( void* dstHost, CUdeviceptr srcDevice, size_t ByteCount ): Copies memory from Device to Host.
CUresult cuMemcpyDtoHAsync ( void* dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream ): Copies memory from Device to Host.
CUresult cuMemcpyHtoA ( CUarray dstArray, size_t dstOffset, const void* srcHost, size_t ByteCount ): Copies memory from Host to Array.
CUresult cuMemcpyHtoAAsync ( CUarray dstArray, size_t dstOffset, const void* srcHost, size_t ByteCount, CUstream hStream ): Copies memory from Host to Array.
CUresult cuMemcpyHtoD ( CUdeviceptr dstDevice, const void* srcHost, size_t ByteCount ): Copies memory from Host to Device.
CUresult cuMemcpyHtoDAsync ( CUdeviceptr dstDevice, const void* srcHost, size_t ByteCount, CUstream hStream ): Copies memory from Host to Device.
CUresult cuMemcpyPeer ( CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount ): Copies device memory between two contexts.
CUresult cuMemcpyPeerAsync ( CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount, CUstream hStream ): Copies device memory between two contexts asynchronously.
CUresult cuMemsetD16 ( CUdeviceptr dstDevice, unsigned short us, size_t N ): Initializes device memory.
CUresult cuMemsetD16Async ( CUdeviceptr dstDevice, unsigned short us, size_t N, CUstream hStream ): Sets device memory.
CUresult cuMemsetD2D16 ( CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height ): Initializes device memory.
CUresult cuMemsetD2D16Async ( CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height, CUstream hStream ): Sets device memory.
CUresult cuMemsetD2D32 ( CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height ): Initializes device memory.
CUresult cuMemsetD2D32Async ( CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height, CUstream hStream ): Sets device memory.
CUresult cuMemsetD2D8 ( CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height ): Initializes device memory.
CUresult cuMemsetD2D8Async ( CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, CUstream hStream ): Sets device memory.
CUresult cuMemsetD32 ( CUdeviceptr dstDevice, unsigned int ui, size_t N ): Initializes device memory.
CUresult cuMemsetD32Async ( CUdeviceptr dstDevice, unsigned int ui, size_t N, CUstream hStream ): Sets device memory.
CUresult cuMemsetD8 ( CUdeviceptr dstDevice, unsigned char uc, size_t N ): Initializes device memory.
CUresult cuMemsetD8Async ( CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream ): Sets device memory.
CUresult cuMipmappedArrayCreate ( CUmipmappedArray* pHandle, const CUDA_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc, unsigned int numMipmapLevels ): Creates a CUDA mipmapped array.
CUresult cuMipmappedArrayDestroy ( CUmipmappedArray hMipmappedArray ): Destroys a CUDA mipmapped array.
CUresult cuMipmappedArrayGetLevel ( CUarray* pLevelArray, CUmipmappedArray hMipmappedArray, unsigned int level ): Gets a mipmap level of a CUDA mipmapped array.
CUresult cuMipmappedArrayGetMemoryRequirements ( CUDA_ARRAY_MEMORY_REQUIREMENTS* memoryRequirements, CUmipmappedArray mipmap, CUdevice device ): Returns the memory requirements of a CUDA mipmapped array.
CUresult cuMipmappedArrayGetSparseProperties ( CUDA_ARRAY_SPARSE_PROPERTIES* sparseProperties, CUmipmappedArray mipmap ): Returns the layout properties of a sparse CUDA mipmapped array.

枚举

enum CUmemDecompressAlgorithm

数值

CU_MEM_DECOMPRESS_UNSUPPORTED = 0: Decompression is unsupported.
CU_MEM_DECOMPRESS_ALGORITHM_DEFLATE = 1<<0: Deflate is supported.
CU_MEM_DECOMPRESS_ALGORITHM_SNAPPY = 1<<1: Snappy is supported.

Functions

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

创建一个3D CUDA数组。

参数

pHandle: - Returned array
pAllocateArray: - 3D array descriptor

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结构体pAllocateArray创建一个CUDA数组，并在*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;

where:

Width, Height, and Depth are the width, height, and depth of the CUDA array (in elements); the following types of CUDA arrays can be allocated:
- 如果Height和Depth范围均为零，则分配一维数组。
- 如果仅Depth范围为0，则分配一个二维数组。
- 如果所有三个维度范围都非零，则会分配一个3D数组。
- 如果仅当Height为零且设置了CUDA_ARRAY3D_LAYERED标志时，将分配一个一维分层CUDA数组。每一层都是一个一维数组。层数由深度范围决定。
- 如果所有三个维度范围均非零且设置了CUDA_ARRAY3D_LAYERED标志，则会分配一个2D分层CUDA数组。每个层都是一个2D数组。层数由深度范围决定。
- 如果三个维度均非零且设置了CUDA_ARRAY3D_CUBEMAP标志，则会分配一个立方体贴图CUDA数组。Width必须等于Height，且Depth必须为6。立方体贴图是一种特殊的2D分层CUDA数组，其中六个层代表立方体的六个面。内存中六个层的顺序与CUarray_cubemap_face中列出的顺序相同。
- 如果所有三个维度都不为零，并且同时设置了CUDA_ARRAY3D_CUBEMAP和CUDA_ARRAY3D_LAYERED标志，则会分配一个立方体贴图分层的CUDA数组。Width必须等于Height，且Depth必须是六的倍数。立方体贴图分层的CUDA数组是一种特殊类型的2D分层CUDA数组，由一系列立方体贴图组成。前六个层代表第一个立方体贴图，接下来的六个层形成第二个立方体贴图，依此类推。

Format specifies the format of the elements; CUarray_format is defined as:

‎    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 may be set to
- CUDA_ARRAY3D_LAYERED 用于启用分层CUDA数组的创建。如果设置了此标志，Depth指定的是层数，而不是3D数组的深度。
- CUDA_ARRAY3D_SURFACE_LDST 用于启用将表面引用绑定到CUDA数组的功能。如果未设置此标志，当尝试将CUDA数组绑定到表面引用时，cuSurfRefSetArray 将会失败。
- CUDA_ARRAY3D_CUBEMAP 用于启用立方体贴图创建。如果设置此标志，Width 必须等于 Height，且 Depth 必须为六。如果同时设置了 CUDA_ARRAY3D_LAYERED 标志，则 Depth 必须是六的倍数。
- CUDA_ARRAY3D_TEXTURE_GATHER 表示该CUDA数组将用于纹理采集。纹理采集只能在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时的有效范围 {(以元素为单位的宽度范围), (高度范围), (深度范围)}
一维	{ (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) } 或者 { (1,TEXTURE3D_WIDTH_ALTERNATE), (1,TEXTURE3D_HEIGHT_ALTERNATE), (1,TEXTURE3D_DEPTH_ALTERNATE) }	{ (1,SURFACE3D_WIDTH), (1,SURFACE3D_HEIGHT), (1,SURFACE3D_DEPTH) }
一维分层	{ (1,TEXTURE1D_LAYERED_WIDTH), 0, (1,TEXTURE1D_LAYERED_LAYERS) }	{ (1,SURFACE1D_LAYERED_WIDTH), 0, (1,SURFACE1D_LAYERED_LAYERS) }
二维分层	{ (1,TEXTURE2D_LAYERED_WIDTH), (1,TEXTURE2D_LAYERED_HEIGHT), (1,TEXTURE2D_LAYERED_LAYERS) }	{ (1,SURFACE2D_LAYERED_WIDTH), (1,SURFACE2D_LAYERED_HEIGHT), (1,SURFACE2D_LAYERED_LAYERS) }
立方体贴图	{ (1,TEXTURECUBEMAP_WIDTH), (1,TEXTURECUBEMAP_WIDTH), 6 }	{ (1,SURFACECUBEMAP_WIDTH), (1,SURFACECUBEMAP_WIDTH), 6 }
立方体贴图分层	{ (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;

描述一个宽度为width、高度为height、深度为depth的CUDA数组，该数组包含64位、4x16位的float16数据：

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

Note:

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

另请参阅：

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: - Returned 3D array descriptor
hArray: - 3D array to get descriptor of

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。

Note:

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

另请参阅：

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 )

创建一个一维或二维的CUDA数组。

参数

pHandle: - Returned array
pAllocateArray: - Array descriptor

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结构体pAllocateArray创建一个CUDA数组，并在*pHandle中返回新CUDA数组的句柄。CUDA_ARRAY_DESCRIPTOR的定义如下：

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

where:

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

Format specifies the format of the elements; CUarray_format is defined as:

‎    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;

描述一个宽度为width、高度为height的CUDA数组，包含64位4x16位float16数据：

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

描述一个宽度为width、高度为height的CUDA数组，其中每个元素为16位，由两个8位无符号字符组成：

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

Note:

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

另请参阅：

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: - 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

描述

销毁CUDA数组hArray。

Note:

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

另请参阅：

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 )

获取一维或二维CUDA数组描述符。

参数

pArrayDescriptor: - Returned array descriptor
hArray: - Array to get descriptor of

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

Note:

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

另请参阅：

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: - Pointer to CUDA_ARRAY_MEMORY_REQUIREMENTS
array: - CUDA array to get the memory requirements of
device: - Device to get the memory requirements for

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: - Returned CUDA array referenced by the planeIdx
hArray: - Multiplanar CUDA array
planeIdx: - Plane index

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

在pPlaneArray中返回一个表示CUDA数组hArray单个格式平面的CUDA数组。

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

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

Note:

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

另请参阅：

cuArrayCreate, cudaArrayGetPlane

CUresult cuArrayGetSparseProperties ( CUDA_ARRAY_SPARSE_PROPERTIES* sparseProperties, CUarray array )

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

参数

sparseProperties: - Pointer to CUDA_ARRAY_SPARSE_PROPERTIES
array: - CUDA array to get the sparse properties of

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: - Returned device handle
pciBusId: - String in one of the following forms: [domain]:[bus]:[device].[function] [domain]:[bus]:[device] [bus]:[device].[function] where domain, bus, device, and function are all hexadecimal values

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE

描述

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

Note:

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

另请参阅：

cuDeviceGet, cuDeviceGetAttribute, cuDeviceGetPCIBusId, cudaDeviceGetByPCIBusId

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

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

参数

pciBusId: - Returned identifier string for the device in the following format [domain]:[bus]:[device].[function] where domain, bus, device, and function are all hexadecimal values. pciBusId should be large enough to store 13 characters including the NULL-terminator.
len: - Maximum length of string to store in name
dev: - Device to get identifier string for

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE

描述

返回一个ASCII字符串，用于标识设备dev，该字符串以NULL结尾并存储在pciBusId指向的位置。len指定了可能返回的字符串的最大长度。

Note:

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

另请参阅：

cuDeviceGet, cuDeviceGetAttribute, cuDeviceGetByPCIBusId, cudaDeviceGetPCIBusId

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

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

参数

device: - The device on which to register the callback
callbackFunc: - The function to register as a callback
userData: - A generic pointer to user data. This is passed into the callback function.
callback: - A handle representing the registered callback instance

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中返回一个表示已注册回调实例的句柄。

Note:

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

另请参阅：

cuDeviceUnregisterAsyncNotification

CUresult cuDeviceUnregisterAsyncNotification ( CUdevice device, CUasyncCallbackHandle callback )

注销一个异步通知回调函数。

参数

device: - The device from which to remove callback.
callback: - The callback instance to unregister from receiving async notifications.

CUDA_SUCCESS CUDA_ERROR_NOT_SUPPORTED CUDA_ERROR_INVALID_DEVICE CUDA_ERROR_INVALID_VALUE CUDA_ERROR_NOT_PERMITTED CUDA_ERROR_UNKNOWN

描述

注销callback，使对应的回调函数停止接收异步通知。

Note:

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

另请参阅：

cuDeviceRegisterAsyncNotification

CUresult cuIpcCloseMemHandle ( CUdeviceptr dptr )

尝试关闭通过cuIpcOpenMemHandle映射的内存。

参数

dptr: - Device pointer returned by 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: - Pointer to a user allocated CUipcEventHandle in which to return the opaque event handle
event: - Event allocated with CU_EVENT_INTERPROCESS and CU_EVENT_DISABLE_TIMING flags.

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释放后对导入的事件执行操作，将导致未定义行为。

IPC功能仅限于支持Linux和Windows操作系统统一寻址的设备。Windows上的IPC功能出于兼容性目的而提供，但由于存在性能损耗，不建议使用。用户可以通过调用cuapiDeviceGetAttribute并检查CU_DEVICE_ATTRIBUTE_IPC_EVENT_SUPPORTED属性来测试设备的IPC功能支持情况。

另请参阅：

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

CUresult cuIpcGetMemHandle ( CUipcMemHandle* pHandle, CUdeviceptr dptr )

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

参数

pHandle: - Pointer to user allocated CUipcMemHandle to return the handle in.
dptr: - Base pointer to previously allocated device memory

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: - Returns the imported event
handle: - Interprocess handle to open

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释放此事件。

在导出的event通过cuEventDestroy释放后，对导入的event执行操作将导致未定义行为。

另请参阅：

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

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

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

参数

pdptr: - Returned device pointer
handle: - CUipcMemHandle to open
Flags: - Flags for this operation. Must be specified as 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可确定是否可以进行映射。

可以打开CUipcMemHandles的上下文受到以下限制。在给定进程中，每个CUdevice的CUipcMemHandles只能由其他进程中每个CUdevice对应的一个CUcontext打开。

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

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

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

IPC功能仅限于支持Linux和Windows操作系统统一寻址的设备。Windows上的IPC功能出于兼容性目的而提供，但由于存在性能开销，不建议使用。用户可以通过调用cuapiDeviceGetAttribute并传入CU_DEVICE_ATTRIBUTE_IPC_EVENT_SUPPORTED来测试设备的IPC功能支持情况。

Note:

对于*pdptr中返回的地址不作任何保证。特别是，多个进程可能不会为相同的handle接收到相同的地址。

另请参阅：

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

CUresult cuMemAlloc ( CUdeviceptr* dptr, size_t bytesize )

分配设备内存。

参数

dptr: - Returned device pointer
bytesize: - Requested allocation size in bytes

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。

Note:

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

另请参阅：

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: - Returned pointer to host memory
bytesize: - Requested allocation size in bytes

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。更多详情请参阅Unified Addressing。

Note:

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

另请参阅：

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: - Returned device pointer
bytesize: - Requested allocation size in bytes
flags: - Must be one of CU_MEM_ATTACH_GLOBAL or 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值为零时，托管内存物理存储位置的选择将取决于具体系统配置。

On Linux, the location chosen will be device memory as long as the current set of active contexts are on devices that either have peer-to-peer support with each other or have a non-zero value for the device attribute CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. If there is an active context on a GPU that does not have a non-zero value for that device attribute and it does not have peer-to-peer support with the other devices that have active contexts on them, then the location for physical storage will be 'zero-copy' or host memory. Note that this means that managed memory that is located in device memory is migrated to host memory if a new context is created on a GPU that doesn't have a non-zero value for the device attribute and does not support peer-to-peer with at least one of the other devices that has an active context. This in turn implies that context creation may fail if there is insufficient host memory to migrate all managed allocations.
在Windows系统上，物理存储始终创建在'零拷贝'或主机内存中。所有GPU将通过PCIe总线以降低的带宽引用数据。在此情况下，建议使用环境变量CUDA_VISIBLE_DEVICES来限制CUDA仅使用那些支持点对点传输的GPU。或者，用户也可以将CUDA_MANAGED_FORCE_DEVICE_ALLOC设置为非零值，强制驱动程序始终使用设备内存作为物理存储。当此环境变量设置为非零值时，该进程中在支持托管内存的设备上创建的所有上下文必须彼此具备点对点兼容性。如果在支持托管内存的设备上创建上下文，且该设备与之前创建过上下文的其他支持托管内存的设备不具备点对点兼容性，那么即使这些上下文已被销毁，上下文创建也会失败。这些环境变量在CUDA编程指南的"CUDA环境变量"章节中有详细说明。
在ARM架构上，Drive PX-2的独立GPU不支持托管内存。

Note:

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

另请参阅：

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

分配带有间距的设备内存。

参数

dptr: - Returned device pointer
pPitch: - Returned pitch of allocation in bytes
WidthInBytes: - Requested allocation width in bytes
Height: - Requested allocation height in rows
ElementSizeBytes: - Size of largest reads/writes for range

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小于内核实际读写大小，内核仍能正确运行，但速度可能会降低。cuMemAllocPitch()在*pPitch中返回的间距是分配的宽度（以字节为单位）。间距的预期用途是作为分配的独立参数，用于计算二维数组内的地址。给定类型为T的数组元素的行和列，地址计算方式为：

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

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

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

Note:

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

另请参阅：

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 )

Submit a batch of count independent decompression operations.

参数

paramsArray: The array of structures describing the independent decompression operations.
count: The number of entries in paramsArray array.
flags: Must be 0.
errorIndex: The index into paramsArray of the decompression operation for which the error returned by this function pertains to. If index is SIZE_MAX and the value returned is not CUDA_SUCCESS, then the error returned by this function should be considered a general error that does not pertain to a particular decompression operation. May be NULL, in which case, no index will be recorded in the event of error.
stream: The stream where the work will be enqueued.

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

paramsArray数组中的每个条目对应一个count解压操作。提交批处理后，函数将立即返回，解压过程会相对于CPU异步执行。对于CUDA驱动中的工作完成跟踪机制而言，该批处理将被视为一个独立的工作单元，并按照流语义进行处理，这意味着无法查询批处理中单个解压操作的完成状态。

由CUmemDecompressParams.src、CUmemDecompressParams.dst和CUmemDecompressParams.dstActBytes指向的内存必须能够支持硬件解压缩功能。也就是说，对于上述每个指针，其属性CU_POINTER_ATTRIBUTE_IS_MEM_DECOMPRESS_CAPABLE应返回非零值。为确保这一点，支持这些指针的内存应使用以下CUDA内存分配器之一进行分配：* cuMemAlloc() * 带有使用标志CU_MEM_CREATE_USAGE_HW_DECOMPRESS的cuMemCreate() * 从创建时带有使用标志CU_MEM_POOL_CREATE_USAGE_HW_DECOMPRESS的内存池中通过cuMemAllocFromPoolAsync()分配。此外，CUmemDecompressParams.src、CUmemDecompressParams.dst和CUmemDecompressParams.dstActBytes都必须能够从创建stream的上下文关联设备访问。有关如何确保这一点的信息，请参阅相关分配器的文档。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出异步行为。
该函数使用标准的默认流语义。

另请参阅：

cuMemAlloc, cuMemPoolCreate, cuMemAllocFromPoolAsync

CUresult cuMemFree ( CUdeviceptr dptr )

释放设备内存。

参数

dptr: - Pointer to memory to free

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可能会执行隐式同步。

Note:

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

另请参阅：

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: - Pointer to memory to free

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

释放由p指向的内存空间，该指针必须是通过先前调用cuMemAllocHost()返回的。

Note:

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

另请参阅：

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: - Returned base address
psize: - Returned size of device memory allocation
dptr: - Device pointer to query

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_NOT_FOUND, CUDA_ERROR_INVALID_VALUE

描述

返回包含输入指针dptr的cuMemAlloc()或cuMemAllocPitch()分配的内存的基地址到*pbase和大小到*psize。参数pbase和psize都是可选的。如果其中一个为NULL，则会被忽略。

Note:

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

另请参阅：

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: - Pointer to the location where the returned handle will be stored.
dptr: - Pointer to a valid CUDA device allocation. Must be aligned to host page size.
size: - Length of the address range. Must be aligned to host page size.
handleType: - Type of handle requested (defines type and size of the handle output parameter)
flags: - When requesting CUmemRangeHandleType::CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD the value could be CU_MEM_RANGE_FLAG_DMA_BUF_MAPPING_TYPE_PCIE, otherwise 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时，用户应在调用此API前通过CU_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORTED设备属性查询平台是否支持dma_buf。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: - Returned free memory in bytes
total: - Returned total memory in bytes

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应用说明。

Note:

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

另请参阅：

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: - Returned pointer to host memory
bytesize: - Requested allocation size in bytes
Flags: - Flags for allocation request

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()查询设备指针，即使上下文支持统一寻址。更多详情请参阅Unified Addressing。

Note:

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

另请参阅：

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: - Returned device pointer
p: - Host pointer
Flags: - Options (must be 0)

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

返回与通过cuMemHostAlloc分配的映射固定主机缓冲区p对应的设备指针pdptr。

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

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

Flags 为未来版本预留。当前必须设置为0。

Note:

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

另请参阅：

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: - Returned flags word
p: - Host pointer

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

返回在分配由cuMemHostAlloc分配的固定主机缓冲区p时指定的标志pFlags。

cuMemHostGetFlags() 如果指针不在由 cuMemAllocHost() 或 cuMemHostAlloc() 执行的内存分配中，将会失败。

Note:

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

另请参阅：

cuMemAllocHost, cuMemHostAlloc, cudaHostGetFlags

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

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

参数

p: - Host pointer to memory to page-lock
bytesize: - Size in bytes of the address range to page-lock
Flags: - Flags for allocation request

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设备，可以在CUDA上下文中指定CU_MEMHOSTREGISTER_DEVICEMAP标志。错误会延迟到cuMemHostGetDevicePointer()时才出现，因为该内存可能通过CU_MEMHOSTREGISTER_PORTABLE标志被映射到其他CUDA上下文中。

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

通过此函数锁定的内存页必须使用cuMemHostUnregister()进行注销。

Note:

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

另请参阅：

cuMemHostUnregister, cuMemHostGetFlags, cuMemHostGetDevicePointer, cudaHostRegister

CUresult cuMemHostUnregister ( void* p )

注销之前通过cuMemHostRegister注册的内存范围。

参数

p: - Host pointer to memory to unregister

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()的地址相同。

Note:

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

另请参阅：

cuMemHostRegister, cudaHostUnregister

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

复制内存。

参数

dst: - Destination unified virtual address space pointer
src: - Source unified virtual address space pointer
ByteCount: - Size of memory copy in bytes

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。
请求的内存区域必须全部在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 )

复制二维数组的内存。

参数

pCopy: - Parameters for the memory copy

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

根据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;

where:

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() 如果任何间距(pitch)超过允许的最大值(CU_DEVICE_ATTRIBUTE_MAX_PITCH)，则会返回错误。cuMemAllocPitch() 返回的间距值总是能与 cuMemcpy2D() 配合使用。在设备内部内存拷贝（设备到设备、CUDA数组到设备、CUDA数组到CUDA数组）时，对于非由 cuMemAllocPitch() 计算的间距值，cuMemcpy2D() 可能会失败。cuMemcpy2DUnaligned() 没有这个限制，但在 cuMemcpy2D() 会返回错误码的情况下，其运行速度可能会显著变慢。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。

另请参阅：

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, cuMemsetD2D16, cuMemsetD2D32, cuMemsetD8, cuMemsetD16, cuMemsetD32, cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DFromArray

CUresult cuMemcpy2DAsync ( const CUDA_MEMCPY2D* pCopy, CUstream hStream )

复制二维数组的内存。

参数

pCopy: - Parameters for the memory copy
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

根据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;

where:

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_UNIFIED，则srcDevice和srcPitch指定源数据的（统一虚拟地址空间）基地址和每行应用的字节数。srcArray将被忽略。仅当调用上下文支持统一寻址时才能使用此值。

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

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

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

如果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() 如果任何间距(pitch)超过允许的最大值(CU_DEVICE_ATTRIBUTE_MAX_PITCH)会返回错误。cuMemAllocPitch() 返回的间距值总是能与cuMemcpy2D()配合使用。在设备内部内存拷贝时(设备到设备、CUDA数组到设备、CUDA数组到CUDA数组)，对于不是由cuMemAllocPitch()计算得出的间距值，cuMemcpy2DAsync()可能会执行失败。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出异步行为。
该函数使用标准的默认流语义。

另请参阅：

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 )

复制二维数组的内存。

参数

pCopy: - Parameters for the memory copy

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

根据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;

where:

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。

cuMemcpy2D() 如果任何间距(pitch)超过允许的最大值(CU_DEVICE_ATTRIBUTE_MAX_PITCH)会返回错误。cuMemAllocPitch() 返回的间距值总是能与 cuMemcpy2D() 配合使用。在设备内部内存拷贝时（设备到设备、CUDA数组到设备、CUDA数组到CUDA数组），对于非由 cuMemAllocPitch() 计算的间距值，cuMemcpy2D() 可能会失败。cuMemcpy2DUnaligned() 没有这个限制，但在 cuMemcpy2D() 会返回错误码的情况下，其运行速度可能会显著变慢。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。

另请参阅：

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: - Parameters for the memory copy

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

根据pCopy中指定的参数执行3D内存复制。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;

where:

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将被忽略。

如果目标内存类型是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() 如果任何间距(pitch)超过允许的最大值(CU_DEVICE_ATTRIBUTE_MAX_PITCH)，将返回错误。

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。

另请参阅：

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: - Parameters for the memory copy
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

根据pCopy中指定的参数执行3D内存复制。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;

where:

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。

cuMemcpy3DAsync() 如果任何间距(pitch)超过允许的最大值(CU_DEVICE_ATTRIBUTE_MAX_PITCH)，将返回错误。

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出异步行为。
该函数使用标准的默认流语义。

另请参阅：

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: - Total number of memcpy operations.
opList: - Array of size numOps containing the actual memcpy operations.
failIdx: - Pointer to a location to return the index of the copy where a failure was encountered. The value will be SIZE_MAX if the error doesn't pertain to any specific copy.
flags: - Flags for future use, must be zero now.
hStream: - The stream to enqueue the operations in. Must not be default NULL stream.

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中。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出异步行为。
请求的内存区域必须完全在CUDA中注册，或者在主机可分页传输的情况下完全不注册。不支持跨越已注册和未在CUDA中注册的内存分配区域，此类操作将返回CUDA_ERROR_INVALID_VALUE错误。

CUresult cuMemcpy3DPeer ( const CUDA_MEMCPY3D_PEER* pCopy )

在不同上下文之间复制内存。

参数

pCopy: - Parameters for the memory copy

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。

另请参阅：

cuMemcpyDtoD, cuMemcpyPeer, cuMemcpyDtoDAsync, cuMemcpyPeerAsync, cuMemcpy3DPeerAsync, cudaMemcpy3DPeer

CUresult cuMemcpy3DPeerAsync ( const CUDA_MEMCPY3D_PEER* pCopy, CUstream hStream )

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

参数

pCopy: - Parameters for the memory copy
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出异步行为。
该函数使用标准的默认流语义。

另请参阅：

cuMemcpyDtoD, cuMemcpyPeer, cuMemcpyDtoDAsync, cuMemcpyPeerAsync, cuMemcpy3DPeerAsync, cudaMemcpy3DPeerAsync

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

异步复制内存。

参数

dst: - Destination unified virtual address space pointer
src: - Source unified virtual address space pointer
ByteCount: - Size of memory copy in bytes
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出异步行为。
此函数使用标准的默认流语义。
请求的内存区域必须全部在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: - Destination array
dstOffset: - Offset in bytes of destination array
srcArray: - Source array
srcOffset: - Offset in bytes of source array
ByteCount: - Size of memory copy in bytes

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。

另请参阅：

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: - Destination device pointer
srcArray: - Source array
srcOffset: - Offset in bytes of source array
ByteCount: - Size of memory copy in bytes

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将数据从一维CUDA数组复制到设备内存。dstDevice指定目标内存的基础指针，必须与CUDA数组元素自然对齐。srcArray和srcOffset分别指定CUDA数组句柄和数组内开始复制的字节偏移量。ByteCount指定要复制的字节数，必须能被数组元素大小整除。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。

另请参阅：

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: - Destination device pointer
srcArray: - Source array
srcOffset: - Offset in bytes of source array
ByteCount: - Size of memory copy in bytes

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。
请求的内存区域必须全部在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: - Destination pointer
srcArray: - Source array
srcOffset: - Offset in bytes of source array
ByteCount: - Size of memory copy in bytes
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出异步行为。
此函数使用标准的默认流语义。
请求的内存区域必须全部在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: - Array of destination pointers.
srcs: - Array of memcpy source pointers.
sizes: - Array of sizes for memcpy operations.
count: - Size of dsts, srcs and sizes arrays
attrs: - Array of memcpy attributes.
attrsIdxs: - Array of indices to specify which copies each entry in the attrs array applies to. The attributes specified in attrs[k] will be applied to copies starting from attrsIdxs[k] through attrsIdxs[k+1] - 1. Also attrs[numAttrs-1] will apply to copies starting from attrsIdxs[numAttrs-1] through count - 1.
numAttrs: - Size of attrs and attrsIdxs arrays.
failIdx: - Pointer to a location to return the index of the copy where a failure was encountered. The value will be SIZE_MAX if the error doesn't pertain to any specific copy.
hStream: - The stream to enqueue the operations in. Must not be legacy NULL stream.

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指定的相同。例如，如果一个批次在dst/src/sizes中有10个副本，其中前6个具有一组属性，其余4个具有另一组属性，那么numAttrs将为2，attrsIdxs将为{0, 6}，而attrs将包含这两组属性。请注意，attrsIdxs的第一个条目必须始终为0。此外，每个条目必须大于前一个条目，最后一个条目应小于count。此外，numAttrs必须小于或等于count。

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的设备上系统分配的可分页内存。对于其他情况，这些提示将被忽略。

CUmemcpyAttributes::flags 字段可用于为拷贝操作指定特定标志。设置 CU_MEMCPY_FLAG_PREFER_OVERLAP_WITH_COMPUTE 标志表示关联的拷贝操作应优先与任何计算工作重叠。请注意，此标志仅作为提示，可能会根据平台和拷贝的其他参数而被忽略。

如果在解析批次时遇到任何错误，将返回批次中遇到错误的索引位置，存储在failIdx中。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出异步行为。
请求的内存区域必须完全在CUDA中注册，或者在主机可分页传输的情况下完全不注册。不支持跨越已注册和未在CUDA中注册的内存分配区域，此类操作将返回CUDA_ERROR_INVALID_VALUE错误。

CUresult cuMemcpyDtoA ( CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount )

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

参数

dstArray: - Destination array
dstOffset: - Offset in bytes of destination array
srcDevice: - Source device pointer
ByteCount: - Size of memory copy in bytes

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将数据从设备内存复制到一维CUDA数组。dstArray和dstOffset分别指定目标数据的CUDA数组句柄和起始索引。srcDevice指定源数据的基础指针。ByteCount指定要复制的字节数。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。

另请参阅：

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: - Destination device pointer
srcDevice: - Source device pointer
ByteCount: - Size of memory copy in bytes

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。

另请参阅：

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: - Destination device pointer
srcDevice: - Source device pointer
ByteCount: - Size of memory copy in bytes
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出异步行为。
该函数使用标准的默认流语义。

另请参阅：

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: - Destination host pointer
srcDevice: - Source device pointer
ByteCount: - Size of memory copy in bytes

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。
请求的内存区域必须全部在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: - Destination host pointer
srcDevice: - Source device pointer
ByteCount: - Size of memory copy in bytes
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出异步行为。
此函数使用标准的默认流语义。
请求的内存区域必须全部在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: - Destination array
dstOffset: - Offset in bytes of destination array
srcHost: - Source host pointer
ByteCount: - Size of memory copy in bytes

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。
请求的内存区域必须全部在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: - Destination array
dstOffset: - Offset in bytes of destination array
srcHost: - Source host pointer
ByteCount: - Size of memory copy in bytes
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

将数据从主机内存复制到一维CUDA数组。dstArray和dstOffset分别指定目标数据的CUDA数组句柄和以字节为单位的起始偏移量。srcHost指定源数据的基础地址。ByteCount指定要复制的字节数。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出异步行为。
此函数使用标准的默认流语义。
请求的内存区域必须全部在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: - Destination device pointer
srcHost: - Source host pointer
ByteCount: - Size of memory copy in bytes

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。
请求的内存区域必须全部在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: - Destination device pointer
srcHost: - Source host pointer
ByteCount: - Size of memory copy in bytes
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出异步行为。
此函数使用标准的默认流语义。
请求的内存区域必须全部在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: - Destination device pointer
dstContext: - Destination context
srcDevice: - Source device pointer
srcContext: - Source context
ByteCount: - Size of memory copy in bytes

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将数据从一个上下文中的设备内存复制到另一个上下文中的设备内存。dstDevice是目标内存的基础设备指针，dstContext是目标上下文。srcDevice是源内存的基础设备指针，srcContext是源指针。ByteCount指定要复制的字节数。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出同步行为。

另请参阅：

cuMemcpyDtoD, cuMemcpy3DPeer, cuMemcpyDtoDAsync, cuMemcpyPeerAsync, cuMemcpy3DPeerAsync, cudaMemcpyPeer

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

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

参数

dstDevice: - Destination device pointer
dstContext: - Destination context
srcDevice: - Source device pointer
srcContext: - Source context
ByteCount: - Size of memory copy in bytes
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

描述

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
该函数在大多数使用场景下表现出异步行为。
该函数使用标准的默认流语义。

另请参阅：

cuMemcpyDtoD, cuMemcpyPeer, cuMemcpy3DPeer, cuMemcpyDtoDAsync, cuMemcpy3DPeerAsync, cudaMemcpyPeerAsync

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

初始化设备内存。

参数

dstDevice: - Destination device pointer
us: - Value to set
N: - Number of elements

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将N个16位值的内存范围设置为指定值us。dstDevice指针必须两字节对齐。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
另请参阅 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, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemset

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

设置设备内存。

参数

dstDevice: - Destination device pointer
us: - Value to set
N: - Number of elements
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将N个16位值的内存范围设置为指定值us。dstDevice指针必须按两字节对齐。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
另请参阅 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, cuMemsetD32, cuMemsetD32Async, cudaMemsetAsync

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

初始化设备内存。

参数

dstDevice: - Destination device pointer
dstPitch: - Pitch of destination device pointer(Unused if Height is 1)
us: - Value to set
Width: - Width of row
Height: - Number of rows

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
另请参阅 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: - Destination device pointer
dstPitch: - Pitch of destination device pointer(Unused if Height is 1)
us: - Value to set
Width: - Width of row
Height: - Number of rows
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
另请参阅 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: - Destination device pointer
dstPitch: - Pitch of destination device pointer(Unused if Height is 1)
ui: - Value to set
Width: - Width of row
Height: - Number of rows

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
另请参阅 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: - Destination device pointer
dstPitch: - Pitch of destination device pointer(Unused if Height is 1)
ui: - Value to set
Width: - Width of row
Height: - Number of rows
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
另请参阅 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: - Destination device pointer
dstPitch: - Pitch of destination device pointer(Unused if Height is 1)
uc: - Value to set
Width: - Width of row
Height: - Number of rows

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

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

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
另请参阅 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: - Destination device pointer
dstPitch: - Pitch of destination device pointer(Unused if Height is 1)
uc: - Value to set
Width: - Width of row
Height: - Number of rows
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
另请参阅 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: - Destination device pointer
ui: - Value to set
N: - Number of elements

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将N个32位值的内存范围设置为指定值ui。dstDevice指针必须四字节对齐。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
另请参阅 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: - Destination device pointer
ui: - Value to set
N: - Number of elements
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将N个32位值的内存范围设置为指定值ui。dstDevice指针必须四字节对齐。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
另请参阅 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: - Destination device pointer
uc: - Value to set
N: - Number of elements

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将N个8位值的内存范围设置为指定值uc。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
另请参阅 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, cuMemsetD32Async, cudaMemset

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

设置设备内存。

参数

dstDevice: - Destination device pointer
uc: - Value to set
N: - Number of elements
hStream: - Stream identifier

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

描述

将N个8位值的内存范围设置为指定值uc。

Note:

请注意，此函数也可能返回之前异步启动的错误代码。
另请参阅 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, cuMemsetD16, cuMemsetD16Async, cuMemsetD32, cuMemsetD32Async, cudaMemsetAsync

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

创建一个CUDA mipmapped数组。

参数

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

描述

根据CUDA_ARRAY3D_DESCRIPTOR结构体pMipmappedArrayDesc创建一个CUDA多级渐远纹理数组，并在*pHandle中返回新创建的CUDA多级渐远纹理数组的句柄。numMipmapLevels指定要分配的mipmap层级数量。该值会被限制在[1, 1 + floor(log2(max(width, height, depth)))]范围内。

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;

where:

Width, Height, and Depth are the width, height, and depth of the CUDA array (in elements); the following types of CUDA arrays can be allocated:
- 如果Height和Depth范围均为零，则会分配一个一维mipmapped数组。
- 如果仅Depth范围为0，则会分配一个2D mipmapped数组。
- 如果三个维度范围均不为零，则分配一个3D mipmapped数组。
- 如果仅Height为零且设置了CUDA_ARRAY3D_LAYERED标志，则会分配一个一维分层CUDA mipmapped数组。每一层都是一个一维数组。层数由深度范围决定。
- 如果所有三个维度均非零且设置了CUDA_ARRAY3D_LAYERED标志，则会分配一个2D分层CUDA mipmapped数组。每层都是一个2D数组，层数由深度维度决定。
- 如果三个维度均非零且设置了CUDA_ARRAY3D_CUBEMAP标志，则会分配一个立方体贴图CUDA多级渐远纹理数组。Width必须等于Height，且Depth必须为6。立方体贴图是一种特殊的2D分层CUDA数组，其中六个层面对应立方体的六个面。内存中六个图层的排列顺序与CUarray_cubemap_face中列出的顺序相同。
- 当所有三个维度均非零且同时设置了CUDA_ARRAY3D_CUBEMAP和CUDA_ARRAY3D_LAYERED标志时，将分配一个立方体贴图分层的CUDA多级渐远纹理数组。Width必须等于Height，且Depth必须是六的倍数。立方体贴图分层的CUDA数组是一种特殊类型的2D分层CUDA数组，由一系列立方体贴图组成。前六个层级代表第一个立方体贴图，接下来的六个层级构成第二个立方体贴图，以此类推。

Format specifies the format of the elements; CUarray_format is defined as:

‎    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 may be set to
- CUDA_ARRAY3D_LAYERED 用于启用分层CUDA mipmapped数组的创建。如果设置了此标志，Depth指定的是层数，而非3D数组的深度。
- CUDA_ARRAY3D_SURFACE_LDST 用于启用将表面引用绑定到CUDA多级渐远纹理数组的各个mipmap层级。如果未设置此标志，当尝试将CUDA多级渐远纹理数组的mipmap层级绑定到表面引用时，cuSurfRefSetArray 将会失败。
- CUDA_ARRAY3D_CUBEMAP 用于启用创建mipmapped立方体贴图。如果设置了此标志，Width 必须等于 Height，且 Depth 必须为六。如果同时设置了 CUDA_ARRAY3D_LAYERED 标志，则 Depth 必须是六的倍数。
- CUDA_ARRAY3D_TEXTURE_GATHER 表示该CUDA mipmapped数组将用于纹理聚集。纹理聚集只能在2D CUDA mipmapped数组上执行。

Width、Height 和 Depth 必须满足下表中列出的特定尺寸要求。所有值都以元素为单位指定。请注意，为简洁起见，未指定设备属性的全称。例如，TEXTURE1D_MIPMAPPED_WIDTH 指的是设备属性 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH。

CUDA数组类型	必须始终满足的有效范围 {(以元素为单位的宽度范围), (高度范围), (深度范围)}	设置CUDA_ARRAY3D_SURFACE_LDST时的有效范围 {(以元素为单位的宽度范围), (高度范围), (深度范围)}
一维	{ (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) } 或者 { (1,TEXTURE3D_WIDTH_ALTERNATE), (1,TEXTURE3D_HEIGHT_ALTERNATE), (1,TEXTURE3D_DEPTH_ALTERNATE) }	{ (1,SURFACE3D_WIDTH), (1,SURFACE3D_HEIGHT), (1,SURFACE3D_DEPTH) }
一维分层	{ (1,TEXTURE1D_LAYERED_WIDTH), 0, (1,TEXTURE1D_LAYERED_LAYERS) }	{ (1,SURFACE1D_LAYERED_WIDTH), 0, (1,SURFACE1D_LAYERED_LAYERS) }
二维分层	{ (1,TEXTURE2D_LAYERED_WIDTH), (1,TEXTURE2D_LAYERED_HEIGHT), (1,TEXTURE2D_LAYERED_LAYERS) }	{ (1,SURFACE2D_LAYERED_WIDTH), (1,SURFACE2D_LAYERED_HEIGHT), (1,SURFACE2D_LAYERED_LAYERS) }
立方体贴图	{ (1,TEXTURECUBEMAP_WIDTH), (1,TEXTURECUBEMAP_WIDTH), 6 }	{ (1,SURFACECUBEMAP_WIDTH), (1,SURFACECUBEMAP_WIDTH), 6 }
立方体贴图分层	{ (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_LAYERS) }	{ (1,SURFACECUBEMAP_LAYERED_WIDTH), (1,SURFACECUBEMAP_LAYERED_WIDTH), (1,SURFACECUBEMAP_LAYERED_LAYERS) }