CUDA 运行时 API :: CUDA 工具包文档

获取指定 cudaArray 的信息。

参数

desc: - 返回的数组类型
extent: - 返回的数组形状。2D 数组的深度将为零
flags: - 返回的数组标志
array: - 要获取信息的 cudaArray

返回值

cudaSuccess, cudaErrorInvalidValue

描述

在以下项中返回*desc, *extent和*flags分别是array.

的类型、形状和标志*desc, *extent和*flags的任何一项

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

另请参阅

__host__ cudaError_t cudaArrayGetMemoryRequirements ( cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device )

参数

返回 CUDA 数组的内存需求。: memoryRequirements
array: - 指向 cudaArrayMemoryRequirements 的指针
array: - 要获取内存需求的 CUDA 数组

返回值

device

描述

- 获取内存需求的设备返回 CUDA 数组的内存需求。cudaSuccess cudaErrorInvalidValue

在

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

中返回 CUDA 数组的内存需求

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

参数

cudaMipmappedArrayGetMemoryRequirements: __host__ cudaError_t cudaArrayGetPlane ( cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx ) 从 CUDA 数组获取 CUDA 数组平面。
pPlaneArray: - 返回的 CUDA 数组，由
从 CUDA 数组获取 CUDA 数组平面。: planeIdx

返回值

引用

描述

在以下项中返回cudaMipmappedArrayGetMemoryRequirementshArraypPlaneArray.

- CUDA 数组从 CUDA 数组获取 CUDA 数组平面。- 平面索引

cudaSuccess, cudaErrorInvalidValue cudaErrorInvalidResourceHandlepPlaneArray表示 CUDA 数组的单个格式平面的 CUDA 数组从 CUDA 数组获取 CUDA 数组平面。如果pPlaneArray大于此数组中的最大平面数，或者如果数组没有多平面格式，例如：cudaChannelFormatKindNV12，则返回 cudaErrorInvalidValue。从 CUDA 数组获取 CUDA 数组平面。请注意，如果pPlaneArray的格式为 cudaChannelFormatKindNV12，则为

都可以指定为 NULL。

注意

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

传入 0 会返回与

但具有一个 8 位通道和 cudaChannelFormatKindUnsigned 作为其格式类型。如果为

参数

传入 1，则返回的 CUDA 数组的高度和宽度为: 的一半
array: 具有两个 8 位通道和 cudaChannelFormatKindUnsigned 作为其格式类型。

返回值

device

描述

cuArrayGetPlane传入 1，则返回的 CUDA 数组的高度和宽度为 __host__ cudaError_t cudaArrayGetSparseProperties ( cudaArraySparseProperties* sparseProperties, cudaArray_t array )

返回稀疏 CUDA 数组的布局属性。arraysparsePropertiesarray- 指向返回 cudaArraySparseProperties 的指针

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

array

在

参数

中返回稀疏 CUDA 数组的布局属性。: 如果 CUDA 数组不是使用标志 cudaArraySparse 分配的，则会返回 cudaErrorInvalidValue。

返回值

cudaSuccess, cudaErrorInvalidValue

描述

如果 cudaArraySparseProperties::flags 中返回的值包含 cudaArraySparsePropertiesSingleMipTail，则 cudaArraySparseProperties::miptailSize 表示数组的总大小。否则，它将为零。此外，cudaArraySparseProperties::miptailFirstLevel 中返回的值始终为零。请注意，中返回稀疏 CUDA 数组的布局属性。必须已使用 cudaMallocArray 或 cudaMalloc3DArray 分配。cudaMipmappedArrayGetSparseProperties 必须用于获取 cudaMipmappedArrayGetSparseProperties 所属的整个 CUDA mipmapped 数组的稀疏属性。对于使用 cudaMipmappedArrayGetLevel 获取的 CUDA 数组，将返回 cudaErrorInvalidValue。

属于。

cudaMipmappedArrayGetSparseProperties, cuMemMapArrayAsync中返回稀疏 CUDA 数组的布局属性。 __host__ __device__ cudaError_t cudaFree ( void* devPtr ) 中返回稀疏 CUDA 数组的布局属性。释放设备上的内存。

devPtr- 要释放的内存的设备指针释放

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

指向的内存空间，该空间必须由先前调用以下内存分配 API 之一返回 - cudaMalloc(), cudaMallocPitch(), cudaMallocManaged(), cudaMallocAsync(), cudaMallocFromPoolAsync()。

如果之前已调用 cudaFree(

参数

array: )，则会返回错误。如果

返回值

cudaSuccess, cudaErrorInvalidValue

描述

为 0，则不执行任何操作。如果失败，cudaFree() 返回 cudaErrorValue。array设备版本的 cudaFree 不能与使用主机 API 分配的中返回稀疏 CUDA 数组的布局属性。*devPtr

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

一起使用，反之亦然。

__host__ cudaError_t cudaFreeArray ( cudaArray_t array )

参数

释放设备上的数组。: array

返回值

cudaSuccess, cudaErrorInvalidValue

描述

如果 cudaArraySparseProperties::flags 中返回的值包含 cudaArraySparsePropertiesSingleMipTail，则 cudaArraySparseProperties::miptailSize 表示数组的总大小。否则，它将为零。此外，cudaArraySparseProperties::miptailFirstLevel 中返回的值始终为零。请注意，- 要释放的数组的指针释放 CUDA 数组

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMalloc, cudaMallocPitch, cudaFree, cudaMallocArray, cudaFreeArray, cudaMallocHost ( C API), cudaMalloc3D, cudaMalloc3DArray, cudaHostAlloc, cuMemFreeHost

释放设备上的多级渐远纹理数组。

参数

mipmappedArray: - 指向要释放的多级渐远纹理数组的指针

返回值

cudaSuccess, cudaErrorInvalidValue

描述

释放 CUDA 多级渐远纹理数组mipmappedArray，该数组必须是通过先前调用 cudaMallocMipmappedArray() 返回的。如果中返回稀疏 CUDA 数组的布局属性。*devPtr

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMalloc, cudaMallocPitch, cudaFree, cudaMallocArray, cudaMallocHost ( C API), cudaFreeHost, cudaHostAlloc, cuMipmappedArrayDestroy

获取 CUDA 多级渐远纹理数组的某个多级渐远纹理层级。

参数

levelArray: - 返回的多级渐远纹理层级 CUDA 数组
mipmappedArray: - CUDA 多级渐远纹理数组
level: - 多级渐远纹理层级

返回值

引用

描述

在以下项中返回*levelArray表示 CUDA 多级渐远纹理数组的单个多级渐远纹理层级的 CUDA 数组mipmappedArray.

- CUDA 数组level大于此多级渐远纹理数组中的最大层级数，则返回 cudaErrorInvalidValue 错误。

- CUDA 数组mipmappedArray为 NULL，则返回 cudaErrorInvalidResourceHandle 错误。

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMalloc3D, cudaMalloc, cudaMallocPitch, cudaFree, cudaFreeArray, cudaMallocHost ( C API), cudaFreeHost, cudaHostAlloc, make_cudaExtent, cuMipmappedArrayGetLevel

查找与 CUDA 符号关联的地址。

参数

中返回稀疏 CUDA 数组的布局属性。: - 返回与符号关联的设备指针
symbol: - 设备符号地址

返回值

cudaSuccess, cudaErrorInvalidSymbol, cudaErrorNoKernelImageForDevice

描述

在以下项中返回- 要释放的内存的设备指针符号的地址symbol在设备上。symbol是一个驻留在全局或常量内存空间中的变量。如果symbol无法找到，或者如果symbol未在全局或常量内存空间中声明，则- 要释放的内存的设备指针保持不变，并返回错误 cudaErrorInvalidSymbol。

都可以指定为 NULL。

注意
在 CUDA 4.1 中，已弃用将命名变量的字符串用作symbol参数，并在 CUDA 5.0 中移除。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaGetSymbolAddress ( C++ API), cudaGetSymbolSize ( C API), cuModuleGetGlobal

查找与 CUDA 符号关联的对象的大小。

参数

size: - 与符号关联的对象的大小
symbol: - 设备符号地址

返回值

cudaSuccess, cudaErrorInvalidSymbol, cudaErrorNoKernelImageForDevice

描述

在以下项中返回*size符号的大小symbol. symbol是一个驻留在全局或常量内存空间中的变量。如果symbol无法找到，或者如果symbol未在全局或常量内存空间中声明，则*size保持不变，并返回错误 cudaErrorInvalidSymbol。

都可以指定为 NULL。

注意
在 CUDA 4.1 中，已弃用将命名变量的字符串用作symbol参数，并在 CUDA 5.0 中移除。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaGetSymbolAddress ( C API), cudaGetSymbolSize ( C++ API), cuModuleGetGlobal

在主机上分配页锁定内存。

参数

pHost: - 指向已分配内存的设备指针
size: - 请求的分配大小（以字节为单位）
flags: - 请求的已分配内存属性

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorMemoryAllocation

描述

分配size字节的主机内存，该内存已页锁定且可供设备访问。驱动程序跟踪由此函数分配的虚拟内存范围，并自动加速对诸如 cudaMemcpy() 等函数的调用。由于设备可以直接访问内存，因此与使用诸如 malloc() 等函数获得的可分页内存相比，可以以更高的带宽读取或写入内存。分配过多的固定内存可能会降低系统性能，因为它减少了系统可用于分页的内存量。因此，此函数最好谨慎使用，以分配主机和设备之间数据交换的暂存区。

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

cudaHostAllocDefault：此标志的值定义为 0，并使 cudaHostAlloc() 模拟 cudaMallocHost()。
cudaHostAllocPortable：此调用返回的内存将被所有 CUDA 上下文视为固定内存，而不仅仅是执行分配的上下文。
cudaHostAllocMapped：将分配映射到 CUDA 地址空间中。可以通过调用 cudaHostGetDevicePointer() 获取指向内存的设备指针。
cudaHostAllocWriteCombined：将内存分配为写入合并 (WC)。在某些系统配置上，WC 内存可以通过 PCI Express 总线更快地传输，但大多数 CPU 无法有效地读取它。WC 内存非常适合由 CPU 写入并通过映射的固定内存或主机->设备传输由设备读取的缓冲区。

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

为了使 cudaHostAllocMapped 标志生效，CUDA 上下文必须支持 cudaDeviceMapHost 标志，可以通过 cudaGetDeviceFlags() 进行检查。cudaDeviceMapHost 标志对于通过运行时 API 创建的上下文隐式设置。

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

由此函数分配的内存必须使用 cudaFreeHost() 释放。

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaSetDeviceFlags, cudaMallocHost ( C API), cudaFreeHost, cudaGetDeviceFlags, cuMemHostAlloc

返回由 cudaHostAlloc 分配或由 cudaHostRegister 注册的映射主机内存的设备指针。

参数

pDevice: - 映射内存的返回设备指针
pHost: - 请求的主机指针映射
flags: - 扩展标志（目前必须为 0）

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorMemoryAllocation

描述

返回与由 cudaHostAlloc() 分配或由 cudaHostRegister() 注册的映射的固定主机缓冲区相对应的设备指针。

如果在延迟上下文创建发生之前未指定 cudaDeviceMapHost 标志，或者在不支持映射固定内存的设备上调用，则 cudaHostGetDevicePointer() 将失败。

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

flags为将来的版本提供。目前，它必须设置为 0。

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaSetDeviceFlags, cudaHostAlloc, cuMemHostGetDevicePointer

返回用于分配由 cudaHostAlloc 分配的固定主机内存的标志。

参数

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

返回值

cudaSuccess, cudaErrorInvalidValue

描述

如果输入指针未驻留在由 cudaHostAlloc() 分配的地址范围内，则 cudaHostGetFlags() 将失败。

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaHostAlloc, cuMemHostGetFlags

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

参数

释放设备上的数组。: - 指向要页锁定的内存的主机指针
size: - 要页锁定的地址范围的大小（以字节为单位）
flags: - 分配请求的标志

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorMemoryAllocation, cudaErrorHostMemoryAlreadyRegistered, cudaErrorNotSupported

描述

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

在 pageableMemoryAccessUsesHostPageTables 为 true 的系统上，cudaHostRegister 将不会页锁定由释放设备上的数组。指定的内存范围，而只会填充未填充的页面。

cudaHostRegister 仅在 I/O 一致性设备上受支持，这些设备的设备属性 cudaDevAttrHostRegisterSupported 的值不为零。

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

cudaHostRegisterDefault：在具有统一虚拟寻址的系统上，内存将既是映射的又是可移植的。在没有统一虚拟寻址的系统上，内存将既不是映射的也不是可移植的。

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

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

cudaHostRegisterIoMemory：传递的内存指针被视为指向某些内存映射的 I/O 空间，例如属于第三方 PCIe 设备，它将被标记为非缓存一致性和连续性。

cudaHostRegisterReadOnly：传递的内存指针被视为指向被设备视为只读的内存。在没有 cudaDevAttrPageableMemoryAccessUsesHostPageTables 的平台上，为了将映射到 CPU 的内存注册为只读，需要此标志。可以使用设备属性 cudaDevAttrHostRegisterReadOnlySupported 查询对此标志使用的支持。将此标志与关联到未设置此属性的设备的当前上下文一起使用将导致 cudaHostRegister 返回 cudaErrorNotSupported 错误。

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

CUDA 上下文必须已使用 cudaMapHost 标志创建，cudaHostRegisterMapped 标志才能生效。

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

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

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

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaHostUnregister, cudaHostGetFlags, cudaHostGetDevicePointer, cuMemHostRegister

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

参数

释放设备上的数组。: - 指向要取消注册的内存的主机指针

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorHostMemoryNotRegistered

描述

取消映射由释放设备上的数组。指定的基地址的内存范围，并使其再次可分页。

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

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaHostUnregister, cuMemHostUnregister

在设备上分配内存。

参数

中返回稀疏 CUDA 数组的布局属性。: - 指向已分配设备内存的指针
size: - 请求的分配大小（以字节为单位）

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorMemoryAllocation

描述

分配size设备上的线性内存字节数，并在- 要释放的内存的设备指针中返回指向已分配内存的指针。分配的内存适当地对齐，以用于任何类型的变量。内存未被清除。cudaMalloc() 在失败的情况下返回 cudaErrorMemoryAllocation。

devPtr- 要释放的内存的设备指针释放

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMallocPitch, cudaFree, cudaMallocArray, cudaFreeArray, cudaMalloc3D, cudaMalloc3DArray, cudaMallocHost ( C API), cudaFreeHost, cudaHostAlloc, cuMemAlloc

在设备上分配逻辑 1D、2D 或 3D 内存对象。

参数

pitchedDevPtr: - 指向已分配的跨距设备内存的指针
extent: - 请求的分配大小（width字段，以字节为单位）

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorMemoryAllocation

描述

在设备上分配至少width * height * depth字节的线性内存，并返回一个 cudaPitchedPtr，其中释放设备上的数组。是指向已分配内存的指针。该函数可能会填充分配，以确保满足硬件对齐要求。在pitch的字段中返回的跨距pitchedDevPtr是以字节为单位的分配宽度。

返回的 cudaPitchedPtr 包含其他字段xsize和ysize，即分配的逻辑宽度和高度，它们等效于程序员在分配期间提供的width和heightextent参数。

对于 2D 和 3D 对象的分配，强烈建议程序员使用 cudaMalloc3D() 或 cudaMallocPitch() 执行分配。由于硬件中的对齐限制，如果应用程序将执行涉及 2D 或 3D 对象（无论是线性内存还是 CUDA 数组）的内存拷贝，则尤其如此。

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMallocPitch, cudaFree, cudaMemcpy3D, cudaMemset3D, cudaMalloc3DArray, cudaMallocArray, cudaFreeArray, cudaMallocHost ( C API), cudaFreeHost, cudaHostAlloc, make_cudaPitchedPtr, make_cudaExtent, cuMemAllocPitch

在设备上分配数组。

参数

array: - 指向设备内存中已分配数组的指针
desc: - 请求的通道格式
extent: - 请求的分配大小（width字段，以元素为单位）
flags: - 扩展标志

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorMemoryAllocation

描述

根据 cudaChannelFormatDesc 结构分配 CUDA 数组desc并在以下位置返回新 CUDA 数组的句柄*array.

cudaChannelFormatDesc 定义为

‎    struct cudaChannelFormatDesc {
              int x, y, z, w;
              enum cudaChannelFormatKind 
                  f;
          };

其中 cudaChannelFormatKind 是 cudaChannelFormatKindSigned、cudaChannelFormatKindUnsigned 或 cudaChannelFormatKindFloat 之一。

cudaMalloc3DArray() 可以分配以下内容

如果高度和深度范围均为零，则分配 1D 数组。
如果仅深度范围为零，则分配 2D 数组。
如果所有三个范围均为非零，则分配 3D 数组。
如果仅高度范围为零且设置了 cudaArrayLayered 标志，则分配 1D 分层 CUDA 数组。每个层都是一个 1D 数组。层数由深度范围确定。
如果所有三个范围均为非零且设置了 cudaArrayLayered 标志，则分配 2D 分层 CUDA 数组。每个层都是一个 2D 数组。层数由深度范围确定。
如果所有三个范围均为非零且设置了 cudaArrayCubemap 标志，则分配立方体贴图 CUDA 数组。宽度必须等于高度，深度必须为六。立方体贴图是一种特殊的 2D 分层 CUDA 数组，其中六个层表示立方体的六个面。内存中六个层的顺序与 cudaGraphicsCubeFace 中列出的顺序相同。
如果所有三个范围均为非零，并且同时设置了 cudaArrayCubemap 和 cudaArrayLayered 标志，则分配立方体贴图分层 CUDA 数组。宽度必须等于高度，深度必须是六的倍数。立方体贴图分层 CUDA 数组是一种特殊的 2D 分层 CUDA 数组，它由立方体贴图的集合组成。前六层表示第一个立方体贴图，接下来的六层构成第二个立方体贴图，依此类推。

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

cudaArrayDefault：此标志的值定义为 0，并提供默认数组分配
cudaArrayLayered：分配分层 CUDA 数组，深度范围指示层数
cudaArrayCubemap：分配立方体贴图 CUDA 数组。宽度必须等于高度，深度必须为六。如果还设置了 cudaArrayLayered 标志，则深度必须是六的倍数。
cudaArraySurfaceLoadStore：分配可以使用表面引用读取或写入的 CUDA 数组。
cudaArrayTextureGather：此标志指示将在 CUDA 数组上执行纹理Gather操作。纹理Gather操作只能在 2D CUDA 数组上执行。
cudaArraySparse：分配没有物理后备内存的 CUDA 数组。此稀疏数组中的子区域稍后可以通过调用 cuMemMapArrayAsync 映射到物理内存分配。此标志只能用于创建 2D、3D 或 2D 分层稀疏 CUDA 数组。物理后备内存必须通过 cuMemCreate 分配。
cudaArrayDeferredMapping：分配没有物理后备内存的 CUDA 数组。整个数组稍后可以通过调用 cuMemMapArrayAsync 映射到物理内存分配。物理后备内存必须通过 cuMemCreate 分配。

宽度、高度和深度范围必须满足下表列出的某些尺寸要求。所有值均以元素为单位指定。

请注意，如果设置了 cudaArrayTextureGather 标志，则 2D CUDA 数组具有不同的尺寸要求。在这种情况下，(宽度，高度，深度) 的有效范围是 ((1,maxTexture2DGather[0]), (1,maxTexture2DGather[1]), 0)。

CUDA 数组类型	必须始终满足的有效范围 {(以元素为单位的宽度范围), (高度范围), (深度范围)}	设置 cudaArraySurfaceLoadStore 的有效范围 {(以元素为单位的宽度范围), (高度范围), (深度范围)}
1D	{ (1,maxTexture1D), 0, 0 }	{ (1,maxSurface1D), 0, 0 }
2D	{ (1,maxTexture2D[0]), (1,maxTexture2D[1]), 0 }	{ (1,maxSurface2D[0]), (1,maxSurface2D[1]), 0 }
3D	{ (1,maxTexture3D[0]), (1,maxTexture3D[1]), (1,maxTexture3D[2]) } 或 { (1,maxTexture3DAlt[0]), (1,maxTexture3DAlt[1]), (1,maxTexture3DAlt[2]) }	{ (1,maxSurface3D[0]), (1,maxSurface3D[1]), (1,maxSurface3D[2]) }
1D 分层	{ (1,maxTexture1DLayered[0]), 0, (1,maxTexture1DLayered[1]) }	{ (1,maxSurface1DLayered[0]), 0, (1,maxSurface1DLayered[1]) }
2D 分层	{ (1,maxTexture2DLayered[0]), (1,maxTexture2DLayered[1]), (1,maxTexture2DLayered[2]) }	{ (1,maxSurface2DLayered[0]), (1,maxSurface2DLayered[1]), (1,maxSurface2DLayered[2]) }
立方体贴图	{ (1,maxTextureCubemap), (1,maxTextureCubemap), 6 }	{ (1,maxSurfaceCubemap), (1,maxSurfaceCubemap), 6 }
立方体贴图分层	{ (1,maxTextureCubemapLayered[0]), (1,maxTextureCubemapLayered[0]), (1,maxTextureCubemapLayered[1]) }	{ (1,maxSurfaceCubemapLayered[0]), (1,maxSurfaceCubemapLayered[0]), (1,maxSurfaceCubemapLayered[1]) }

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMalloc3D, cudaMalloc, cudaMallocPitch, cudaFree, cudaFreeArray, cudaMallocHost ( C API), cudaFreeHost, cudaHostAlloc, make_cudaExtent, cuArray3DCreate

在设备上分配数组。

参数

array: - 指向设备内存中已分配数组的指针
desc: - 请求的通道格式
width: - 请求的数组分配宽度
height: - 请求的数组分配高度
flags: - 请求的已分配数组的属性

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorMemoryAllocation

描述

根据 cudaChannelFormatDesc 结构分配 CUDA 数组desc并在以下位置返回新 CUDA 数组的句柄*array.

cudaChannelFormatDesc 定义为

‎    struct cudaChannelFormatDesc {
              int x, y, z, w;
          enum cudaChannelFormatKind 
                  f;
          };

其中 cudaChannelFormatKind 是 cudaChannelFormatKindSigned、cudaChannelFormatKindUnsigned 或 cudaChannelFormatKindFloat 之一。

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

cudaArrayDefault：此标志的值定义为 0，并提供默认数组分配
cudaArraySurfaceLoadStore：分配可以使用表面引用读取或写入的数组
cudaArrayTextureGather：此标志指示将在数组上执行纹理Gather操作。
cudaArraySparse：分配没有物理后备内存的 CUDA 数组。此稀疏数组中的子区域稍后可以通过调用 cuMemMapArrayAsync 映射到物理内存分配。物理后备内存必须通过 cuMemCreate 分配。
cudaArrayDeferredMapping：分配没有物理后备内存的 CUDA 数组。整个数组稍后可以通过调用 cuMemMapArrayAsync 映射到物理内存分配。物理后备内存必须通过 cuMemCreate 分配。

width和height必须满足某些尺寸要求。有关更多详细信息，请参见 cudaMalloc3DArray()。

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMalloc, cudaMallocPitch, cudaFree, cudaFreeArray, cudaMallocHost ( C API), cudaFreeHost, cudaMalloc3D, cudaMalloc3DArray, cudaHostAlloc, cuArrayCreate

在主机上分配页锁定内存。

参数

释放设备上的数组。: - 指向已分配主机内存的指针
size: - 请求的分配大小（以字节为单位）

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorMemoryAllocation

描述

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

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

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

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMalloc, cudaMallocPitch, cudaMallocArray, cudaMalloc3D, cudaMalloc3DArray, cudaHostAlloc, cudaFree, cudaFreeArray, cudaMallocHost ( C++ API), cudaFreeHost, cudaHostAlloc, cuMemAllocHost

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

参数

中返回稀疏 CUDA 数组的布局属性。: - 指向已分配设备内存的指针
size: - 请求的分配大小（以字节为单位）
flags: - 必须是 cudaMemAttachGlobal 或 cudaMemAttachHost 之一（默认为 cudaMemAttachGlobal）

返回值

cudaSuccess, cudaErrorMemoryAllocation, cudaErrorNotSupported, cudaErrorInvalidValue

描述

分配size设备上托管内存的字节数，并在以下位置返回- 要释放的内存的设备指针指向已分配内存的指针。如果设备不支持分配托管内存，则返回 cudaErrorNotSupported。可以使用设备属性 cudaDevAttrManagedMemory 查询对托管内存的支持。分配的内存已适当对齐，可用于任何类型的变量。内存未被清除。如果size为 0，则 cudaMallocManaged 返回 cudaErrorInvalidValue。该指针在 CPU 和系统中所有支持托管内存的 GPU 上均有效。对此指针的所有访问都必须遵守统一内存编程模型。

flags指定此分配的默认流关联。flags必须是 cudaMemAttachGlobal 或 cudaMemAttachHost 之一。的默认值为flags是 cudaMemAttachGlobal。如果指定 cudaMemAttachGlobal，则可以从任何设备上的任何流访问此内存。如果指定 cudaMemAttachHost，则不应从设备属性 cudaDevAttrConcurrentManagedAccess 值为零的设备访问分配；需要显式调用 cudaStreamAttachMemAsync 才能在此类设备上启用访问。

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

使用 cudaMallocManaged 分配的内存应使用 cudaFree 释放。

对于设备属性 cudaDevAttrConcurrentManagedAccess 值非零的 GPU，设备内存超额订阅是可能的。此类 GPU 上的托管内存可能随时被统一内存驱动程序从设备内存中逐出到主机内存中，以便为其他分配腾出空间。

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

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

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

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

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMallocPitch, cudaFree, cudaMallocArray, cudaFreeArray, cudaMalloc3D, cudaMalloc3DArray, cudaMallocHost ( C API), cudaFreeHost, cudaHostAlloc, cudaDeviceGetAttribute, cudaStreamAttachMemAsync, cuMemAllocManaged

在设备上分配 mipmapped 数组。

参数

mipmappedArray: - 指向设备内存中已分配的 mipmapped 数组的指针
desc: - 请求的通道格式
extent: - 请求的分配大小（width字段，以元素为单位）
numLevels: - 要分配的 mipmap 级别数
flags: - 扩展标志

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorMemoryAllocation

描述

根据 cudaChannelFormatDesc 结构分配 CUDA mipmapped 数组desc并在以下位置返回新 CUDA mipmapped 数组的句柄*mipmappedArray. numLevels指定要分配的 mipmap 级别数。此值被限制在 [1, 1 + floor(log2(max(宽度, 高度, 深度)))] 范围内。

cudaChannelFormatDesc 定义为

‎    struct cudaChannelFormatDesc {
              int x, y, z, w;
              enum cudaChannelFormatKind 
                  f;
          };

其中 cudaChannelFormatKind 是 cudaChannelFormatKindSigned、cudaChannelFormatKindUnsigned 或 cudaChannelFormatKindFloat 之一。

cudaMallocMipmappedArray() 可以分配以下内容

如果高度和深度范围均为零，则分配 1D mipmapped 数组。
如果仅深度范围为零，则分配 2D mipmapped 数组。
如果所有三个范围均为非零，则分配 3D mipmapped 数组。
如果仅高度范围为零且设置了 cudaArrayLayered 标志，则分配 1D 分层 CUDA mipmapped 数组。每个层都是一个 1D mipmapped 数组。层数由深度范围确定。
如果所有三个范围均为非零且设置了 cudaArrayLayered 标志，则分配 2D 分层 CUDA mipmapped 数组。每个层都是一个 2D mipmapped 数组。层数由深度范围确定。
如果所有三个范围均为非零且设置了 cudaArrayCubemap 标志，则分配立方体贴图 CUDA mipmapped 数组。宽度必须等于高度，深度必须为六。内存中六个层的顺序与 cudaGraphicsCubeFace 中列出的顺序相同。
如果所有三个范围均为非零，并且同时设置了 cudaArrayCubemap 和 cudaArrayLayered 标志，则分配立方体贴图分层 CUDA mipmapped 数组。宽度必须等于高度，深度必须是六的倍数。立方体贴图分层 CUDA mipmapped 数组是一种特殊的 2D 分层 CUDA mipmapped 数组，它由立方体贴图 mipmapped 数组的集合组成。前六层表示第一个立方体贴图 mipmapped 数组，接下来的六层构成第二个立方体贴图 mipmapped 数组，依此类推。

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

cudaArrayDefault：此标志的值定义为 0，并提供默认 mipmapped 数组分配
cudaArrayLayered：分配分层 CUDA mipmapped 数组，深度范围指示层数
cudaArrayCubemap：分配立方体贴图 CUDA mipmapped 数组。宽度必须等于高度，深度必须为六。如果还设置了 cudaArrayLayered 标志，则深度必须是六的倍数。
cudaArraySurfaceLoadStore：此标志指示 CUDA mipmapped 数组的各个 mipmap 级别将使用表面引用进行读取或写入。
cudaArrayTextureGather：此标志指示将在 CUDA 数组上执行纹理Gather操作。纹理Gather操作只能在 2D CUDA mipmapped 数组上执行，并且Gather操作仅在最详细的 mipmap 级别上执行。
cudaArraySparse：分配没有物理后备内存的 CUDA mipmapped 数组。此稀疏数组中的子区域稍后可以通过调用 cuMemMapArrayAsync 映射到物理内存分配。此标志只能用于创建 2D、3D 或 2D 分层稀疏 CUDA mipmapped 数组。物理后备内存必须通过 cuMemCreate 分配。
cudaArrayDeferredMapping：分配没有物理后备内存的 CUDA mipmapped 数组。整个数组稍后可以通过调用 cuMemMapArrayAsync 映射到物理内存分配。物理后备内存必须通过 cuMemCreate 分配。

宽度、高度和深度范围必须满足下表列出的某些尺寸要求。所有值均以元素为单位指定。

CUDA 数组类型	必须始终满足的有效范围 {(以元素为单位的宽度范围), (高度范围), (深度范围)}	设置 cudaArraySurfaceLoadStore 的有效范围 {(以元素为单位的宽度范围), (高度范围), (深度范围)}
1D	{ (1,maxTexture1DMipmap), 0, 0 }	{ (1,maxSurface1D), 0, 0 }
2D	{ (1,maxTexture2DMipmap[0]), (1,maxTexture2DMipmap[1]), 0 }	{ (1,maxSurface2D[0]), (1,maxSurface2D[1]), 0 }
3D	{ (1,maxTexture3D[0]), (1,maxTexture3D[1]), (1,maxTexture3D[2]) } 或 { (1,maxTexture3DAlt[0]), (1,maxTexture3DAlt[1]), (1,maxTexture3DAlt[2]) }	{ (1,maxSurface3D[0]), (1,maxSurface3D[1]), (1,maxSurface3D[2]) }
1D 分层	{ (1,maxTexture1DLayered[0]), 0, (1,maxTexture1DLayered[1]) }	{ (1,maxSurface1DLayered[0]), 0, (1,maxSurface1DLayered[1]) }
2D 分层	{ (1,maxTexture2DLayered[0]), (1,maxTexture2DLayered[1]), (1,maxTexture2DLayered[2]) }	{ (1,maxSurface2DLayered[0]), (1,maxSurface2DLayered[1]), (1,maxSurface2DLayered[2]) }
立方体贴图	{ (1,maxTextureCubemap), (1,maxTextureCubemap), 6 }	{ (1,maxSurfaceCubemap), (1,maxSurfaceCubemap), 6 }
立方体贴图分层	{ (1,maxTextureCubemapLayered[0]), (1,maxTextureCubemapLayered[0]), (1,maxTextureCubemapLayered[1]) }	{ (1,maxSurfaceCubemapLayered[0]), (1,maxSurfaceCubemapLayered[0]), (1,maxSurfaceCubemapLayered[1]) }

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMalloc3D, cudaMalloc, cudaMallocPitch, cudaFree, cudaFreeArray, cudaMallocHost ( C API), cudaFreeHost, cudaHostAlloc, make_cudaExtent, cuMipmappedArrayCreate

在设备上分配 pitched 内存。

参数

中返回稀疏 CUDA 数组的布局属性。: - 指向已分配的跨距设备内存的指针
pitch: - 分配的跨距
width: - 请求的 pitched 分配宽度（以字节为单位）
height: - 请求的 pitched 分配高度

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorMemoryAllocation

描述

在设备上分配至少width（以字节为单位）*height设备上的线性内存字节数，并在- 要释放的内存的设备指针指向已分配内存的指针。该函数可能会填充分配，以确保任何给定行中的相应指针在地址从一行更新到另一行时，将继续满足合并的对齐要求。在以下位置返回的跨距*pitch通过 cudaMallocPitch() 返回的是分配的宽度（以字节为单位）。的预期用途是pitch作为分配的单独参数，用于计算 2D 数组中的地址。给定类型为数组元素的行和列T，地址计算为

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

对于 2D 数组的分配，建议程序员考虑使用 cudaMallocPitch() 执行 pitch 分配。由于硬件中存在 pitch 对齐限制，因此如果应用程序将在设备内存的不同区域（无论是线性内存还是 CUDA 数组）之间执行 2D 内存复制，则尤其如此。

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMalloc, cudaFree, cudaMallocArray, cudaFreeArray, cudaMallocHost ( C API), cudaFreeHost, cudaMalloc3D, cudaMalloc3DArray, cudaHostAlloc, cuMemAllocPitch

建议给定内存范围的用法。

参数

中返回稀疏 CUDA 数组的布局属性。: - 指向要设置建议的内存的指针
count: - 内存范围的大小（以字节为单位）
advice: - 要应用于指定内存范围的建议
array: - 应用建议的设备

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevice

描述

就起始于以下位置的内存范围的用法模式向统一内存子系统提供建议中返回稀疏 CUDA 数组的布局属性。大小为count字节。在应用建议之前，内存范围的起始地址和结束地址将分别向下和向上舍入，以与 CPU 页大小对齐。内存范围必须引用通过 cudaMallocManaged 分配或通过 __managed__ 变量声明的托管内存。内存范围也可以引用系统分配的可分页内存，前提是它表示有效的、主机可访问的内存区域，并且满足以下施加的所有附加约束advice如下所述也得到满足。指定无效的系统分配的可分页内存范围将导致返回错误。

参数advice参数可以采用以下值

cudaMemAdviseSetReadMostly：这意味着数据主要将被读取，而仅偶尔写入。任何处理器对该区域的读取访问都将在该处理器的内存中创建至少所访问页面的只读副本。此外，如果在此区域上调用 cudaMemPrefetchAsync，则将在目标处理器上创建数据的只读副本。如果任何处理器写入此区域，则除了写入发生的副本之外，相应页面的所有副本都将失效。此array参数在此建议中被忽略。请注意，要使页面被读取复制，访问处理器必须是 CPU 或 GPU，并且该 GPU 的设备属性 cudaDevAttrConcurrentManagedAccess 的值必须为非零。此外，如果在不具有设备属性 cudaDevAttrConcurrentManagedAccess 设置的设备上创建上下文，则在销毁所有此类上下文之前，不会发生读取复制。如果内存区域引用有效的系统分配的可分页内存，则访问设备必须具有设备属性 cudaDevAttrPageableMemoryAccess 的非零值，才能在该设备上创建只读副本。但是请注意，如果访问设备还具有设备属性 cudaDevAttrPageableMemoryAccessUsesHostPageTables 的非零值，则设置此建议不会在该设备访问此内存区域时创建只读副本。

cudaMemAdviceUnsetReadMostly：撤消 cudaMemAdviceReadMostly 的效果，并阻止统一内存驱动程序尝试对内存范围进行启发式读取复制。数据的任何读取复制副本都将折叠为单个副本。如果页面具有首选位置，并且其中一个读取复制的副本驻留在该位置，则折叠副本的位置将为首选位置。否则，选择的位置是任意的。

cudaMemAdviseSetPreferredLocation：此建议将数据的首选位置设置为属于以下设备的内存array。传入 cudaCpuDeviceId 作为array将首选位置设置为主机内存。如果array是 GPU，则它必须具有设备属性 cudaDevAttrConcurrentManagedAccess 的非零值。设置首选位置不会立即导致数据迁移到该位置。相反，它在内存区域发生故障时指导迁移策略。如果数据已在其首选位置，并且发生故障的处理器可以建立映射而无需迁移数据，则将避免数据迁移。另一方面，如果数据不在其首选位置，或者无法建立直接映射，则数据将迁移到访问它的处理器。重要的是要注意，设置首选位置不会阻止使用 cudaMemPrefetchAsync 完成的数据预取。具有首选位置可以覆盖统一内存驱动程序中的页面抖动检测和解决逻辑。通常，如果检测到页面在例如主机和设备内存之间不断抖动，则该页面最终可能会被统一内存驱动程序固定到主机内存。但是，如果首选位置设置为设备内存，则该页面将无限期地继续抖动。如果在此内存区域或其任何子集上还设置了 cudaMemAdviseSetReadMostly，则与该建议关联的策略将覆盖此建议的策略，除非来自array的读取访问不会导致在该设备上创建只读副本，如建议 cudaMemAdviseSetReadMostly 的描述中所述。如果内存区域引用有效的系统分配的可分页内存，则array必须具有设备属性 cudaDevAttrPageableMemoryAccess 的非零值。

cudaMemAdviseUnsetPreferredLocation：撤消 cudaMemAdviseSetPreferredLocation 的效果，并将首选位置更改为无。

cudaMemAdviseSetAccessedBy：此建议意味着数据将由以下处理器访问array。传入 cudaCpuDeviceId 作为array将为 CPU 设置建议。如果array是 GPU，则设备属性 cudaDevAttrConcurrentManagedAccess 必须为非零。此建议不会导致数据迁移，并且本身对数据的位置没有影响。相反，只要数据的位置允许建立映射，它就会导致数据始终映射到指定处理器的页表中。如果数据因任何原因而迁移，则映射将相应更新。在数据局部性不重要但避免故障很重要的情况下，建议使用此建议。例如，考虑一个包含多个启用对等访问的 GPU 的系统，其中位于一个 GPU 上的数据偶尔会被对等 GPU 访问。在这种情况下，将数据迁移到其他 GPU 并不那么重要，因为访问不频繁，并且迁移开销可能太高。但是，防止故障仍然可以帮助提高性能，因此提前设置映射很有用。请注意，在 CPU 访问此数据时，数据可能会迁移到主机内存，因为 CPU 通常无法直接访问设备内存。任何为此数据设置了 cudaMemAdviceSetAccessedBy 标志的 GPU 现在都将更新其映射以指向主机内存中的页面。如果在此内存区域或其任何子集上还设置了 cudaMemAdviseSetReadMostly，则与该建议关联的策略将覆盖此建议的策略。此外，如果此内存区域或其任何子集的首选位置也是array，则与 cudaMemAdviseSetPreferredLocation 关联的策略将覆盖此建议的策略。如果内存区域引用有效的系统分配的可分页内存，则array必须具有设备属性 cudaDevAttrPageableMemoryAccess 的非零值。此外，如果array具有设备属性 cudaDevAttrPageableMemoryAccessUsesHostPageTables 的非零值，则此调用无效。

cudaMemAdviseUnsetAccessedBy：撤消 cudaMemAdviseSetAccessedBy 的效果。来自以下设备的数据的任何映射array可能会随时删除，从而导致访问产生非致命页面错误。如果内存区域引用有效的系统分配的可分页内存，则array必须具有设备属性 cudaDevAttrPageableMemoryAccess 的非零值。此外，如果array具有设备属性 cudaDevAttrPageableMemoryAccessUsesHostPageTables 的非零值，则此调用无效。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemcpy, cudaMemcpyPeer, cudaMemcpyAsync, cudaMemcpy3DPeerAsync, cudaMemPrefetchAsync, cuMemAdvise

建议给定内存范围的用法。

参数

中返回稀疏 CUDA 数组的布局属性。: - 指向要设置建议的内存的指针
count: - 内存范围的大小（以字节为单位）
advice: - 要应用于指定内存范围的建议
location: - 应用建议的位置

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevice

描述

就起始于以下位置的内存范围的用法模式向统一内存子系统提供建议中返回稀疏 CUDA 数组的布局属性。大小为count字节。在应用建议之前，内存范围的起始地址和结束地址将分别向下和向上舍入，以与 CPU 页大小对齐。内存范围必须引用通过 cudaMallocManaged 分配或通过 __managed__ 变量声明的托管内存。内存范围也可以引用系统分配的可分页内存，前提是它表示有效的、主机可访问的内存区域，并且满足以下施加的所有附加约束advice如下所述也得到满足。指定无效的系统分配的可分页内存范围将导致返回错误。

参数advice参数可以采用以下值

cudaMemAdviseSetReadMostly：这意味着数据主要将被读取，而仅偶尔写入。任何处理器对该区域的读取访问都将在该处理器的内存中创建至少所访问页面的只读副本。此外，如果在此区域上调用 cudaMemPrefetchAsync 或 cudaMemPrefetchAsync_v2，则将在目标处理器上创建数据的只读副本。如果 cudaMemPrefetchAsync_v2 的目标位置是主机 NUMA 节点，并且另一个主机 NUMA 节点上已存在只读副本，则该副本将迁移到目标主机 NUMA 节点。如果任何处理器写入此区域，则除了写入发生的副本之外，相应页面的所有副本都将失效。如果写入处理器是 CPU，并且页面的首选位置是主机 NUMA 节点，则页面也将迁移到该主机 NUMA 节点。此location参数在此建议中被忽略。请注意，要使页面被读取复制，访问处理器必须是 CPU 或 GPU，并且该 GPU 的设备属性 cudaDevAttrConcurrentManagedAccess 的值必须为非零。此外，如果在不具有设备属性 cudaDevAttrConcurrentManagedAccess 设置的设备上创建上下文，则在销毁所有此类上下文之前，不会发生读取复制。如果内存区域引用有效的系统分配的可分页内存，则访问设备必须具有设备属性 cudaDevAttrPageableMemoryAccess 的非零值，才能在该设备上创建只读副本。但是请注意，如果访问设备还具有设备属性 cudaDevAttrPageableMemoryAccessUsesHostPageTables 的非零值，则设置此建议不会在该设备访问此内存区域时创建只读副本。

cudaMemAdviceUnsetReadMostly：撤消 cudaMemAdviseSetReadMostly 的效果，并阻止统一内存驱动程序尝试对内存范围进行启发式读取复制。数据的任何读取复制副本都将折叠为单个副本。如果页面具有首选位置，并且其中一个读取复制的副本驻留在该位置，则折叠副本的位置将为首选位置。否则，选择的位置是任意的。注意：此location参数在此建议中被忽略。

cudaMemAdviseSetPreferredLocation：此建议将数据的首选位置设置为属于以下设备的内存location。当 cudaMemLocation::type 为 cudaMemLocationTypeHost 时，cudaMemLocation::id 将被忽略，并且首选位置将设置为主机内存。要将首选位置设置为特定的主机 NUMA 节点，应用程序必须将 cudaMemLocation::type 设置为 cudaMemLocationTypeHostNuma，并且 cudaMemLocation::id 必须指定主机 NUMA 节点的 NUMA ID。如果 cudaMemLocation::type 设置为 cudaMemLocationTypeHostNumaCurrent，则 cudaMemLocation::id 将被忽略，并且最靠近调用线程 CPU 的主机 NUMA 节点将用作首选位置。如果 cudaMemLocation::type 是 cudaMemLocationTypeDevice，则 cudaMemLocation::id 必须是有效的设备序号，并且设备必须具有设备属性 cudaDevAttrConcurrentManagedAccess 的非零值。设置首选位置不会立即导致数据迁移到该位置。相反，它在内存区域发生故障时指导迁移策略。如果数据已在其首选位置，并且发生故障的处理器可以建立映射而无需迁移数据，则将避免数据迁移。另一方面，如果数据不在其首选位置，或者无法建立直接映射，则数据将迁移到访问它的处理器。重要的是要注意，设置首选位置不会阻止使用 cudaMemPrefetchAsync 完成的数据预取。具有首选位置可以覆盖统一内存驱动程序中的页面抖动检测和解决逻辑。通常，如果检测到页面在例如主机和设备内存之间不断抖动，则该页面最终可能会被统一内存驱动程序固定到主机内存。但是，如果首选位置设置为设备内存，则该页面将无限期地继续抖动。如果在此内存区域或其任何子集上还设置了 cudaMemAdviseSetReadMostly，则与该建议关联的策略将覆盖此建议的策略，除非来自location的读取访问不会导致在该处理器上创建只读副本，如建议 cudaMemAdviseSetReadMostly 的描述中所述。如果内存区域引用有效的系统分配的可分页内存，并且 cudaMemLocation::type 是 cudaMemLocationTypeDevice，则 cudaMemLocation::id 必须是具有设备属性 cudaDevAttrPageableMemoryAccess 的非零值的有效设备。

cudaMemAdviseUnsetPreferredLocation：撤消 cudaMemAdviseSetPreferredLocation 的效果，并将首选位置更改为无。此location参数在此建议中被忽略。

cudaMemAdviseSetAccessedBy：此建议意味着数据将由处理器访问location。 cudaMemLocation::type 必须是 cudaMemLocationTypeDevice，其中 cudaMemLocation::id 表示有效的设备序号，或者 cudaMemLocationTypeHost，并且 cudaMemLocation::id 将被忽略。所有其他位置类型均无效。如果 cudaMemLocation::id 是 GPU，则设备属性 cudaDevAttrConcurrentManagedAccess 必须为非零。此建议不会导致数据迁移，并且本身对数据的位置没有影响。相反，只要数据的位置允许建立映射，它就会导致数据始终映射到指定处理器的页表中。如果数据因任何原因而迁移，则映射将相应更新。在数据局部性不重要但避免故障很重要的情况下，建议使用此建议。例如，考虑一个包含多个启用对等访问的 GPU 的系统，其中位于一个 GPU 上的数据偶尔会被对等 GPU 访问。在这种情况下，将数据迁移到其他 GPU 并不那么重要，因为访问不频繁，并且迁移开销可能太高。但是，防止故障仍然可以帮助提高性能，因此提前设置映射很有用。请注意，在 CPU 访问此数据时，数据可能会迁移到主机内存，因为 CPU 通常无法直接访问设备内存。任何为此数据设置了 cudaMemAdviseSetAccessedBy 标志的 GPU 现在都将更新其映射以指向主机内存中的页面。如果在此内存区域或其任何子集上还设置了 cudaMemAdviseSetReadMostly，则与该建议关联的策略将覆盖此建议的策略。此外，如果此内存区域或其任何子集的首选位置也是location，则与 CU_MEM_ADVISE_SET_PREFERRED_LOCATION 关联的策略将覆盖此建议的策略。如果内存区域引用有效的系统分配的可分页内存，并且 cudaMemLocation::type 是 cudaMemLocationTypeDevice，则 cudaMemLocation::id 中的设备必须具有设备属性 cudaDevAttrPageableMemoryAccess 的非零值。此外，如果 cudaMemLocation::id 具有设备属性 cudaDevAttrPageableMemoryAccessUsesHostPageTables 的非零值，则此调用无效。

CU_MEM_ADVISE_UNSET_ACCESSED_BY：撤消 cudaMemAdviseSetAccessedBy 的效果。来自以下设备的数据的任何映射location可能会随时删除，从而导致访问产生非致命页面错误。如果内存区域引用有效的系统分配的可分页内存，并且 cudaMemLocation::type 是 cudaMemLocationTypeDevice，则 cudaMemLocation::id 中的设备必须具有设备属性 cudaDevAttrPageableMemoryAccess 的非零值。此外，如果 cudaMemLocation::id 具有设备属性 cudaDevAttrPageableMemoryAccessUsesHostPageTables 的非零值，则此调用无效。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemcpy, cudaMemcpyPeer, cudaMemcpyAsync, cudaMemcpy3DPeerAsync, cudaMemPrefetchAsync, cuMemAdvise, cuMemAdvise_v2

获取可用和总设备内存。

参数

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

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorLaunchFailure

描述

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

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

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cuMemGetInfo

将内存预取到指定的目的设备。

参数

中返回稀疏 CUDA 数组的布局属性。: - 要预取的指针
count: - 大小（以字节为单位）
dstDevice: - 要预取到的目的设备
stream: - 用于将预取操作入队的流

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevice

描述

将内存预取到指定的目的设备。中返回稀疏 CUDA 数组的布局属性。是要预取的内存的基设备指针，而dstDevice是目的设备。count指定要复制的字节数。stream是操作入队的流。内存范围必须引用通过 cudaMallocManaged 分配或通过 __managed__ 变量声明的托管内存，或者它也可以引用具有非零 cudaDevAttrPageableMemoryAccess 的系统上的系统分配内存。

传入 cudaCpuDeviceId 作为dstDevice会将数据预取到主机内存。如果dstDevice是 GPU，则设备属性 cudaDevAttrConcurrentManagedAccess 必须为非零。此外，stream必须与具有设备属性 cudaDevAttrConcurrentManagedAccess 的非零值的设备关联。

在预取操作入队到流中之前，内存范围的起始地址和结束地址将分别向下和向上舍入，以与 CPU 页大小对齐。

如果尚未为此区域分配物理内存，则将在目的设备上填充和映射此内存区域。如果内存不足以预取所需的区域，统一内存驱动程序可能会从其他 cudaMallocManaged 分配中驱逐页面到主机内存，以便腾出空间。使用 cudaMalloc 或 cudaMallocArray 分配的设备内存将不会被驱逐。

默认情况下，将删除任何到已迁移页面的先前位置的映射，并且仅在以下设备上设置新位置的映射dstDevice。但是，确切的行为还取决于通过 cudaMemAdvise 应用于此内存范围的设置，如下所述

如果在该内存范围的任何子集上设置了 cudaMemAdviseSetReadMostly，则该子集将在以下设备上创建页面的只读副本dstDevice.

如果在该内存范围的任何子集上调用了 cudaMemAdviseSetPreferredLocation，则页面将迁移到dstDevice即使dstDevice不是内存范围中任何页面的首选位置。

如果在该内存范围的任何子集上调用了 cudaMemAdviseSetAccessedBy，则来自所有适当处理器的到这些页面的映射将被更新以引用新位置（如果可以建立此类映射）。否则，这些映射将被清除。

请注意，此 API 不是功能必需的，仅用于通过允许应用程序在访问数据之前将数据迁移到合适的位置来提高性能。对此范围的内存访问始终是一致的，即使在数据正在主动迁移时也是允许的。

请注意，此函数相对于主机和所有其他设备上的工作是异步的。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemcpy, cudaMemcpyPeer, cudaMemcpyAsync, cudaMemcpy3DPeerAsync, cudaMemAdvise, cudaMemAdvise_v2 cuMemPrefetchAsync

将内存预取到指定的目标位置。

参数

中返回稀疏 CUDA 数组的布局属性。: - 要预取的指针
count: - 大小（以字节为单位）
location: - 预取到的位置
flags: - 供将来使用的标志，现在必须为零。
stream: - 用于将预取操作入队的流

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevice

描述

将内存预取到指定的目标位置。中返回稀疏 CUDA 数组的布局属性。是要预取的内存的基设备指针，而location指定目标位置。count指定要复制的字节数。stream是操作入队的流。内存范围必须引用通过 cudaMallocManaged 分配或通过 __managed__ 变量声明的托管内存，或者它也可以引用具有非零 cudaDevAttrPageableMemoryAccess 的系统上的系统分配内存。

为 cudaMemLocation::type 指定 cudaMemLocationTypeDevice 将预取内存到由设备序号 cudaMemLocation::id 指定的 GPU，该 GPU 必须具有非零值的设备属性 concurrentManagedAccess。此外，stream必须与具有非零值设备属性 concurrentManagedAccess 的设备相关联。为 cudaMemLocation::type 指定 cudaMemLocationTypeHost 将预取数据到主机内存。应用程序可以通过为 cudaMemLocation::type 指定 cudaMemLocationTypeHostNuma 并在 cudaMemLocation::id 中指定有效的主机 NUMA 节点 ID，来请求将内存预取到特定的主机 NUMA 节点。用户还可以通过为 cudaMemLocation::type 指定 cudaMemLocationTypeHostNumaCurrent，来请求将内存预取到最接近当前线程 CPU 的主机 NUMA 节点。请注意，当 cudaMemLocation::type 是 cudaMemLocationTypeHost 或 cudaMemLocationTypeHostNumaCurrent 时，cudaMemLocation::id 将被忽略。

在预取操作入队到流中之前，内存范围的起始地址和结束地址将分别向下和向上舍入，以与 CPU 页大小对齐。

如果尚未为此区域分配物理内存，则将在目的设备上填充和映射此内存区域。如果内存不足以预取所需的区域，统一内存驱动程序可能会从其他 cudaMallocManaged 分配中驱逐页面到主机内存，以便腾出空间。使用 cudaMalloc 或 cudaMallocArray 分配的设备内存将不会被驱逐。

默认情况下，任何到迁移页面先前位置的映射都将被移除，并且仅在目标位置设置新位置的映射。然而，确切的行为还取决于通过 cuMemAdvise 应用于此内存范围的设置，如下所述

如果对该内存范围的任何子集设置了 cudaMemAdviseSetReadMostly，则该子集将在目标位置创建页面的只读副本。但是，如果目标位置是主机 NUMA 节点，则该子集中已位于另一个主机 NUMA 节点的任何页面都将传输到目标位置。

如果在该内存范围的任何子集上调用了 cudaMemAdviseSetPreferredLocation，则页面将迁移到location即使location不是内存范围中任何页面的首选位置。

如果在该内存范围的任何子集上调用了 cudaMemAdviseSetAccessedBy，则来自所有适当处理器的到这些页面的映射将被更新以引用新位置（如果可以建立此类映射）。否则，这些映射将被清除。

请注意，此 API 不是功能必需的，仅用于通过允许应用程序在访问数据之前将数据迁移到合适的位置来提高性能。对此范围的内存访问始终是一致的，即使在数据正在主动迁移时也是允许的。

请注意，此函数相对于主机和所有其他设备上的工作是异步的。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemcpy, cudaMemcpyPeer, cudaMemcpyAsync, cudaMemcpy3DPeerAsync, cudaMemAdvise, cudaMemAdvise_v2 cuMemPrefetchAsync

查询给定内存范围的属性。

参数

data: - 指向内存位置的指针，每个属性查询的结果将写入到该位置。
dataSize: - 包含 data 大小的数组
attribute: - 要查询的属性
中返回稀疏 CUDA 数组的布局属性。: - 要查询的范围的起始地址
count: - 要查询的范围的大小

返回值

cudaSuccess, cudaErrorInvalidValue

描述

查询从中返回稀疏 CUDA 数组的布局属性。大小为count字节开始的内存范围的属性。内存范围必须引用通过 cudaMallocManaged 分配或通过 __managed__ 变量声明的托管内存。

参数attribute参数可以采用以下值

cudaMemRangeAttributeReadMostly: 如果指定此属性，data将被解释为 32 位整数，并且dataSize必须为 4。如果给定内存范围中的所有页面都启用了只读复制，则返回的结果为 1，否则为 0。
cudaMemRangeAttributePreferredLocation: 如果指定此属性，data将被解释为 32 位整数，并且dataSize必须为 4。如果内存范围中的所有页面都将该 GPU 作为其首选位置，则返回的结果将是一个 GPU 设备 ID；如果内存范围中的所有页面都将 CPU 作为其首选位置，则返回的结果将是 cudaCpuDeviceId；如果所有页面没有相同的首选位置，或者某些页面根本没有首选位置，则返回的结果将是 cudaInvalidDeviceId。请注意，查询时内存范围中页面的实际位置可能与首选位置不同。
cudaMemRangeAttributeAccessedBy: 如果指定此属性，data将被解释为 32 位整数数组，并且dataSize必须是 4 的非零倍数。返回的结果将是为整个内存范围设置了 cudaMemAdviceSetAccessedBy 的设备 ID 列表。如果任何设备未为整个内存范围设置该建议，则该设备将不包括在内。如果data大于已为该内存范围设置建议的设备数量，则将在提供的所有额外空间中返回 cudaInvalidDeviceId。例如，如果dataSize为 12（即data有 3 个元素），并且只有设备 0 设置了建议，则返回的结果将是 { 0, cudaInvalidDeviceId, cudaInvalidDeviceId }。如果data小于已设置该建议的设备数量，则只会返回可以容纳在数组中的设备数量。但是，不能保证将返回哪些特定设备。
cudaMemRangeAttributeLastPrefetchLocation: 如果指定此属性，data将被解释为 32 位整数，并且dataSize必须为 4。返回的结果将是所有页面通过 cudaMemPrefetchAsync 显式预取的最后一个位置。这将是 GPU ID 或 cudaCpuDeviceId，具体取决于上次预取的位置是 GPU 还是 CPU。如果内存范围中的任何页面从未显式预取，或者如果所有页面未预取到同一位置，则将返回 cudaInvalidDeviceId。请注意，这仅返回应用程序请求将内存范围预取到的最后一个位置。它不指示到该位置的预取操作是否已完成甚至开始。
cudaMemRangeAttributePreferredLocationType: 如果指定此属性，data将被解释为 cudaMemLocationType，并且dataSize必须为 sizeof(cudaMemLocationType)。如果内存范围中的所有页面都具有相同的 GPU 作为其首选位置，则返回的 cudaMemLocationType 将是 cudaMemLocationTypeDevice；如果内存范围中的所有页面都将 CPU 作为其首选位置，则 cudaMemLocationType 将是 cudaMemLocationTypeHost；如果内存范围中的所有页面都具有相同的主机 NUMA 节点 ID 作为其首选位置，则将是 cudaMemLocationTypeHostNuma；如果所有页面没有相同的首选位置，或者某些页面根本没有首选位置，则将是 cudaMemLocationTypeInvalid。请注意，查询时内存范围中页面的实际位置类型可能与首选位置类型不同。
- cudaMemRangeAttributePreferredLocationId: 如果指定此属性，data将被解释为 32 位整数，并且dataSize必须为 4。如果同一地址范围的 cudaMemRangeAttributePreferredLocationType 查询返回 cudaMemLocationTypeDevice，则它将是一个有效的设备序号；如果它返回 cudaMemLocationTypeHostNuma，则它将是一个有效的主机 NUMA 节点 ID；如果它返回任何其他位置类型，则应忽略该 ID。
cudaMemRangeAttributeLastPrefetchLocationType: 如果指定此属性，data将被解释为 cudaMemLocationType，并且dataSize必须为 sizeof(cudaMemLocationType)。返回的结果将是所有页面通过 cuMemPrefetchAsync 显式预取的最后一个位置类型。如果上次预取位置是 GPU，则返回的 cudaMemLocationType 将是 cudaMemLocationTypeDevice；如果是 CPU，则为 cudaMemLocationTypeHost；如果上次预取位置是特定的主机 NUMA 节点，则为 cudaMemLocationTypeHostNuma。如果内存范围中的任何页面从未显式预取，或者如果所有页面未预取到同一位置，则 CUmemLocationType 将为 cudaMemLocationTypeInvalid。请注意，这仅返回应用程序请求将内存范围预取到的最后一个位置类型。它不指示到该位置的预取操作是否已完成甚至开始。
- cudaMemRangeAttributeLastPrefetchLocationId: 如果指定此属性，data将被解释为 32 位整数，并且dataSize必须为 4。如果同一地址范围的 cudaMemRangeAttributeLastPrefetchLocationType 查询返回 cudaMemLocationTypeDevice，则它将是一个有效的设备序号；如果它返回 cudaMemLocationTypeHostNuma，则它将是一个有效的主机 NUMA 节点 ID；如果它返回任何其他位置类型，则应忽略该 ID。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemRangeGetAttributes, cudaMemPrefetchAsync, cudaMemAdvise, cuMemRangeGetAttribute

查询给定内存范围的属性。

参数

data: - 一个二维数组，包含指向内存位置的指针，每个属性查询的结果将写入到这些位置。
dataSizes: - 包含每个结果大小的数组
attributes: - 要查询的属性数组（numAttributes 和此数组中的属性数量应匹配）
numAttributes: - 要查询的属性数量
中返回稀疏 CUDA 数组的布局属性。: - 要查询的范围的起始地址
count: - 要查询的范围的大小

返回值

cudaSuccess, cudaErrorInvalidValue

描述

查询从中返回稀疏 CUDA 数组的布局属性。大小为count字节开始的内存范围的属性。内存范围必须引用通过 cudaMallocManaged 分配或通过 __managed__ 变量声明的托管内存。attributes数组将被解释为具有numAttributes个条目。dataSizes数组也将被解释为具有numAttributes个条目。查询结果将存储在data.

支持的属性列表如下。有关属性描述和限制，请参阅 cudaMemRangeGetAttribute。

cudaMemRangeAttributeReadMostly
cudaMemRangeAttributePreferredLocation
cudaMemRangeAttributeAccessedBy
cudaMemRangeAttributeLastPrefetchLocation
:: cudaMemRangeAttributePreferredLocationType
:: cudaMemRangeAttributePreferredLocationId
:: cudaMemRangeAttributeLastPrefetchLocationType
:: cudaMemRangeAttributeLastPrefetchLocationId

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemRangeGetAttribute, cudaMemAdvise, cudaMemPrefetchAsync, cuMemRangeGetAttributes

在主机和设备之间复制数据。

参数

dst: - 目标内存地址
src: - 源内存地址
count: - 要复制的字节大小
kind: - 传输类型

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidMemcpyDirection

描述

从count指向的内存区域复制src字节到dst指向的内存区域，其中kind指定复制的方向，并且必须是 cudaMemcpyHostToHost、cudaMemcpyHostToDevice、cudaMemcpyDeviceToHost、cudaMemcpyDeviceToDevice 或 cudaMemcpyDefault 之一。建议传递 cudaMemcpyDefault，在这种情况下，传输类型将从指针值推断出来。但是，只有在支持统一虚拟寻址的系统上才允许使用 cudaMemcpyDefault。使用与复制方向不匹配的 dst 和 src 指针调用 cudaMemcpy() 会导致未定义的行为。

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。
对于大多数用例，此函数表现出同步行为。
请求的内存区域必须完全注册到 CUDA，或者在主机可分页传输的情况下，完全不注册。不支持跨越同时注册和未注册到 CUDA 的分配的内存区域，并将返回 CUDA_ERROR_INVALID_VALUE。

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

cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DFromArray, cudaMemcpy2DArrayToArray, cudaMemcpyToSymbol, cudaMemcpyFromSymbol, cudaMemcpyAsync, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync, cuMemcpyDtoH, cuMemcpyHtoD, cuMemcpyDtoD, cuMemcpy

在主机和设备之间复制数据。

参数

dst: - 目标内存地址
dpitch: - 目标内存的 pitch
src: - 源内存地址
spitch: - 源内存的 pitch
width: - 矩阵传输的宽度（以字节为单位的列数）
height: - 矩阵传输的高度（行数）
kind: - 传输类型

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection

描述

从height行，每行width字节的矩阵，从src字节到dst指向的内存区域，其中kind指定复制的方向，并且必须是 cudaMemcpyHostToHost、cudaMemcpyHostToDevice、cudaMemcpyDeviceToHost、cudaMemcpyDeviceToDevice 或 cudaMemcpyDefault 之一。建议传递 cudaMemcpyDefault，在这种情况下，传输类型将从指针值推断出来。但是，只有在支持统一虚拟寻址的系统上才允许使用 cudaMemcpyDefault。dpitch和spitch是以字节为单位的 2D 数组的内存宽度，由dst和src指向，包括添加到每行末尾的任何填充。内存区域可能不重叠。width不得超过dpitch或spitch。使用dst和src指针调用 cudaMemcpy2D()，如果这些指针与复制方向不匹配，则会导致未定义的行为。如果dpitch或spitch超过允许的最大值，cudaMemcpy2D() 将返回错误。

都可以指定为 NULL。

注意
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。
请求的内存区域必须完全注册到 CUDA，或者在主机可分页传输的情况下，完全不注册。不支持跨越同时注册和未注册到 CUDA 的分配的内存区域，并将返回 CUDA_ERROR_INVALID_VALUE。

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

cudaMemcpy, cudaMemcpy2DToArray, cudaMemcpy2DFromArray, cudaMemcpy2DArrayToArray, cudaMemcpyToSymbol, cudaMemcpyFromSymbol, cudaMemcpyAsync, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync, cuMemcpy2D, cuMemcpy2DUnaligned

在主机和设备之间复制数据。

参数

dst: - 目标内存地址
wOffsetDst: - 目标起始 X 偏移量（以字节为单位的列数）
hOffsetDst: - 目标起始 Y 偏移量（行数）
src: - 源内存地址
wOffsetSrc: - 源起始 X 偏移量（以字节为单位的列数）
hOffsetSrc: - 源起始 Y 偏移量（行数）
width: - 矩阵传输的宽度（以字节为单位的列数）
height: - 矩阵传输的高度（行数）
kind: - 传输类型

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidMemcpyDirection

描述

从height行，每行width行，每行src字节，从 CUDA 数组hOffsetSrc行和wOffsetSrc字节（从左上角开始）复制到 CUDA 数组dst字节，从 CUDA 数组hOffsetDst行和wOffsetDst字节（从左上角开始），其中kind指定复制的方向，并且必须是 cudaMemcpyHostToHost、cudaMemcpyHostToDevice、cudaMemcpyDeviceToHost、cudaMemcpyDeviceToDevice 或 cudaMemcpyDefault 之一。建议传递 cudaMemcpyDefault，在这种情况下，传输类型将从指针值推断出来。但是，只有在支持统一虚拟寻址的系统上才允许使用 cudaMemcpyDefault。wOffsetDst + width不得超过 CUDA 数组的宽度dst. wOffsetSrc + width不得超过 CUDA 数组的宽度src.

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出同步行为。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemcpy, cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DFromArray, cudaMemcpyToSymbol, cudaMemcpyFromSymbol, cudaMemcpyAsync, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync, cuMemcpy2D, cuMemcpy2DUnaligned

在主机和设备之间复制数据。

参数

dst: - 目标内存地址
dpitch: - 目标内存的 pitch
src: - 源内存地址
spitch: - 源内存的 pitch
width: - 矩阵传输的宽度（以字节为单位的列数）
height: - 矩阵传输的高度（行数）
kind: - 传输类型
stream: - 流标识符

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection

描述

从height行，每行width字节的矩阵，从src字节到dst指向的内存区域，其中kind指定复制的方向，并且必须是 cudaMemcpyHostToHost、cudaMemcpyHostToDevice、cudaMemcpyDeviceToHost、cudaMemcpyDeviceToDevice 或 cudaMemcpyDefault 之一。建议传递 cudaMemcpyDefault，在这种情况下，传输类型将从指针值推断出来。但是，只有在支持统一虚拟寻址的系统上才允许使用 cudaMemcpyDefault。dpitch和spitch是以字节为单位的 2D 数组的内存宽度，由dst和src指向，包括添加到每行末尾的任何填充。内存区域可能不重叠。width不得超过dpitch或spitch.

使用dst和src指针方向与复制方向不匹配会导致未定义的行为。如果出现以下情况，cudaMemcpy2DAsync() 将返回错误：dpitch或spitch大于允许的最大值。

cudaMemcpy2DAsync() 相对于主机是异步的，因此调用可能在复制完成之前返回。可以通过传递非零值将复制操作与流关联：stream参数。如果kind是 cudaMemcpyHostToDevice 或 cudaMemcpyDeviceToHost 并且stream为非零值，则此复制操作可能与其他流中的操作重叠。

此函数的设备版本仅处理设备到设备的复制，并且不能使用本地或共享指针。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。
请求的内存区域必须完全注册到 CUDA，或者在主机可分页传输的情况下，完全不注册。不支持跨越同时注册和未注册到 CUDA 的分配的内存区域，并将返回 CUDA_ERROR_INVALID_VALUE。

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

cudaMemcpy, cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DFromArray, cudaMemcpy2DArrayToArray, cudaMemcpyToSymbol, cudaMemcpyFromSymbol, cudaMemcpyAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync, cuMemcpy2DAsync

在主机和设备之间复制数据。

参数

dst: - 目标内存地址
dpitch: - 目标内存的 pitch
src: - 源内存地址
wOffset: - 源起始 X 偏移量（以字节为单位的列数）
hOffset: - 源起始 Y 偏移量（行数）
width: - 矩阵传输的宽度（以字节为单位的列数）
height: - 矩阵传输的高度（行数）
kind: - 传输类型

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection

描述

从height行，每行width行，每行src字节，从 CUDA 数组hOffset行和wOffset从左上角到指针指向的内存区域的字节偏移量dst指向的内存区域，其中kind指定复制的方向，并且必须是 cudaMemcpyHostToHost、cudaMemcpyHostToDevice、cudaMemcpyDeviceToHost、cudaMemcpyDeviceToDevice 或 cudaMemcpyDefault 之一。建议传递 cudaMemcpyDefault，在这种情况下，传输类型将从指针值推断出来。但是，只有在支持统一虚拟寻址的系统上才允许使用 cudaMemcpyDefault。dpitch是指针指向的 2D 数组在内存中的宽度（以字节为单位）dst，包括添加到每行末尾的任何填充。wOffset + width不得超过 CUDA 数组的宽度src. width不得超过dpitch。如果出现以下情况，cudaMemcpy2DFromArray() 将返回错误：dpitch超过允许的最大值，cudaMemcpy2D() 将返回错误。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出同步行为。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。
请求的内存区域必须完全注册到 CUDA，或者在主机可分页传输的情况下，完全不注册。不支持跨越同时注册和未注册到 CUDA 的分配的内存区域，并将返回 CUDA_ERROR_INVALID_VALUE。

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

cudaMemcpy, cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DArrayToArray, cudaMemcpyToSymbol, cudaMemcpyFromSymbol, cudaMemcpyAsync, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync, cuMemcpy2D, cuMemcpy2DUnaligned

在主机和设备之间复制数据。

参数

dst: - 目标内存地址
dpitch: - 目标内存的 pitch
src: - 源内存地址
wOffset: - 源起始 X 偏移量（以字节为单位的列数）
hOffset: - 源起始 Y 偏移量（行数）
width: - 矩阵传输的宽度（以字节为单位的列数）
height: - 矩阵传输的高度（行数）
kind: - 传输类型
stream: - 流标识符

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection

描述

从height行，每行width行，每行src字节，从 CUDA 数组hOffset行和wOffset从左上角到指针指向的内存区域的字节偏移量dst指向的内存区域，其中kind指定复制的方向，并且必须是 cudaMemcpyHostToHost、cudaMemcpyHostToDevice、cudaMemcpyDeviceToHost、cudaMemcpyDeviceToDevice 或 cudaMemcpyDefault 之一。建议传递 cudaMemcpyDefault，在这种情况下，传输类型将从指针值推断出来。但是，只有在支持统一虚拟寻址的系统上才允许使用 cudaMemcpyDefault。dpitch是指针指向的 2D 数组在内存中的宽度（以字节为单位）dst，包括添加到每行末尾的任何填充。wOffset + width不得超过 CUDA 数组的宽度src. width不得超过dpitch。如果出现以下情况，cudaMemcpy2DFromArrayAsync() 将返回错误：dpitch超过允许的最大值，cudaMemcpy2D() 将返回错误。

cudaMemcpy2DFromArrayAsync() 相对于主机是异步的，因此调用可能在复制完成之前返回。可以通过传递非零值将复制操作与流关联：stream参数。如果kind是 cudaMemcpyHostToDevice 或 cudaMemcpyDeviceToHost 并且stream为非零值，则此复制操作可能与其他流中的操作重叠。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。
请求的内存区域必须完全注册到 CUDA，或者在主机可分页传输的情况下，完全不注册。不支持跨越同时注册和未注册到 CUDA 的分配的内存区域，并将返回 CUDA_ERROR_INVALID_VALUE。

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

cudaMemcpy, cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DFromArray, cudaMemcpy2DArrayToArray, cudaMemcpyToSymbol, cudaMemcpyFromSymbol, cudaMemcpyAsync, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync,

cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync, cuMemcpy2DAsync

在主机和设备之间复制数据。

参数

dst: - 目标内存地址
wOffset: - 目标起始 X 偏移量（以字节为单位的列数）
hOffset: - 目标起始 Y 偏移量（行数）
src: - 源内存地址
spitch: - 源内存的 pitch
width: - 矩阵传输的宽度（以字节为单位的列数）
height: - 矩阵传输的高度（行数）
kind: - 传输类型

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection

描述

从height行，每行width字节的矩阵，从src到 CUDA 数组dst字节，从 CUDA 数组hOffset行和wOffset字节（从左上角开始），其中kind指定复制的方向，并且必须是 cudaMemcpyHostToHost、cudaMemcpyHostToDevice、cudaMemcpyDeviceToHost、cudaMemcpyDeviceToDevice 或 cudaMemcpyDefault 之一。建议传递 cudaMemcpyDefault，在这种情况下，传输类型将从指针值推断出来。但是，只有在支持统一虚拟寻址的系统上才允许使用 cudaMemcpyDefault。spitch是指针指向的 2D 数组在内存中的宽度（以字节为单位）src，包括添加到每行末尾的任何填充。wOffset + width不得超过 CUDA 数组的宽度dst. width不得超过spitch。如果出现以下情况，cudaMemcpy2DToArray() 将返回错误：spitch超过允许的最大值，cudaMemcpy2D() 将返回错误。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出同步行为。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。
请求的内存区域必须完全注册到 CUDA，或者在主机可分页传输的情况下，完全不注册。不支持跨越同时注册和未注册到 CUDA 的分配的内存区域，并将返回 CUDA_ERROR_INVALID_VALUE。

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

cudaMemcpy, cudaMemcpy2D, cudaMemcpy2DFromArray, cudaMemcpy2DArrayToArray, cudaMemcpyToSymbol, cudaMemcpyFromSymbol, cudaMemcpyAsync, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync, cuMemcpy2D, cuMemcpy2DUnaligned

在主机和设备之间复制数据。

参数

dst: - 目标内存地址
wOffset: - 目标起始 X 偏移量（以字节为单位的列数）
hOffset: - 目标起始 Y 偏移量（行数）
src: - 源内存地址
spitch: - 源内存的 pitch
width: - 矩阵传输的宽度（以字节为单位的列数）
height: - 矩阵传输的高度（行数）
kind: - 传输类型
stream: - 流标识符

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection

描述

从height行，每行width字节的矩阵，从src到 CUDA 数组dst字节，从 CUDA 数组hOffset行和wOffset字节（从左上角开始），其中kind指定复制的方向，并且必须是 cudaMemcpyHostToHost、cudaMemcpyHostToDevice、cudaMemcpyDeviceToHost、cudaMemcpyDeviceToDevice 或 cudaMemcpyDefault 之一。建议传递 cudaMemcpyDefault，在这种情况下，传输类型将从指针值推断出来。但是，只有在支持统一虚拟寻址的系统上才允许使用 cudaMemcpyDefault。spitch是指针指向的 2D 数组在内存中的宽度（以字节为单位）src，包括添加到每行末尾的任何填充。wOffset + width不得超过 CUDA 数组的宽度dst. width不得超过spitch。如果出现以下情况，cudaMemcpy2DToArrayAsync() 将返回错误：spitch超过允许的最大值，cudaMemcpy2D() 将返回错误。

cudaMemcpy2DToArrayAsync() 相对于主机是异步的，因此调用可能在复制完成之前返回。可以通过传递非零值将复制操作与流关联：stream参数。如果kind是 cudaMemcpyHostToDevice 或 cudaMemcpyDeviceToHost 并且stream为非零值，则此复制操作可能与其他流中的操作重叠。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。
请求的内存区域必须完全注册到 CUDA，或者在主机可分页传输的情况下，完全不注册。不支持跨越同时注册和未注册到 CUDA 的分配的内存区域，并将返回 CUDA_ERROR_INVALID_VALUE。

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

cudaMemcpy, cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DFromArray, cudaMemcpy2DArrayToArray, cudaMemcpyToSymbol, cudaMemcpyFromSymbol, cudaMemcpyAsync, cudaMemcpy2DAsync,

cudaMemcpy2DFromArrayAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync, cuMemcpy2DAsync

在 3D 对象之间复制数据。

参数

p: - 3D 内存复制参数

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection

描述

‎struct cudaExtent {
        size_t width;
        size_t height;
        size_t depth;
      };
      struct cudaExtent 
                  make_cudaExtent(size_t w, size_t h, size_t d);
      
      struct cudaPos {
        size_t x;
        size_t y;
        size_t z;
      };
      struct cudaPos 
                  make_cudaPos(size_t x, size_t y, size_t z);
      
      struct cudaMemcpy3DParms {
        cudaArray_t           
                  srcArray;
        struct cudaPos        
                  srcPos;
        struct cudaPitchedPtr 
                  srcPtr;
        cudaArray_t           
                  dstArray;
        struct cudaPos        
                  dstPos;
        struct cudaPitchedPtr 
                  dstPtr;
        struct cudaExtent     
                  extent;
        enum cudaMemcpyKind   
                  kind;
      };

cudaMemcpy3D() 在两个 3D 对象之间复制数据。源对象和目标对象可以位于主机内存、设备内存或 CUDA 数组中。要执行的复制操作的源、目标、范围和类型由 cudaMemcpy3DParms 结构体指定，使用前应将其初始化为零。

‎cudaMemcpy3DParms myParms = {0};

传递给 cudaMemcpy3D() 的结构体必须指定以下源之一：srcArray或srcPtr和以下目标之一：dstArray或dstPtr。传递多个非零源或目标将导致 cudaMemcpy3D() 返回错误。

参数srcPos和dstPos字段是源对象和目标对象的可选偏移量，以每个对象的元素为单位定义。主机或设备指针的元素假定为 unsigned char 类型。

参数extent字段定义了以元素为单位的传输区域的维度。如果 CUDA 数组参与复制，则范围根据该数组的元素定义。如果没有 CUDA 数组参与复制，则范围以 unsigned char 的元素定义。

参数kind字段定义了复制方向。它必须是 cudaMemcpyHostToHost、cudaMemcpyHostToDevice、cudaMemcpyDeviceToHost、cudaMemcpyDeviceToDevice 或 cudaMemcpyDefault 之一。建议传递 cudaMemcpyDefault，在这种情况下，传输类型将从指针值推断。但是，cudaMemcpyDefault 仅在支持统一虚拟寻址的系统上允许使用。对于作为 kind 传递的 cudaMemcpyHostToHost、cudaMemcpyHostToDevice 或 cudaMemcpyDeviceToHost，以及作为源或目标传递的 cudaArray 类型，如果 kind 暗示 cudaArray 类型应存在于主机上，则 cudaMemcpy3D() 将忽略该暗示，并根据 cudaArray 类型只能存在于设备上的事实，以静默方式更正 kind。

如果源和目标都是数组，则当它们不具有相同的元素大小时，cudaMemcpy3D() 将返回错误。

源对象和目标对象可能不重叠。如果指定了重叠的源对象和目标对象，则会导致未定义的行为。

源对象必须完全包含由以下内容定义的区域：srcPos和extent。目标对象必须完全包含由以下内容定义的区域：dstPos和extent.

如果以下对象的 pitch 超出允许的最大值，cudaMemcpy3D() 将返回错误。srcPtr或dstPtr超出允许的最大值。使用 cudaMalloc3D() 分配的 cudaPitchedPtr 的 pitch 始终有效。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出同步行为。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMalloc3D, cudaMalloc3DArray, cudaMemset3D, cudaMemcpy3DAsync, cudaMemcpy, cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DFromArray, cudaMemcpy2DArrayToArray, cudaMemcpyToSymbol, cudaMemcpyFromSymbol, cudaMemcpyAsync, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync, make_cudaExtent, make_cudaPos, cuMemcpy3D

在 3D 对象之间复制数据。

参数

p: - 3D 内存复制参数
stream: - 流标识符

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection

描述

‎struct cudaExtent {
        size_t width;
        size_t height;
        size_t depth;
      };
      struct cudaExtent 
                  make_cudaExtent(size_t w, size_t h, size_t d);
      
      struct cudaPos {
        size_t x;
        size_t y;
        size_t z;
      };
      struct cudaPos 
                  make_cudaPos(size_t x, size_t y, size_t z);
      
      struct cudaMemcpy3DParms {
        cudaArray_t           
                  srcArray;
        struct cudaPos        
                  srcPos;
        struct cudaPitchedPtr 
                  srcPtr;
        cudaArray_t           
                  dstArray;
        struct cudaPos        
                  dstPos;
        struct cudaPitchedPtr 
                  dstPtr;
        struct cudaExtent     
                  extent;
        enum cudaMemcpyKind   
                  kind;
      };

cudaMemcpy3DAsync() 在两个 3D 对象之间复制数据。源对象和目标对象可以位于主机内存、设备内存或 CUDA 数组中。要执行的复制操作的源、目标、范围和类型由 cudaMemcpy3DParms 结构体指定，使用前应将其初始化为零。

‎cudaMemcpy3DParms myParms = {0};

传递给 cudaMemcpy3DAsync() 的结构体必须指定以下源之一：srcArray或srcPtr和以下目标之一：dstArray或dstPtr。传递多个非零源或目标将导致 cudaMemcpy3DAsync() 返回错误。

参数srcPos和dstPos字段是源对象和目标对象的可选偏移量，以每个对象的元素为单位定义。主机或设备指针的元素假定为 unsigned char 类型。对于 CUDA 数组，任何维度的位置都必须在 [0, 2048) 范围内。

参数extent字段定义了以元素为单位的传输区域的维度。如果 CUDA 数组参与复制，则范围根据该数组的元素定义。如果没有 CUDA 数组参与复制，则范围以 unsigned char 的元素定义。

参数kind字段定义了复制方向。它必须是 cudaMemcpyHostToHost、cudaMemcpyHostToDevice、cudaMemcpyDeviceToHost、cudaMemcpyDeviceToDevice 或 cudaMemcpyDefault 之一。建议传递 cudaMemcpyDefault，在这种情况下，传输类型将从指针值推断。但是，cudaMemcpyDefault 仅在支持统一虚拟寻址的系统上允许使用。对于作为 kind 传递的 cudaMemcpyHostToHost、cudaMemcpyHostToDevice 或 cudaMemcpyDeviceToHost，以及作为源或目标传递的 cudaArray 类型，如果 kind 暗示 cudaArray 类型应存在于主机上，则 cudaMemcpy3DAsync() 将忽略该暗示，并根据 cudaArray 类型只能存在于设备上的事实，以静默方式更正 kind。

如果源和目标都是数组，则当它们不具有相同的元素大小时，cudaMemcpy3DAsync() 将返回错误。

源对象和目标对象可能不重叠。如果指定了重叠的源对象和目标对象，则会导致未定义的行为。

源对象必须完全位于以下内容定义的区域内：srcPos和extent。目标对象必须完全位于以下内容定义的区域内：dstPos和extent.

如果以下对象的 pitch 超出允许的最大值，cudaMemcpy3DAsync() 将返回错误。srcPtr或dstPtr超出允许的最大值。使用 cudaMalloc3D() 分配的 cudaPitchedPtr 的 pitch 始终有效。

cudaMemcpy3DAsync() 相对于主机是异步的，因此调用可能在复制完成之前返回。可以通过传递非零值将复制操作与流关联：stream参数。如果kind是 cudaMemcpyHostToDevice 或 cudaMemcpyDeviceToHost 并且stream为非零值，则此复制操作可能与其他流中的操作重叠。

此函数的设备版本仅处理设备到设备的复制，并且不能使用本地或共享指针。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMalloc3D, cudaMalloc3DArray, cudaMemset3D, cudaMemcpy3D, cudaMemcpy, cudaMemcpy2D, cudaMemcpy2DToArray, :cudaMemcpy2DFromArray, cudaMemcpy2DArrayToArray, cudaMemcpyToSymbol, cudaMemcpyFromSymbol, cudaMemcpyAsync, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync, make_cudaExtent, make_cudaPos, cuMemcpy3DAsync

异步执行一批 3D 内存拷贝。

参数

numOps: - memcpy 操作的总数。
opList: - 大小为numOps的数组，包含实际的 memcpy 操作。
failIdx: - 指向某个位置的指针，用于返回遇到错误的拷贝的索引。如果错误不属于任何特定的拷贝，则该值将为 SIZE_MAX。
flags: - 供将来使用的标志，现在必须为零。
stream

返回值

device

描述

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

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

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

如果操作数的类型指定为 cudaMemcpyOperandTypeArray，则将使用 cudaMemcpy3DOperand::op::array。 cudaMemcpy3DOperand::op::array::array 字段指定 CUDA 数组，而 cudaMemcpy3DOperand::op::array::offset 指定拷贝开始的数组中的 3D 偏移量。

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

cudaMemcpyAttributes::flags 字段可用于为拷贝指定某些标志。设置 cudaMemcpyFlagPreferOverlapWithCompute 标志表示关联的拷贝应尽可能与任何计算工作重叠。请注意，此标志是一个提示，可能会被忽略，具体取决于平台和拷贝的其他参数。

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

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
请求的内存区域必须完全注册到 CUDA，或者在主机可分页传输的情况下，完全不注册。不支持跨越同时注册和未注册到 CUDA 的分配的内存区域，并将返回 CUDA_ERROR_INVALID_VALUE。

在设备之间拷贝内存。

参数

p: - 内存拷贝的参数

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevice, cudaErrorInvalidPitchValue

描述

根据p中指定的参数执行 3D 内存拷贝。有关其参数的文档，请参阅 cudaMemcpy3DPeerParms 结构的定义。

请注意，仅当传输的源或目标是主机内存时，此函数才相对于主机同步。另请注意，此拷贝相对于当前设备、拷贝的源设备和拷贝的目标设备中的所有挂起和将来的异步工作进行序列化（使用 cudaMemcpy3DPeerAsync 以避免此同步）。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出同步行为。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemcpy, cudaMemcpyPeer, cudaMemcpyAsync, cudaMemcpyPeerAsync, cudaMemcpy3DPeerAsync, cuMemcpy3DPeer

异步地在设备之间拷贝内存。

参数

p: - 内存拷贝的参数
stream: - 流标识符

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevice, cudaErrorInvalidPitchValue

描述

根据p中指定的参数执行 3D 内存拷贝。有关其参数的文档，请参阅 cudaMemcpy3DPeerParms 结构的定义。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemcpy, cudaMemcpyPeer, cudaMemcpyAsync, cudaMemcpyPeerAsync, cudaMemcpy3DPeerAsync, cuMemcpy3DPeerAsync

在主机和设备之间复制数据。

参数

dst: - 目标内存地址
src: - 源内存地址
count: - 要复制的字节大小
kind: - 传输类型
stream: - 流标识符

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidMemcpyDirection

描述

从count指向的内存区域复制src字节到dst指向的内存区域，其中kind指定复制的方向，并且必须是 cudaMemcpyHostToHost、cudaMemcpyHostToDevice、cudaMemcpyDeviceToHost、cudaMemcpyDeviceToDevice 或 cudaMemcpyDefault 之一。建议传递 cudaMemcpyDefault，在这种情况下，传输类型将从指针值推断出来。但是，只有在支持统一虚拟寻址的系统上才允许使用 cudaMemcpyDefault。

内存区域可能不会重叠。使用与拷贝方向不匹配的dst和src指针调用 cudaMemcpyAsync() 会导致未定义的行为。

cudaMemcpyAsync() 相对于主机是异步的，因此调用可能会在拷贝完成之前返回。拷贝可以选择通过传递非零的stream参数。如果kind与流关联。如果stream为非零值，则此复制操作可能与其他流中的操作重叠。

此函数的设备版本仅处理设备到设备的复制，并且不能使用本地或共享指针。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。
请求的内存区域必须完全注册到 CUDA，或者在主机可分页传输的情况下，完全不注册。不支持跨越同时注册和未注册到 CUDA 的分配的内存区域，并将返回 CUDA_ERROR_INVALID_VALUE。

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

cudaMemcpy, cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DFromArray, cudaMemcpy2DArrayToArray, cudaMemcpyToSymbol, cudaMemcpyFromSymbol, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync, cuMemcpyAsync, cuMemcpyDtoHAsync, cuMemcpyHtoDAsync, cuMemcpyDtoDAsync

异步执行一批内存拷贝。

参数

dsts: - 目标指针数组。
srcs: - memcpy 源指针数组。
sizes: - memcpy 操作的大小数组。
count: -dsts, srcs和sizes数组的大小。
attrs: - memcpy 属性数组。
attrsIdxs: - 索引数组，用于指定
数组中的每个条目应用于哪些拷贝。 attrs[k] 中指定的属性将应用于从 attrsIdxs[k] 到 attrsIdxs[k+1] - 1 的拷贝。此外，attrs[numAttrs-1] 将应用于从 attrsIdxs[numAttrs-1] 到 count - 1 的拷贝。attrsarray 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: -attrs和attrsIdxs数组。
failIdx: - 指向某个位置的指针，用于返回遇到错误的拷贝的索引。如果错误不属于任何特定的拷贝，则该值将为 SIZE_MAX。
stream

返回值

device

描述

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

执行从srcs中指定的源缓冲区到dsts中指定的目标缓冲区的内存拷贝。每个拷贝的大小在sizes中指定。所有这三个数组的长度必须相同，如count所指定。由于批处理中的拷贝没有排序保证，因此在批处理中指定任何依赖拷贝将导致未定义的行为。

批处理中的每个拷贝都必须与

数组中指定的一组属性相关联。此数组中的每个条目可以应用于多个拷贝。这可以通过在attrsarray. Each entry in this array can apply to more than one copy. This can be done by specifying in theattrsIdxs数组中指定

数组中对应条目适用的第一个拷贝的索引来完成。attrsarray applies to. Bothattrs和attrsIdxs和numAttrs的长度必须相同，如numAttrs所指定。例如，如果一个批处理在 dst/src/sizes 中列出了 10 个拷贝，其中前 6 个拷贝具有一组属性，而剩余 4 个拷贝具有另一组属性，则attrsIdxs将为 {0, 6}，并且attrs将包含两组属性。请注意，attrsIdxs中的第一个条目必须始终为 0。此外，每个条目必须大于前一个条目，并且最后一个条目应小于count。此外，numAttrs必须小于或等于count.

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

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

cudaMemcpyAttributes::flags 字段可用于为拷贝指定某些标志。设置 cudaMemcpyFlagPreferOverlapWithCompute 标志表示关联的拷贝应尽可能与任何计算工作重叠。请注意，此标志是一个提示，可能会被忽略，具体取决于平台和拷贝的其他参数。

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

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
请求的内存区域必须完全注册到 CUDA，或者在主机可分页传输的情况下，完全不注册。不支持跨越同时注册和未注册到 CUDA 的分配的内存区域，并将返回 CUDA_ERROR_INVALID_VALUE。

从设备上的给定符号拷贝数据。

参数

dst: - 目标内存地址
symbol: - 设备符号地址
count: - 要复制的字节大小
offset: - 从符号起始位置的字节偏移量
kind: - 传输类型

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidSymbol, cudaErrorInvalidMemcpyDirection, cudaErrorNoKernelImageForDevice

描述

从count指向的内存区域复制offset个字节。symbol字节到dst内存区域可能不会重叠。symbol是一个驻留在全局或常量内存空间中的变量。kind可以是 cudaMemcpyDeviceToHost、cudaMemcpyDeviceToDevice 或 cudaMemcpyDefault。建议传递 cudaMemcpyDefault，在这种情况下，传输类型是从指针值推断出来的。但是，只有在支持统一虚拟寻址的系统上才允许使用 cudaMemcpyDefault。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出同步行为。
在 CUDA 4.1 中，已弃用将命名变量的字符串用作symbol参数，并在 CUDA 5.0 中移除。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemcpy, cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DFromArray, cudaMemcpy2DArrayToArray, cudaMemcpyToSymbol, cudaMemcpyAsync, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync, cuMemcpy, cuMemcpyDtoH, cuMemcpyDtoD

从设备上的给定符号拷贝数据。

参数

dst: - 目标内存地址
symbol: - 设备符号地址
count: - 要复制的字节大小
offset: - 从符号起始位置的字节偏移量
kind: - 传输类型
stream: - 流标识符

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidSymbol, cudaErrorInvalidMemcpyDirection, cudaErrorNoKernelImageForDevice

描述

从count指向的内存区域复制offset个字节。symbol字节到dst内存区域可能不会重叠。symbol是一个驻留在全局或常量内存空间中的变量。kind可以是 cudaMemcpyDeviceToHost、cudaMemcpyDeviceToDevice 或 cudaMemcpyDefault。建议传递 cudaMemcpyDefault，在这种情况下，传输类型是从指针值推断出来的。但是，只有在支持统一虚拟寻址的系统上才允许使用 cudaMemcpyDefault。

cudaMemcpyFromSymbolAsync() 相对于主机是异步的，因此调用可能会在拷贝完成之前返回。拷贝可以选择通过传递非零的stream参数。如果kind与流关联。如果stream为非零值，则此复制操作可能与其他流中的操作重叠。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
在 CUDA 4.1 中，已弃用将命名变量的字符串用作symbol参数，并在 CUDA 5.0 中移除。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemcpy, cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DFromArray, cudaMemcpy2DArrayToArray, cudaMemcpyToSymbol, cudaMemcpyFromSymbol, cudaMemcpyAsync, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync, cudaMemcpyToSymbolAsync, cuMemcpyAsync, cuMemcpyDtoHAsync, cuMemcpyDtoDAsync

在两个设备之间拷贝内存。

参数

dst: - 目标设备指针
dstDevice: - 目标设备
src: - 源设备指针
srcDevice: - 源设备
count: - 内存拷贝的大小（以字节为单位）

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevice

描述

将内存从一个设备拷贝到另一个设备上的内存。dst是目标内存的基本设备指针，而dstDevice是目的设备。src是源内存的基本设备指针，并且srcDevice是源设备。count指定要复制的字节数。

请注意，此函数相对于主机是异步的，但相对于当前设备、srcDevice和dstDevice中的所有挂起和将来的异步工作进行序列化（使用 cudaMemcpyPeerAsync 以避免此同步）。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出同步行为。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemcpy, cudaMemcpyAsync, cudaMemcpyPeerAsync, cudaMemcpy3DPeerAsync, cuMemcpyPeer

异步地在两个设备之间拷贝内存。

参数

dst: - 目标设备指针
dstDevice: - 目标设备
src: - 源设备指针
srcDevice: - 源设备
count: - 内存拷贝的大小（以字节为单位）
stream: - 流标识符

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevice

描述

将内存从一个设备拷贝到另一个设备上的内存。dst是目标内存的基本设备指针，而dstDevice是目的设备。src是源内存的基本设备指针，并且srcDevice是源设备。count指定要复制的字节数。

请注意，此函数相对于主机和所有其他设备上的工作是异步的。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemcpy, cudaMemcpyPeer, cudaMemcpyAsync, cudaMemcpy3DPeerAsync, cuMemcpyPeerAsync

将数据复制到设备上给定的符号。

参数

symbol: - 设备符号地址
src: - 源内存地址
count: - 要复制的字节大小
offset: - 从符号起始位置的字节偏移量
kind: - 传输类型

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidSymbol, cudaErrorInvalidMemcpyDirection, cudaErrorNoKernelImageForDevice

描述

从count指向的内存区域复制src字节到offset个字节。symbol内存区域可能不会重叠。symbol是一个驻留在全局或常量内存空间中的变量。kind可以是 cudaMemcpyHostToDevice, cudaMemcpyDeviceToDevice, 或 cudaMemcpyDefault。推荐使用 cudaMemcpyDefault，在这种情况下，传输类型会从指针值中推断出来。然而，只有在支持统一虚拟寻址的系统上才允许使用 cudaMemcpyDefault。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出同步行为。
在 CUDA 4.1 中，已弃用将命名变量的字符串用作symbol参数，并在 CUDA 5.0 中移除。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemcpy, cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DFromArray, cudaMemcpy2DArrayToArray, cudaMemcpyFromSymbol, cudaMemcpyAsync, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync, cudaMemcpyToSymbolAsync, cudaMemcpyFromSymbolAsync, cuMemcpy, cuMemcpyHtoD, cuMemcpyDtoD

将数据复制到设备上给定的符号。

参数

symbol: - 设备符号地址
src: - 源内存地址
count: - 要复制的字节大小
offset: - 从符号起始位置的字节偏移量
kind: - 传输类型
stream: - 流标识符

返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidSymbol, cudaErrorInvalidMemcpyDirection, cudaErrorNoKernelImageForDevice

描述

从count指向的内存区域复制src字节到offset个字节。symbol内存区域可能不会重叠。symbol是一个驻留在全局或常量内存空间中的变量。kind可以是 cudaMemcpyHostToDevice, cudaMemcpyDeviceToDevice, 或 cudaMemcpyDefault。推荐使用 cudaMemcpyDefault，在这种情况下，传输类型会从指针值中推断出来。然而，只有在支持统一虚拟寻址的系统上才允许使用 cudaMemcpyDefault。

cudaMemcpyToSymbolAsync() 相对于主机是异步的，因此调用可能在复制完成之前返回。通过传递非零值，复制操作可以选择与流关联。stream参数。如果kind是 cudaMemcpyHostToDevice 和stream为非零值，则此复制操作可能与其他流中的操作重叠。

都可以指定为 NULL。

注意
对于大多数用例，此函数表现出异步行为。
此函数使用标准的默认流语义。
在 CUDA 4.1 中，已弃用将命名变量的字符串用作symbol参数，并在 CUDA 5.0 中移除。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemcpy, cudaMemcpy2D, cudaMemcpy2DToArray, cudaMemcpy2DFromArray, cudaMemcpy2DArrayToArray, cudaMemcpyToSymbol, cudaMemcpyFromSymbol, cudaMemcpyAsync, cudaMemcpy2DAsync, cudaMemcpy2DToArrayAsync, cudaMemcpy2DFromArrayAsync, cudaMemcpyFromSymbolAsync, cuMemcpyAsync, cuMemcpyHtoDAsync, cuMemcpyDtoDAsync

初始化或将设备内存设置为某个值。

参数

中返回稀疏 CUDA 数组的布局属性。: - 指向设备内存的指针
value: - 要为指定内存的每个字节设置的值
count: - 要设置的字节大小

返回值

cudaSuccess, cudaErrorInvalidValue,

描述

用常量字节值count填充由中返回稀疏 CUDA 数组的布局属性。指向的内存区域的前value.

个字节。请注意，除非中返回稀疏 CUDA 数组的布局属性。指向pinned host memory，否则此函数相对于主机是异步的。

都可以指定为 NULL。

注意
另请参阅 memset 同步细节。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cuMemsetD8, cuMemsetD16, cuMemsetD32

初始化或将设备内存设置为某个值。

参数

中返回稀疏 CUDA 数组的布局属性。: - 指向 2D 设备内存的指针
pitch: - 2D 设备内存的 pitch（字节）（如果height为 1，则未使用）
value: - 要为指定内存的每个字节设置的值
width: - 设置的矩阵宽度（列，以字节为单位）
height: - 设置的矩阵高度（行）

返回值

cudaSuccess, cudaErrorInvalidValue,

描述

将value矩阵（每个元素height行，每行width字节）设置为指定值，该矩阵由dstPtr. pitch指向，是由dstPtr指向的 2D 数组的宽度（以字节为单位），包括添加到每行末尾的任何填充。当 pitch 是由 cudaMallocPitch() 返回的 pitch 时，此函数执行速度最快。

个字节。请注意，除非中返回稀疏 CUDA 数组的布局属性。指向pinned host memory，否则此函数相对于主机是异步的。

都可以指定为 NULL。

注意
另请参阅 memset 同步细节。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemset, cudaMemset3D, cudaMemsetAsync, cudaMemset2DAsync, cudaMemset3DAsync, cuMemsetD2D8, cuMemsetD2D16, cuMemsetD2D32

初始化或将设备内存设置为某个值。

参数

中返回稀疏 CUDA 数组的布局属性。: - 指向 2D 设备内存的指针
pitch: - 2D 设备内存的 pitch（字节）（如果height为 1，则未使用）
value: - 要为指定内存的每个字节设置的值
width: - 设置的矩阵宽度（列，以字节为单位）
height: - 设置的矩阵高度（行）
stream: - 流标识符

返回值

cudaSuccess, cudaErrorInvalidValue,

描述

将value矩阵（每个元素height行，每行width字节）设置为指定值，该矩阵由dstPtr. pitch指向，是由dstPtr指向的 2D 数组的宽度（以字节为单位），包括添加到每行末尾的任何填充。当 pitch 是由 cudaMallocPitch() 返回的 pitch 时，此函数执行速度最快。

cudaMemset2DAsync() 相对于主机是异步的，因此调用可能在 memset 操作完成之前返回。通过传递非零值，操作可以选择与流关联。stream参数。如果stream为非零值时，操作可能与其他流中的操作重叠。

此函数的设备版本仅处理设备到设备的复制，并且不能使用本地或共享指针。

都可以指定为 NULL。

注意
另请参阅 memset 同步细节。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemset, cudaMemset2D, cudaMemset3D, cudaMemsetAsync, cudaMemset3DAsync, cuMemsetD2D8Async, cuMemsetD2D16Async, cuMemsetD2D32Async

初始化或将设备内存设置为某个值。

参数

pitchedDevPtr: - 指向 pitched 设备内存的指针
value: - 要为指定内存的每个字节设置的值
extent: - 用于设置设备内存大小的参数 (width字段，以字节为单位）

返回值

cudaSuccess, cudaErrorInvalidValue,

描述

将 3D 数组的每个元素初始化为指定值value。要初始化的对象由pitchedDevPtr定义。pitch的字段中返回的跨距pitchedDevPtr是由pitchedDevPtr指向的 3D 数组的内存宽度（以字节为单位），包括添加到每行末尾的任何填充。xsize字段指定每行的逻辑宽度（以字节为单位），而ysize字段指定每个 2D 切片的高度（以行数为单位）。当pitch的字段中返回的跨距pitchedDevPtr被忽略，如果height和depth都等于 1。

要初始化的区域的范围指定为width（以字节为单位）、height（以行数为单位）和depth（以切片数为单位）。

范围的width大于或等于xsize的pitchedDevPtr可能比范围窄于xsize的范围执行速度显著更快。其次，当height等于ysize的pitchedDevPtr时，将比height短于ysize.

时执行速度更快。当pitchedDevPtr已由 cudaMalloc3D() 分配时，此函数执行速度最快。

个字节。请注意，除非pitchedDevPtr指向pinned host memory，否则此函数相对于主机是异步的。

都可以指定为 NULL。

注意
另请参阅 memset 同步细节。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemset, cudaMemset2D, cudaMemsetAsync, cudaMemset2DAsync, cudaMemset3DAsync, cudaMalloc3D, make_cudaPitchedPtr, make_cudaExtent

初始化或将设备内存设置为某个值。

参数

pitchedDevPtr: - 指向 pitched 设备内存的指针
value: - 要为指定内存的每个字节设置的值
extent: - 用于设置设备内存大小的参数 (width字段，以字节为单位）
stream: - 流标识符

返回值

cudaSuccess, cudaErrorInvalidValue,

描述

将 3D 数组的每个元素初始化为指定值value。要初始化的对象由pitchedDevPtr定义。pitch的字段中返回的跨距pitchedDevPtr是由pitchedDevPtr指向的 3D 数组的内存宽度（以字节为单位），包括添加到每行末尾的任何填充。xsize字段指定每行的逻辑宽度（以字节为单位），而ysize字段指定每个 2D 切片的高度（以行数为单位）。当pitch的字段中返回的跨距pitchedDevPtr被忽略，如果height和depth都等于 1。

要初始化的区域的范围指定为width（以字节为单位）、height（以行数为单位）和depth（以切片数为单位）。

范围的width大于或等于xsize的pitchedDevPtr可能比范围窄于xsize的范围执行速度显著更快。其次，当height等于ysize的pitchedDevPtr时，将比height短于ysize.

时执行速度更快。当pitchedDevPtr已由 cudaMalloc3D() 分配时，此函数执行速度最快。

cudaMemset3DAsync() 相对于主机是异步的，因此调用可能在 memset 操作完成之前返回。通过传递非零值，操作可以选择与流关联。stream参数。如果stream为非零值时，操作可能与其他流中的操作重叠。

此函数的设备版本仅处理设备到设备的复制，并且不能使用本地或共享指针。

都可以指定为 NULL。

注意
另请参阅 memset 同步细节。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemset, cudaMemset2D, cudaMemset3D, cudaMemsetAsync, cudaMemset2DAsync, cudaMalloc3D, make_cudaPitchedPtr, make_cudaExtent

初始化或将设备内存设置为某个值。

参数

中返回稀疏 CUDA 数组的布局属性。: - 指向设备内存的指针
value: - 要为指定内存的每个字节设置的值
count: - 要设置的字节大小
stream: - 流标识符

返回值

cudaSuccess, cudaErrorInvalidValue,

描述

用常量字节值count填充由中返回稀疏 CUDA 数组的布局属性。指向的内存区域的前value.

cudaMemsetAsync() 相对于主机是异步的，因此调用可能在 memset 操作完成之前返回。通过传递非零值，操作可以选择与流关联。stream参数。如果stream为非零值时，操作可能与其他流中的操作重叠。

此函数的设备版本仅处理设备到设备的复制，并且不能使用本地或共享指针。

都可以指定为 NULL。

注意
另请参阅 memset 同步细节。
此函数使用标准的默认流语义。
请注意，此函数也可能返回来自先前异步启动的错误代码。
请注意，如果此调用尝试初始化内部 CUDA RT 状态，此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

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

cudaMemset, cudaMemset2D, cudaMemset3D, cudaMemset2DAsync, cudaMemset3DAsync, cuMemsetD8Async, cuMemsetD16Async, cuMemsetD32Async

返回 CUDA mipmapped array 的内存需求。

参数

返回 CUDA 数组的内存需求。: memoryRequirements
mipmap: - 要获取内存需求的 CUDA mipmapped array
array: - 要获取内存需求的 CUDA 数组

返回值

device

描述

在返回 CUDA 数组的内存需求。中返回 CUDA mipmapped array 的内存需求。如果 CUDA mipmapped array 未使用标志 cudaArrayDeferredMapping 分配，将返回 cudaErrorInvalidValue。

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

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

cudaArrayGetMemoryRequirements

返回 sparse CUDA mipmapped array 的布局属性。

参数

传入 1，则返回的 CUDA 数组的高度和宽度为: - 指向返回 cudaArraySparseProperties 的指针
mipmap: - 要获取 sparse 属性的 CUDA mipmapped array

返回值

device

描述

在传入 1，则返回的 CUDA 数组的高度和宽度为中返回 sparse array 布局属性。如果 CUDA mipmapped array 未使用标志 cudaArraySparse 分配，将返回 cudaErrorInvalidValue。

对于非 layered CUDA mipmapped array，cudaArraySparseProperties::miptailSize 返回 mip tail 区域的大小。 mip tail 区域包括所有 mip 级别，其宽度、高度或深度小于 tile 的宽度、高度或深度。对于 layered CUDA mipmapped array，如果 cudaArraySparseProperties::flags 包含 cudaArraySparsePropertiesSingleMipTail，则 cudaArraySparseProperties::miptailSize 指定所有 layer 组合的 mip tail 的大小。否则，cudaArraySparseProperties::miptailSize 指定每个 layer 的 mip tail 大小。仅当 cudaArraySparseProperties::miptailSize 为非零值时，cudaArraySparseProperties::miptailFirstLevel 的返回值才有效。

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

cudaArrayGetSparseProperties, cuMemMapArrayAsync

基于输入参数返回 cudaExtent。

参数

w: - 指的是数组内存时，为元素的宽度；指的是线性内存时，为字节宽度
h: - 元素的高度
d: - 元素的深度

返回值

由w, h和d

描述

指定的 cudaExtent 基于指定的输入参数返回 cudaExtentw, h和d.

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

make_cudaPitchedPtr, make_cudaPos

基于输入参数返回 cudaPitchedPtr。

参数

d: - 指向已分配内存的指针
p: - 已分配内存的 pitch（以字节为单位）
xsz: - 分配的逻辑宽度（以元素为单位）
ysz: - 分配的逻辑高度（以元素为单位）

返回值

由d, p, xsz和ysz

描述

指定的 cudaPitchedPtr 基于指定的输入参数返回 cudaPitchedPtrd, p, xsz和ysz.

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

make_cudaExtent, make_cudaPos

基于输入参数返回 cudaPos。

参数

x: - X 位置
y: - Y 位置
z: - Z 位置

返回值

由x, y和z

描述

指定的 cudaPos 基于指定的输入参数返回 cudaPosx, y和z.

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

make_cudaExtent, make_cudaPitchedPtr

6.11. 内存管理

函数

函数

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值

描述

参数

返回值