cuBLASMp C API

库管理

cublasMpCreate

cublasMpStatus_t cublasMpCreate(
        cublasMpHandle_t *handle,
        cudaStream_t stream);

此函数初始化 cuBLASMp 库句柄 (cublasMpHandle_t)，该句柄保存 cuBLASMp 库上下文。它在主机上分配少量硬件资源，并且必须在进行任何其他 cuBLASMp 库调用之前调用。

调用任何使用 cublasMpHandle_t 的 cuBLASMp 函数，而之前未调用 cublasMpCreate() 将返回错误。

cuBLASMp 库上下文与当前 CUDA 设备和给定的 CUDA 流绑定。

与多个进程共享设备可能会导致未定义的行为。

参数	内存	输入/输出	描述
handle	主机	输出	cuBLASMp 库句柄。
stream	主机	输入	将分配给句柄的流。

有关返回状态的描述，请参阅 cublasMpStatus_t。

cublasMpDestroy

cublasMpStatus_t cublasMpDestroy(
        cublasMpHandle_t handle);

此函数销毁 cuBLASMp 库句柄 (cublasMpHandle_t)，该句柄保存 cuBLASMp 库上下文。

cuBLASMp 库上下文与调用 cublasMpCreate() 时设置的 CUDA 设备绑定。每个进程和每个 GPU 仅支持一个句柄。

参数	内存	输入/输出	描述
handle	主机	输入/输出	cuBLASMp 库句柄，用于销毁。

有关返回状态的描述，请参阅 cublasMpStatus_t。

cublasMpStreamSet

cublasMpStatus_t cublasMpStreamSet(
        cublasMpHandle_t handle,
        cudaStream_t stream);

此函数设置将在计算中使用的 CUDA 流。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
stream	主机	输入	要设置的 CUDA 流指针。

有关返回状态的描述，请参阅 cublasMpStatus_t。

cublasMpStreamGet

cublasMpStatus_t cublasMpStreamGet(
        cublasMpHandle_t handle,
        cudaStream_t* stream);

此函数返回当前在计算中使用的 CUDA 流。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
stream	主机	输出	要设置的 CUDA 流指针。

有关返回状态的描述，请参阅 cublasMpStatus_t。

cublasMpGetVersion

cublasMpStatus_t cublasMpGetVersion(
        int *version);

此函数返回 cuBLASMp 库的版本号。

参数	内存	输入/输出	描述
version	主机	输出	cuBLASMp 库版本。值为 CUBLASMP_VER_MAJOR * 1000 + CUBLASMP_VER_MINOR * 100 + CUBLASMP_VER_PATCH。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

网格管理

cublasMpGridCreate

cublasMpStatus_t cublasMpGridCreate(
        int64_t nprow,
        int64_t npcol,
        cublasMpGridLayout_t layout,
        cal_comm_t comm,
        cublasMpGrid_t* grid);

此函数初始化 grid 不透明数据结构。它将给定的资源（通信器、网格维度和 grid layout）映射到网格对象。

所有定义在此网格中的进程都必须进入此函数。

如果 NVSHMEM 未由用户初始化，cuBLASMp 将在创建第一个网格时初始化它。如果 NVSHMEM 已经初始化，则不会重新初始化。如果 cuBLASMp 初始化了 NVSHMEM，则它只会调用 nvshmem_finalize。

参数	内存	输入/输出	描述
nprow	主机	输入	网格包含多少行进程。
npcol	主机	输入	网格包含多少列进程。
layout	主机	输入	网格布局 (cublasMpGridLayout_t)。
comm	主机	输入	与网格关联的通信器。
grid	主机	输入/输出	指向网格对象的指针。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpGridDestroy

cublasMpStatus_t cublasMpGridDestroy(
        cublasMpGrid_t grid);

此函数销毁给定的 grid 对象。

所有定义在此网格中的进程都必须进入此函数。

参数	内存	输入/输出	描述
grid	主机	输入/输出	要销毁的网格对象。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

矩阵管理

cublasMpMatrixDescriptorCreate

cublasMpStatus_t cublasMpMatrixDescriptorCreate(
        int64_t m,
        int64_t n,
        int64_t mb,
        int64_t nb,
        int64_t rsrc,
        int64_t csrc,
        int64_t lld,
        cudaDataType_t type,
        cublasMpGrid_t grid,
        cublasMpMatrixDescriptor_t* desc);

此函数初始化 cublasMpMatrixDescriptor_t 对象。

参数	内存	输入/输出	描述
m	主机	输入	全局矩阵中的行数。
n	主机	输入	全局矩阵中的列数。
mb	主机	输入	用于分布全局矩阵行的分块因子。
nb	主机	输入	用于分布全局矩阵列的分块因子。
rsrc	主机	输入	拥有全局矩阵第一个行块的进程的行秩。
csrc	主机	输入	拥有全局矩阵第一个列块的进程的列秩。
lld	主机	输入	局部矩阵的 leading dimension。
type	主机	输入	矩阵的数据类型。
grid	主机	输入	与矩阵描述符关联的网格对象。
desc	主机	输出	由此函数初始化的矩阵描述符对象。

列出了 type 参数的受支持值。

数据类型	描述
CUDA_R_8I	8 位实数有符号整数。
CUDA_R_32I	32 位实数有符号整数。
CUDA_R_8F_E4M3	E4M3 格式的 8 位实数浮点数。
CUDA_R_8F_E5M2	E5M2 格式的 8 位实数浮点数。
CUDA_R_16F	16 位实数半精度浮点数。
CUDA_R_16BF	16 位实数 bfloat16 浮点数。
CUDA_R_32F	32 位实数单精度浮点数。
CUDA_R_64F	64 位实数双精度浮点数。
CUDA_C_32F	64 位结构，由两个单精度浮点数组成，表示复数。
CUDA_C_64F	128 位结构，由两个双精度浮点数组成，表示复数。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpMatrixDescriptorDestroy

cublasMpStatus_t cublasMpMatrixDescriptorDestroy(
        cublasMpMatrixDescriptor_t desc);

此函数销毁 cublasMpMatrixDescriptor_t 对象。

参数	内存	输入/输出	描述
desc	主机	输入/输出	要销毁的矩阵描述符对象。

有关返回状态的描述，请参阅 cublasMpStatus_t。

cublasMpMatrixDescriptorInit

cublasMpStatus_t cublasMpMatrixDescriptorInit(
        int64_t m,
        int64_t n,
        int64_t mb,
        int64_t nb,
        int64_t rsrc,
        int64_t csrc,
        int64_t lld,
        cudaDataType_t type,
        cublasMpGrid_t grid,
        cublasMpMatrixDescriptor_t desc);

此函数初始化 cublasMpMatrixDescriptor_t 对象的值。此函数不分配额外的内存。

参数	内存	输入/输出	描述
m	主机	输入	全局矩阵中的行数。
n	主机	输入	全局矩阵中的列数。
mb	主机	输入	用于分布全局矩阵行的分块因子。
nb	主机	输入	用于分布全局矩阵列的分块因子。
rsrc	主机	输入	拥有全局矩阵第一个行块的进程的行秩。
csrc	主机	输入	拥有全局矩阵第一个列块的进程的列秩。
lld	主机	输入	局部矩阵的 leading dimension。
type	主机	输入	矩阵的数据类型。
grid	主机	输入	与矩阵描述符关联的网格对象。
desc	主机	输出	由此函数初始化的矩阵描述符对象。

下面列出了 type 参数的受支持值

数据类型	描述
CUDA_R_8I	8 位实数有符号整数。
CUDA_R_32I	32 位实数有符号整数。
CUDA_R_8F_E4M3	E4M3 格式的 8 位实数浮点数。
CUDA_R_8F_E5M2	E5M2 格式的 8 位实数浮点数。
CUDA_R_16F	16 位实数半精度浮点数。
CUDA_R_16BF	16 位实数 bfloat16 浮点数。
CUDA_R_32F	32 位实数单精度浮点数。
CUDA_R_64F	64 位实数双精度浮点数。
CUDA_C_32F	64 位结构，由两个单精度浮点数组成，表示复数。
CUDA_C_64F	128 位结构，由两个双精度浮点数组成，表示复数。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

Matmul 属性

cublasMpMatmulDescriptorCreate

cublasMpStatus_t cublasMpMatmulDescriptorCreate(
        cublasMpMatmulDescriptor_t* matmulDesc,
        cublasComputeType_t computeType);

此函数初始化 cublasMpMatmulDescriptor_t 对象的值，该对象用于 cublasMpMatmul() 中。

参数	内存	输入/输出	描述
matmulDesc	主机	输入/输出	指向要初始化的 cublasMpMatmulDescriptor 对象的指针。
computeType	主机	输入	cuBLAS 计算类型，用于计算。请参阅下表了解支持的组合。

列出了 computeType 参数的受支持值。

计算类型
CUBLAS_COMPUTE_32I
CUBLAS_COMPUTE_32I_PEDANTIC
CUBLAS_COMPUTE_16F
CUBLAS_COMPUTE_16F_PEDANTIC
CUBLAS_COMPUTE_32F
CUBLAS_COMPUTE_32F_PEDANTIC
CUBLAS_COMPUTE_32F_FAST_16F
CUBLAS_COMPUTE_32F_FAST_16BF
CUBLAS_COMPUTE_32F_FAST_TF32
CUBLAS_COMPUTE_64F
CUBLAS_COMPUTE_64F_PEDANTIC

有关返回状态的描述，请参阅 cublasMpStatus_t。

cublasMpMatmulDescriptorDestroy

cublasMpStatus_t cublasMpMatmulDescriptorDestroy(
        cublasMpMatmulDescriptor_t matmulDesc);

此函数销毁 cublasMpMatmulDescriptor_t 对象，该对象用于 cublasMpMatmul() 中。

参数	内存	输入/输出	描述
matmulDesc	主机	输入/输出	要销毁的 Matmul 描述符对象。

有关返回状态的描述，请参阅 cublasMpStatus_t。

cublasMpMatmulDescriptorAttributeSet

cublasMpStatus_t cublasMpMatmulDescriptorAttributeSet(
        cublasMpMatmulDescriptor_t matmulDesc,
        cublasMpMatmulDescriptorAttribute_t attr,
        const void* buf,
        size_t sizeInBytes);

此函数设置 cublasMpMatmulDescriptor_t 对象的属性，该对象用于 cublasMpMatmul() 中。这些属性的类型为 cublasMpMatmulDescriptorAttribute_t。

参数	内存	输入/输出	描述
matmulDesc	主机	输入	要设置其属性的 Matmul 描述符对象。
attr	主机	输入	要设置的 Matmul 描述符属性。
buf	主机	输入	要设置的属性值。
sizeInBytes	主机	输入	属性缓冲区大小（以字节为单位）。

有关返回状态的描述，请参阅 cublasMpStatus_t。

cublasMpMatmulDescriptorAttributeGet

cublasMpStatus_t cublasMpMatmulDescriptorAttributeGet(
        cublasMpMatmulDescriptor_t matmulDesc,
        cublasMpMatmulDescriptorAttribute_t attr,
        const void* buf,
        size_t sizeInBytes,
        size_t* sizeWritten);

此函数返回 cublasMpMatmulDescriptor_t 对象的属性，该对象用于 cublasMpMatmul() 中。

参数	内存	输入/输出	描述
matmulDesc	主机	输入	要设置其属性的 Matmul 描述符对象。
attr	主机	输入	要设置的 Matmul 描述符属性。
buf	主机	输出	要设置的属性值。
sizeInBytes	主机	输入	属性缓冲区大小（以字节为单位）。
sizeWritten	主机	输出	写入 buf 的属性大小（以字节为单位）。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

实用程序

cublasMpNumroc

int64_t cublasMpNumroc(
        int64_t n,
        int64_t nb,
        uint32_t iproc,
        uint32_t isrcproc,
        uint32_t nprocs);

计算由 iproc 参数指示的进程拥有的分布式矩阵的行数或列数。

参数	内存	输入/输出	描述
n	主机	输入	全局分布式矩阵中的行数或列数。
nb	主机	输入	全局矩阵的行或列分块大小。
iproc	主机	输入	要确定其局部数组行或列的进程的坐标。
isrcproc	主机	输入	拥有分布式矩阵第一行或第一列的进程的坐标。
nprocs	主机	输入	矩阵分布在其上的行或列进程的总数。

---

cublasMpGemr2D

cublasMpStatus_t cublasMpGemr2D(
        cublasMpHandle_t handle,
        int64_t m,
        int64_t n,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        void* b,
        int64_t ib,
        int64_t jb,
        cublasMpMatrixDescriptor_t descB,
        void* d_work,
        size_t workspaceSizeInBytesOnDevice,
        void* h_work,
        size_t workspaceSizeInBytesOnHost,
        cal_comm_t global_comm);

此函数根据矩阵 B 的分布属性重新分布通用矩形矩阵 A。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
m	主机	输入	sub(A) 和 sub(B) 的行数。
n	主机	输入	sub(A) 和 sub(B) 的列数。
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。
ja	主机	输入	sub(A) 第一列的列索引。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。在不属于 A 网格的进程中，descA 的网格值必须设置为 null。
b	设备	输出	指向全局矩阵 B 的局部部分的第一个条目的指针。
ib	主机	输入	sub(B) 第一行的行索引。
jb	主机	输入	sub(B) 第一列的列索引。
descB	主机	输入	与全局矩阵 B 关联的矩阵描述符。在不属于 B 网格的进程中，descB 的网格值必须设置为 null。
d_work	设备	输出	大小为 workspaceInBytesOnDevice 的设备工作区。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作区的大小（以字节为单位），由 cublasMpGemr2D_bufferSize() 提供。
h_work	主机	输出	大小为 workspaceInBytesOnHost 的主机工作区。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作区的大小（以字节为单位），由 cublasMpGemr2D_bufferSize() 提供。
global_comm	主机	输入	一个通信器，至少包含 A 和 B 通信器中所有进程的并集。通信器中的所有进程都必须调用此函数，即使它们不拥有任何矩阵的一部分。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpGemr2D_bufferSize

cublasMpStatus_t cublasMpGemr2D_bufferSize(
        cublasMpHandle_t handle,
        int64_t m,
        int64_t n,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        void* b,
        int64_t ib,
        int64_t jb,
        cublasMpMatrixDescriptor_t descB,
        size_t* workspaceSizeInBytesOnDevice,
        size_t* workspaceSizeInBytesOnHost,
        cal_comm_t global_comm);

此函数返回在给定输入上执行 cublasMpGemr2D() 所需的缓冲区大小。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
m	主机	输入	sub(A) 和 sub(B) 的行数。
n	主机	输入	sub(A) 和 sub(B) 的列数。
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。
ja	主机	输入	sub(A) 第一列的列索引。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。在不属于 A 网格的进程中，descA 的网格值必须设置为 null。
b	设备	输入	指向全局矩阵 B 的局部部分的第一个条目的指针。
ib	主机	输入	sub(B) 第一行的行索引。
jb	主机	输入	sub(B) 第一列的列索引。
descB	主机	输入	与全局矩阵 B 关联的矩阵描述符。在不属于 B 网格的进程中，descB 的网格值必须设置为 null。
workspaceInBytesOnDevice	主机	输出	在输出时，包含 cublasMpGemr2D() 所需的本地设备工作区的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	在输出时，包含 cublasMpGemr2D() 所需的本地主机工作区的大小（以字节为单位）。
global_comm	主机	输入	一个通信器，至少包含 A 和 B 通信器中所有进程的并集。通信器中的所有进程都必须调用此函数，即使它们不拥有任何矩阵的一部分。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpTrmr2D

cublasMpStatus_t cublasMpTrmr2D(
        cublasMpHandle_t handle,
        cublasFillMode_t uplo,
        cublasDiagType_t diag,
        int64_t m,
        int64_t n,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        void* b,
        int64_t ib,
        int64_t jb,
        cublasMpMatrixDescriptor_t descB,
        void* d_work,
        size_t workspaceSizeInBytesOnDevice,
        void* h_work,
        size_t workspaceSizeInBytesOnHost,
        cal_comm_t global_comm);

此函数根据梯形矩阵 B 的分布属性重新分布梯形矩阵 A。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
uplo	主机	输入	指示是否存储了矩阵 A 的下部或上部，另一部分未被引用，而是从存储的元素中推断出来的。
diag	主机	输入	指示矩阵 A 主对角线上的元素是否为单位值，并且不应被访问。
m	主机	输入	sub(A) 和 sub(B) 的行数。
n	主机	输入	sub(A) 和 sub(B) 的列数。
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。
ja	主机	输入	sub(A) 第一列的列索引。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。在不属于 A 网格的进程中，descA 的网格值必须设置为 null。
b	设备	输出	指向全局矩阵 B 的局部部分的第一个条目的指针。
ib	主机	输入	sub(B) 第一行的行索引。
jb	主机	输入	sub(B) 第一列的列索引。
descB	主机	输入	与全局矩阵 B 关联的矩阵描述符。在不属于 B 网格的进程中，descB 的网格值必须设置为 null。
d_work	设备	输出	大小为 workspaceInBytesOnDevice 的设备工作区。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作区的大小（以字节为单位），由 cublasMpTrmr2D_bufferSize() 提供。
h_work	主机	输出	大小为 workspaceInBytesOnHost 的主机工作区。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作区的大小（以字节为单位），由 cublasMpTrmr2D_bufferSize() 提供。
global_comm	主机	输入	一个通信器，至少包含 A 和 B 通信器中所有进程的并集。通信器中的所有进程都必须调用此函数，即使它们不拥有任何矩阵的一部分。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpTrmr2D_bufferSize

cublasMpStatus_t cublasMpTrmr2D_bufferSize(
        cublasMpHandle_t handle,
        cublasFillMode_t uplo,
        cublasDiagType_t diag,
        int64_t m,
        int64_t n,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        void* b,
        int64_t ib,
        int64_t jb,
        cublasMpMatrixDescriptor_t descB,
        size_t* workspaceSizeInBytesOnDevice,
        size_t* workspaceSizeInBytesOnHost,
        cal_comm_t global_comm);

此函数返回在给定输入上执行 cublasMpTrmr2D() 所需的缓冲区大小。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
uplo	主机	输入	指示是否存储了矩阵 A 的下部或上部，另一部分未被引用，而是从存储的元素中推断出来的。
diag	主机	输入	指示矩阵 A 主对角线上的元素是否为单位值，并且不应被访问。
m	主机	输入	sub(A) 和 sub(B) 的行数。
n	主机	输入	sub(A) 和 sub(B) 的列数。
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。
ja	主机	输入	sub(A) 第一列的列索引。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。在不属于 A 网格的进程中，descA 的网格值必须设置为 null。
b	设备	输入	指向全局矩阵 B 的局部部分的第一个条目的指针。
ib	主机	输入	sub(B) 第一行的行索引。
jb	主机	输入	sub(B) 第一列的列索引。
descB	主机	输入	与全局矩阵 B 关联的矩阵描述符。在不属于 B 网格的进程中，descB 的网格值必须设置为 null。
workspaceInBytesOnDevice	主机	输出	在输出时，包含 cublasMpTrmr2D() 所需的本地设备工作区的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	在输出时，包含 cublasMpTrmr2D() 所需的本地主机工作区的大小（以字节为单位）。
global_comm	主机	输入	一个通信器，至少包含 A 和 B 通信器中所有进程的并集。通信器中的所有进程都必须调用此函数，即使它们不拥有任何矩阵的一部分。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

日志记录

cublasMpLoggerSetCallback

cublasMpStatus_t cublasMpLoggerSetCallback(
        cublasMpLoggerCallback_t callback);

此函数设置日志记录回调函数。

参数	内存	输入/输出	描述
callback	主机	输入	指向回调函数的指针。请参阅 cublasMpLoggerCallback_t。

有关返回状态的描述，请参阅 cublasMpStatus_t。

警告

这是一个实验性功能。

---

cublasMpLoggerSetFile

cublasMpStatus_t cublasMpLoggerSetFile(
        FILE *file);

此函数设置日志记录输出文件。注意：一旦使用此函数调用注册，提供的文件句柄不得关闭，除非再次调用该函数以切换到不同的文件句柄。

参数	内存	输入/输出	描述
file	主机	输入	指向打开文件的指针。文件应具有写入权限。

有关返回状态的描述，请参阅 cublasMpStatus_t。

警告

这是一个实验性功能。

---

cublasMpLoggerOpenFile

cublasMpStatus_t cublasMpLoggerOpenFile(
        const char* logFile);

此函数在给定路径中打开日志记录输出文件。

参数	内存	输入/输出	描述
logFile	主机	输入	日志记录输出文件的路径。

有关返回状态的描述，请参阅 cublasMpStatus_t。

警告

这是一个实验性功能。

---

cublasMpLoggerSetLevel

cublasMpStatus_t cublasMpLoggerSetLevel(
        int level);

此函数设置日志记录级别。

参数	内存	输入/输出	描述
level	主机	输入	日志记录级别的数值。请参阅 cuBLASMp 日志记录。

有关返回状态的描述，请参阅 cublasMpStatus_t。

警告

这是一个实验性功能。

---

cublasMpLoggerSetMask

cublasMpStatus_t cublasMpLoggerSetMask(
        int mask);

此函数设置日志记录掩码的值。

参数	内存	输入/输出	描述
mask	主机	输入	日志记录掩码的数值。请参阅 cuBLASMp 日志记录。

有关返回状态的描述，请参阅 cublasMpStatus_t。

警告

这是一个实验性功能。

---

cublasMpLoggerForceDisable

cublasMpStatus_t cublasMpLoggerForceDisable();

此函数禁用整个运行过程的日志记录。

有关返回状态的描述，请参阅 cublasMpStatus_t。

警告

这是一个实验性功能。

---

稠密线性代数 API

cublasMpTrsm

cublasMpStatus_t cublasMpTrsm(
        cublasMpHandle_t handle,
        cublasSideMode_t side,
        cublasFillMode_t uplo,
        cublasOperation_t trans,
        cublasDiagType_t diag,
        int64_t m,
        int64_t n,
        const void* alpha,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        void* b,
        int64_t ib,
        int64_t jb,
        cublasMpMatrixDescriptor_t descB,
        cublasComputeType_t computeType,
        void* d_work,
        size_t workspaceSizeInBytesOnDevice,
        void* h_work,
        size_t workspaceSizeInBytesOnHost);

此函数求解具有多个右侧项的三角线性系统

\(\left\{ \begin{matrix} {\text{op}(A)X = \alpha B} & {\text{if }\textsf{side == $\mathrm{CUBLAS\_SIDE\_LEFT}$}} \\ {X\text{op}(A) = \alpha B} & {\text{if }\textsf{side == $\mathrm{CUBLAS\_SIDE\_RIGHT}$}} \\ \end{matrix} \right.\)

其中 \(A\) 是以较低或较高模式存储的三角矩阵，带或不带主对角线，\(X\) 和 \(B\) 是 \(m \times n\) 矩阵，而 \(\alpha\) 是标量。此外，对于矩阵 \(A\)

\(\text{op}(A) = \left\{ \begin{matrix} A & {\text{if }\textsf{trans == $\mathrm{CUBLAS\_OP\_N}$}} \\ A^{T} & {\text{if }\textsf{trans == $\mathrm{CUBLAS\_OP\_T}$}} \\ A^{H} & {\text{if }\textsf{trans == $\mathrm{CUBLAS\_OP\_C}$}} \\ \end{matrix} \right.\)

解 \(X\) 在退出时覆盖右侧项 \(B\)。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
side	主机	输入	指示矩阵 A 在 X 的左侧还是右侧。
uplo	主机	输入	指示是否存储了矩阵 A 的下部或上部，另一部分未被引用，而是从存储的元素中推断出来的。
trans	主机	输入	非转置或（共轭）转置的运算 op(A)。
diag	主机	输入	指示矩阵 A 主对角线上的元素是否为单位值，并且不应被访问。
m	主机	输入	矩阵 sub(B) 的行数，矩阵 sub(A) 的大小也相应调整。
n	主机	输入	矩阵 sub(B) 的列数，矩阵 sub(A) 的大小也相应调整。
alpha	主机	输入	用于乘法的标量。
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。ia 必须是行分块维度 mbA 的倍数。
ja	主机	输入	sub(A) 第一列的列索引。ja 必须是列分块维度 nbA 的倍数。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。
b	设备	输入/输出	指向全局矩阵 B 的局部部分的第一个条目的指针。
ib	主机	输入	sub(B) 第一行的行索引。ib 必须是行分块维度 mbB 的倍数。
jb	主机	输入	sub(B) 第一列的列索引。jb 必须是列分块维度 nbB 的倍数。
descB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
computeType	主机	输入	cuBLAS 计算类型，用于计算。请参阅下表了解支持的组合。
d_work	设备	输出	大小为 workspaceInBytesOnDevice 的设备工作区。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作区的大小（以字节为单位），由 cublasMpTrsm_bufferSize() 提供。
h_work	主机	输出	大小为 workspaceInBytesOnHost 的主机工作区。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作区的大小（以字节为单位），由 cublasMpTrsm_bufferSize() 提供。

此函数需要正方形分块大小。

此例程支持以下数据类型组合

计算类型	标量类型 (alpha 和 beta)	Atype/Btype	Ctype
CUBLAS_COMPUTE_32F	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUBLAS_COMPUTE_64F	CUDA_R_64F	CUDA_R_64F	CUDA_R_64F
	CUDA_C_64F	CUDA_C_64F	CUDA_C_64F

提供给此函数的 computeType 参数仅用于内部矩阵-矩阵乘法。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpTrsm_bufferSize

cublasMpStatus_t cublasMpTrsm_bufferSize(
        cublasMpHandle_t handle,
        cublasSideMode_t side,
        cublasFillMode_t uplo,
        cublasOperation_t trans,
        cublasDiagType_t diag,
        int64_t m,
        int64_t n,
        const void* alpha,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        void* b,
        int64_t ib,
        int64_t jb,
        cublasMpMatrixDescriptor_t descB,
        cublasComputeType_t computeType,
        size_t* workspaceSizeInBytesOnDevice,
        size_t* workspaceSizeInBytesOnHost);

此函数返回在给定输入上执行 cublasMpTrsm() 所需的缓冲区大小。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
side	主机	输入	指示矩阵 A 在 X 的左侧还是右侧。
uplo	主机	输入	指示是否存储了矩阵 A 的下部或上部，另一部分未被引用，而是从存储的元素中推断出来的。
trans	主机	输入	非转置或（共轭）转置的运算 op(A)。
diag	主机	输入	指示矩阵 A 主对角线上的元素是否为单位值，并且不应被访问。
m	主机	输入	矩阵 sub(B) 的行数，矩阵 sub(A) 的大小也相应调整。
n	主机	输入	矩阵 sub(B) 的列数，矩阵 sub(A) 的大小也相应调整。
alpha	主机	输入	用于乘法的标量。
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。ia 必须是行分块维度 mbA 的倍数。
ja	主机	输入	sub(A) 第一列的列索引。ja 必须是列分块维度 nbA 的倍数。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。
b	设备	输入	指向全局矩阵 B 的局部部分的第一个条目的指针。
ib	主机	输入	sub(B) 第一行的行索引。ib 必须是行分块维度 mbB 的倍数。
jb	主机	输入	sub(B) 第一列的列索引。jb 必须是列分块维度 nbB 的倍数。
descB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
computeType	主机	输入	cuBLAS 计算类型，用于计算。请参阅下表了解支持的组合。
workspaceInBytesOnDevice	主机	输出	在输出时，包含 cublasMpTrsm() 所需的本地设备工作区的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	在输出时，包含 cublasMpTrsm() 所需的本地主机工作区的大小（以字节为单位）。

此函数需要正方形分块大小。

此例程支持以下数据类型组合

计算类型	标量类型 (alpha 和 beta)	Atype/Btype	Ctype
CUBLAS_COMPUTE_32F	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUBLAS_COMPUTE_64F	CUDA_R_64F	CUDA_R_64F	CUDA_R_64F
	CUDA_C_64F	CUDA_C_64F	CUDA_C_64F

提供给此函数的 computeType 参数仅用于内部矩阵-矩阵乘法。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpGemm

cublasMpStatus_t cublasMpGemm(
        cublasMpHandle_t handle,
        cublasOperation_t transA,
        cublasOperation_t transB,
        int64_t m,
        int64_t n,
        int64_t k,
        const void* alpha,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        const void* b,
        int64_t ib,
        int64_t jb,
        cublasMpMatrixDescriptor_t descB,
        const void* beta,
        void* c,
        int64_t ic,
        int64_t jc,
        cublasMpMatrixDescriptor_t descC,
        cublasComputeType_t computeType,
        void* d_work,
        size_t workspaceSizeInBytesOnDevice,
        void* h_work,
        size_t workspaceSizeInBytesOnHost);

此函数执行矩阵-矩阵乘法

\(C = \alpha\text{op}(A)\text{op}(B) + \beta C\)

其中 \(\alpha\) 和 \(\beta\) 是标量，\(A\)、\(B\) 和 \(C\) 是以列优先格式存储的矩阵，其维度分别为 \(\text{op}(A)\) \(m \times k\)、\(\text{op}(B)\) \(k \times n\) 和 \(C\) \(m \times n\)。此外，对于矩阵 \(A\)

\(\text{op}(A) = \left\{ \begin{matrix} A & {\text{if }\textsf{transA == $\mathrm{CUBLAS\_OP\_N}$}} \\ A^{T} & {\text{if }\textsf{transA == $\mathrm{CUBLAS\_OP\_T}$}} \\ A^{H} & {\text{if }\textsf{transA == $\mathrm{CUBLAS\_OP\_C}$}} \\ \end{matrix} \right.\)

并且 \(\text{op}(B)\) 对于矩阵 \(B\) 的定义类似。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
transA	主机	输入	非转置或（共轭）转置的运算 op(A)。
transB	主机	输入	非转置或（共轭）转置的运算 op(B)。
m	主机	输入	sub(A) 和 sub(C) 的行数。
n	主机	输入	sub(B) 和 sub(C) 的列数。
k	主机	输入	sub(A) 的列数和 sub(B) 的行数。
alpha	主机	输入	<type> scalar used for multiplication.
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。ia 必须是行分块维度 mbA 的倍数。
ja	主机	输入	sub(A) 第一列的列索引。ja 必须是列分块维度 nbA 的倍数。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。
b	设备	输入	指向全局矩阵 B 的局部部分的第一个条目的指针。
ib	主机	输入	sub(B) 第一行的行索引。ib 必须是行分块维度 mbB 的倍数。
jb	主机	输入	sub(B) 第一列的列索引。jb 必须是列分块维度 nbB 的倍数。
descB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
beta	主机	输入	<type> scalar used for multiplication.
c	设备	输入/输出	指向全局矩阵 C 的局部部分的第一个条目的指针。
ic	主机	输入	sub(C) 第一行的行索引。ic 必须是行分块维度 mbC 的倍数。
jc	主机	输入	sub(C) 第一列的列索引。jc 必须是列分块维度 nbC 的倍数。
descC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
computeType	主机	输入	cuBLAS 计算类型，用于计算。请参阅下表了解支持的组合。
d_work	设备	输出	大小为 workspaceInBytesOnDevice 的设备工作区。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作区的大小（以字节为单位），由 cublasMpGemm_bufferSize() 提供。
h_work	主机	输出	大小为 workspaceInBytesOnHost 的主机工作区。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作区的大小（以字节为单位），由 cublasMpGemm_bufferSize() 提供。

此例程支持以下数据类型组合

计算类型	标量类型 (alpha 和 beta)	Atype/Btype	Ctype
CUBLAS_COMPUTE_16F 或 CUBLAS_COMPUTE_16F_PEDANTIC	CUDA_R_16F	CUDA_R_16F	CUDA_R_16F
CUBLAS_COMPUTE_32F 或 CUBLAS_COMPUTE_32F_PEDANTIC	CUDA_R_32F	CUDA_R_16BF	CUDA_R_16BF
		CUDA_R_16F	CUDA_R_16F
		CUDA_R_8I	CUDA_R_32F
		CUDA_R_16BF	CUDA_R_32F
		CUDA_R_16F	CUDA_R_32F
		CUDA_R_32F	CUDA_R_32F
	CUDA_C_32F	CUDA_C_8I	CUDA_C_32F
		CUDA_C_32F	CUDA_C_32F
CUBLAS_COMPUTE_32F_FAST_16F 或 CUBLAS_COMPUTE_32F_FAST_16BF 或 CUBLAS_COMPUTE_32F_FAST_TF32	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUBLAS_COMPUTE_64F 或 CUBLAS_COMPUTE_64F_PEDANTIC	CUDA_R_64F	CUDA_R_64F	CUDA_R_64F
	CUDA_C_64F	CUDA_C_64F	CUDA_C_64F

提供给此函数的 computeType 参数仅用于内部矩阵-矩阵乘法。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpGemm_bufferSize

cublasMpStatus_t cublasMpGemm_bufferSize(
        cublasMpHandle_t handle,
        cublasOperation_t transA,
        cublasOperation_t transB,
        int64_t m,
        int64_t n,
        int64_t k,
        const void* alpha,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        const void* b,
        int64_t ib,
        int64_t jb,
        cublasMpMatrixDescriptor_t descB,
        const void* beta,
        void* c,
        int64_t ic,
        int64_t jc,
        cublasMpMatrixDescriptor_t descC,
        cublasComputeType_t computeType,
        size_t* workspaceSizeInBytesOnDevice,
        size_t* workspaceSizeInBytesOnHost);

此函数返回在给定输入上执行 cublasMpGemm() 所需的缓冲区大小。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
transA	主机	输入	非转置或（共轭）转置的运算 op(A)。
transB	主机	输入	非转置或（共轭）转置的运算 op(B)。
m	主机	输入	sub(A) 和 sub(C) 的行数。
n	主机	输入	sub(B) 和 sub(C) 的列数。
k	主机	输入	sub(A) 的列数和 sub(B) 的行数。
alpha	主机	输入	<type> scalar used for multiplication.
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。ia 必须是行分块维度 mbA 的倍数。
ja	主机	输入	sub(A) 第一列的列索引。ja 必须是列分块维度 nbA 的倍数。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。
b	设备	输入	指向全局矩阵 B 的局部部分的第一个条目的指针。
ib	主机	输入	sub(B) 第一行的行索引。ib 必须是行分块维度 mbB 的倍数。
jb	主机	输入	sub(B) 第一列的列索引。jb 必须是列分块维度 nbB 的倍数。
descB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
beta	主机	输入	<type> scalar used for multiplication.
c	设备	输入	指向全局矩阵 C 的局部部分的第一个条目的指针。
ic	主机	输入	sub(C) 第一行的行索引。ic 必须是行分块维度 mbC 的倍数。
jc	主机	输入	sub(C) 第一列的列索引。jc 必须是列分块维度 nbC 的倍数。
descC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
computeType	主机	输入	cuBLAS 计算类型，用于计算。请参阅下表了解支持的组合。
workspaceInBytesOnDevice	主机	输出	在输出时，包含 cublasMpGemm() 所需的本地设备工作区的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	在输出时，包含 cublasMpGemm() 所需的本地主机工作区的大小（以字节为单位）。

此例程支持以下数据类型组合

计算类型	标量类型 (alpha 和 beta)	Atype/Btype	Ctype
CUBLAS_COMPUTE_16F 或 CUBLAS_COMPUTE_16F_PEDANTIC	CUDA_R_16F	CUDA_R_16F	CUDA_R_16F
CUBLAS_COMPUTE_32F 或 CUBLAS_COMPUTE_32F_PEDANTIC	CUDA_R_32F	CUDA_R_16BF	CUDA_R_16BF
		CUDA_R_16F	CUDA_R_16F
		CUDA_R_8I	CUDA_R_32F
		CUDA_R_16BF	CUDA_R_32F
		CUDA_R_16F	CUDA_R_32F
		CUDA_R_32F	CUDA_R_32F
	CUDA_C_32F	CUDA_C_8I	CUDA_C_32F
		CUDA_C_32F	CUDA_C_32F
CUBLAS_COMPUTE_32F_FAST_16F 或 CUBLAS_COMPUTE_32F_FAST_16BF 或 CUBLAS_COMPUTE_32F_FAST_TF32	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUBLAS_COMPUTE_64F 或 CUBLAS_COMPUTE_64F_PEDANTIC	CUDA_R_64F	CUDA_R_64F	CUDA_R_64F
	CUDA_C_64F	CUDA_C_64F	CUDA_C_64F

提供给此函数的 computeType 参数仅用于内部矩阵-矩阵乘法。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpMatmul

cublasMpStatus_t cublasMpMatmul(
        cublasMpHandle_t handle,
        cublasMpMatmulDescriptor_t matmulDesc,
        int64_t m,
        int64_t n,
        int64_t k,
        const void* alpha,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        const void* b,
        int64_t ib,
        int64_t jb,
        cublasMpMatrixDescriptor_t descB,
        const void* beta,
        const void* c,
        int64_t ic,
        int64_t jc,
        cublasMpMatrixDescriptor_t descC,
        void* d,
        int64_t id,
        int64_t jd,
        cublasMpMatrixDescriptor_t descD,
        void* d_work,
        size_t workspaceSizeInBytesOnDevice,
        void* h_work,
        size_t workspaceSizeInBytesOnHost);

此函数执行矩阵-矩阵乘法

\(D = \alpha\text{op}(A)\text{op}(B) + \beta C\)

其中 \(\alpha\) 和 \(\beta\) 是标量，\(A\)、\(B\)、\(C\) 和 \(D\) 是以列优先格式存储的矩阵，其维度分别为 \(\text{op}(A)\) \(m \times k\)、\(\text{op}(B)\) \(k \times n\)、\(C\) \(m \times n\) 和 \(D\) \(m \times n\)。\(\text{op}(A)\) 取决于 matmulDesc 描述符 的 CUBLASMP_MATMUL_DESCRIPTOR_ATTRIBUTE_TRANSA 属性 的值

\(\text{op}(A) = \left\{ \begin{matrix} A & {\text{if }\textsf{TRANSA == $\mathrm{CUBLAS\_OP\_N}$}} \\ A^{T} & {\text{if }\textsf{TRANSA == $\mathrm{CUBLAS\_OP\_T}$}} \\ A^{H} & {\text{if }\textsf{TRANSA == $\mathrm{CUBLAS\_OP\_C}$}} \\ \end{matrix} \right.\)

并且 \(\text{op}(B)\) 对于矩阵 \(B\) 的定义类似，基于 CUBLASMP_MATMUL_DESCRIPTOR_ATTRIBUTE_TRANSB 属性。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
matmulDesc	主机	输入	要执行的操作的描述符，使用 cublasMpMatmulDescriptorCreate() 创建。
m	主机	输入	sub(A) 和 sub(C) 的行数。
n	主机	输入	sub(B) 和 sub(C) 的列数。
k	主机	输入	sub(A) 的列数和 sub(B) 的行数。
alpha	主机	输入	<type> scalar used for multiplication.
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。ia 必须是行分块维度 mbA 的倍数。
ja	主机	输入	sub(A) 第一列的列索引。ja 必须是列分块维度 nbA 的倍数。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。
b	设备	输入	指向全局矩阵 B 的局部部分的第一个条目的指针。
ib	主机	输入	sub(B) 第一行的行索引。ib 必须是行分块维度 mbB 的倍数。
jb	主机	输入	sub(B) 第一列的列索引。jb 必须是列分块维度 nbB 的倍数。
descB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
beta	主机	输入	<type> scalar used for multiplication.
c	设备	输入	指向全局矩阵 C 的局部部分的第一个条目的指针。
ic	主机	输入	sub(C) 第一行的行索引。ic 必须是行分块维度 mbC 的倍数。
jc	主机	输入	sub(C) 第一列的列索引。jc 必须是列分块维度 nbC 的倍数。
descC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
d	设备	输出	指向全局矩阵 D 的局部部分的第一个条目的指针。
id	主机	输入	sub(D) 第一行的行索引。id 必须是行分块维度 mbD 的倍数。
jd	主机	输入	sub(D) 首列的列索引。jd 必须是列分块维度 nbD 的倍数。
descD	主机	输入	与全局矩阵 D 关联的矩阵描述符。
d_work	设备	输出	大小为 workspaceInBytesOnDevice 的设备工作区。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作空间大小（以字节为单位），由 cublasMpMatmul_bufferSize() 提供。
h_work	主机	输出	大小为 workspaceInBytesOnHost 的主机工作区。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作空间大小（以字节为单位），由 cublasMpMatmul_bufferSize() 提供。

此例程支持以下数据类型组合

计算类型	标量类型 (alpha 和 beta)	Atype	Btype	Ctype	Dtype
CUBLAS_COMPUTE_16F 或 CUBLAS_COMPUTE_16F_PEDANTIC	CUDA_R_16F	CUDA_R_16F	CUDA_R_16F	CUDA_R_16F	CUDA_R_16F
CUBLAS_COMPUTE_32F 或 CUBLAS_COMPUTE_32F_PEDANTIC	CUDA_R_32F	CUDA_R_16BF	CUDA_R_16BF	CUDA_R_16BF	CUDA_R_16BF
		CUDA_R_16F	CUDA_R_16F	CUDA_R_16F	CUDA_R_16F
		CUDA_R_8I	CUDA_R_8I	CUDA_R_32F	CUDA_R_32F
		CUDA_R_16BF	CUDA_R_16BF	CUDA_R_32F	CUDA_R_32F
		CUDA_R_16F	CUDA_R_16F	CUDA_R_32F	CUDA_R_32F
		CUDA_R_32F	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
	CUDA_C_32F	CUDA_C_8I	CUDA_C_8I	CUDA_C_32F	CUDA_C_32F
		CUDA_C_32F	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUBLAS_COMPUTE_32F	CUDA_R_32F	CUDA_R_8F_E4M3	CUDA_R_8F_E4M3	CUDA_R_16BF	CUDA_R_16BF
		CUDA_R_8F_E4M3	CUDA_R_8F_E4M3	CUDA_R_16BF	CUDA_R_8F_E4M3
		CUDA_R_8F_E4M3	CUDA_R_8F_E4M3	CUDA_R_16F	CUDA_R_16F
		CUDA_R_8F_E4M3	CUDA_R_8F_E4M3	CUDA_R_16F	CUDA_R_8F_E4M3
		CUDA_R_8F_E4M3	CUDA_R_8F_E4M3	CUDA_R_32F	CUDA_R_32F
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_16BF	CUDA_R_16BF
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_16BF	CUDA_R_8F_E4M3
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_16BF	CUDA_R_8F_E5M2
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_16F	CUDA_R_16F
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_16F	CUDA_R_8F_E4M3
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_16F	CUDA_R_8F_E5M2
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_32F	CUDA_R_32F
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_16BF	CUDA_R_16BF
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_16BF	CUDA_R_8F_E4M3
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_16BF	CUDA_R_8F_E5M2
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_16F	CUDA_R_16F
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_16F	CUDA_R_8F_E4M3
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_16F	CUDA_R_8F_E5M2
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_32F	CUDA_R_32F
CUBLAS_COMPUTE_32F_FAST_16F 或 CUBLAS_COMPUTE_32F_FAST_16BF 或 CUBLAS_COMPUTE_32F_FAST_TF32	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUBLAS_COMPUTE_64F 或 CUBLAS_COMPUTE_64F_PEDANTIC	CUDA_R_64F	CUDA_R_64F	CUDA_R_64F	CUDA_R_64F	CUDA_R_64F
	CUDA_C_64F	CUDA_C_64F	CUDA_C_64F	CUDA_C_64F	CUDA_C_64F

提供给此函数的 computeType 参数仅用于内部矩阵-矩阵乘法。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpMatmul_bufferSize

cublasMpStatus_t cublasMpMatmul_bufferSize(
        cublasMpHandle_t handle,
        cublasMpMatmulDescriptor_t matmulDesc,
        int64_t m,
        int64_t n,
        int64_t k,
        const void* alpha,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        const void* b,
        int64_t ib,
        int64_t jb,
        cublasMpMatrixDescriptor_t descB,
        const void* beta,
        const void* c,
        int64_t ic,
        int64_t jc,
        cublasMpMatrixDescriptor_t descC,
        void* d,
        int64_t id,
        int64_t jd,
        cublasMpMatrixDescriptor_t descD,
        size_t* workspaceSizeInBytesOnDevice,
        size_t* workspaceSizeInBytesOnHost);

此函数返回在给定输入上执行 cublasMpMatmul() 所需的缓冲区大小。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
matmulDesc	主机	输入	要执行的操作的描述符，使用 cublasMpMatmulDescriptorCreate() 创建。
m	主机	输入	sub(A) 和 sub(C) 的行数。
n	主机	输入	sub(B) 和 sub(C) 的列数。
k	主机	输入	sub(A) 的列数和 sub(B) 的行数。
alpha	主机	输入	<type> scalar used for multiplication.
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。ia 必须是行分块维度 mbA 的倍数。
ja	主机	输入	sub(A) 第一列的列索引。ja 必须是列分块维度 nbA 的倍数。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。
b	设备	输入	指向全局矩阵 B 的局部部分的第一个条目的指针。
ib	主机	输入	sub(B) 第一行的行索引。ib 必须是行分块维度 mbB 的倍数。
jb	主机	输入	sub(B) 第一列的列索引。jb 必须是列分块维度 nbB 的倍数。
descB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
beta	主机	输入	<type> scalar used for multiplication.
c	设备	输入	指向全局矩阵 C 的局部部分的第一个条目的指针。
ic	主机	输入	sub(C) 第一行的行索引。ic 必须是行分块维度 mbC 的倍数。
jc	主机	输入	sub(C) 第一列的列索引。jc 必须是列分块维度 nbC 的倍数。
descC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
d	设备	输出	指向全局矩阵 D 的局部部分的第一个条目的指针。
id	主机	输入	sub(D) 第一行的行索引。id 必须是行分块维度 mbD 的倍数。
jd	主机	输入	sub(D) 首列的列索引。jd 必须是列分块维度 nbD 的倍数。
descD	主机	输入	与全局矩阵 D 关联的矩阵描述符。
workspaceInBytesOnDevice	主机	输出	在输出时，包含 cublasMpGemm() 所需的本地设备工作区的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	在输出时，包含 cublasMpGemm() 所需的本地主机工作区的大小（以字节为单位）。

此例程支持以下数据类型组合

计算类型	标量类型 (alpha 和 beta)	Atype	Btype	Ctype	Dtype
CUBLAS_COMPUTE_16F 或 CUBLAS_COMPUTE_16F_PEDANTIC	CUDA_R_16F	CUDA_R_16F	CUDA_R_16F	CUDA_R_16F	CUDA_R_16F
CUBLAS_COMPUTE_32F 或 CUBLAS_COMPUTE_32F_PEDANTIC	CUDA_R_32F	CUDA_R_16BF	CUDA_R_16BF	CUDA_R_16BF	CUDA_R_16BF
		CUDA_R_16F	CUDA_R_16F	CUDA_R_16F	CUDA_R_16F
		CUDA_R_8I	CUDA_R_8I	CUDA_R_32F	CUDA_R_32F
		CUDA_R_16BF	CUDA_R_16BF	CUDA_R_32F	CUDA_R_32F
		CUDA_R_16F	CUDA_R_16F	CUDA_R_32F	CUDA_R_32F
		CUDA_R_32F	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
	CUDA_C_32F	CUDA_C_8I	CUDA_C_8I	CUDA_C_32F	CUDA_C_32F
		CUDA_C_32F	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUBLAS_COMPUTE_32F	CUDA_R_32F	CUDA_R_8F_E4M3	CUDA_R_8F_E4M3	CUDA_R_16BF	CUDA_R_16BF
		CUDA_R_8F_E4M3	CUDA_R_8F_E4M3	CUDA_R_16BF	CUDA_R_8F_E4M3
		CUDA_R_8F_E4M3	CUDA_R_8F_E4M3	CUDA_R_16F	CUDA_R_16F
		CUDA_R_8F_E4M3	CUDA_R_8F_E4M3	CUDA_R_16F	CUDA_R_8F_E4M3
		CUDA_R_8F_E4M3	CUDA_R_8F_E4M3	CUDA_R_32F	CUDA_R_32F
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_16BF	CUDA_R_16BF
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_16BF	CUDA_R_8F_E4M3
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_16BF	CUDA_R_8F_E5M2
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_16F	CUDA_R_16F
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_16F	CUDA_R_8F_E4M3
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_16F	CUDA_R_8F_E5M2
		CUDA_R_8F_E4M3	CUDA_R_8F_E5M2	CUDA_R_32F	CUDA_R_32F
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_16BF	CUDA_R_16BF
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_16BF	CUDA_R_8F_E4M3
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_16BF	CUDA_R_8F_E5M2
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_16F	CUDA_R_16F
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_16F	CUDA_R_8F_E4M3
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_16F	CUDA_R_8F_E5M2
		CUDA_R_8F_E5M2	CUDA_R_8F_E4M3	CUDA_R_32F	CUDA_R_32F
CUBLAS_COMPUTE_32F_FAST_16F 或 CUBLAS_COMPUTE_32F_FAST_16BF 或 CUBLAS_COMPUTE_32F_FAST_TF32	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUBLAS_COMPUTE_64F 或 CUBLAS_COMPUTE_64F_PEDANTIC	CUDA_R_64F	CUDA_R_64F	CUDA_R_64F	CUDA_R_64F	CUDA_R_64F
	CUDA_C_64F	CUDA_C_64F	CUDA_C_64F	CUDA_C_64F	CUDA_C_64F

提供给此函数的 computeType 参数仅用于内部矩阵-矩阵乘法。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpSyrk

cublasMpStatus_t cublasMpSyrk(
        cublasMpHandle_t handle,
        cublasFillMode_t uplo,
        cublasOperation_t trans,
        int64_t n,
        int64_t k,
        const void* alpha,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        const void* beta,
        void* c,
        int64_t ic,
        int64_t jc,
        cublasMpMatrixDescriptor_t descC,
        cublasComputeType_t computeType,
        void* d_work,
        size_t workspaceSizeInBytesOnDevice,
        void* h_work,
        size_t workspaceSizeInBytesOnHost);

此函数执行对称秩-\(k\) 更新

\(C = \alpha\text{op}(A)\text{op}(A)^{T} + \beta C\)

其中 \(\alpha\) 和 \(\beta\) 是标量，\(C\) 是以较低或较高模式存储的对称矩阵，而 \(A\) 是维度为 \(\text{op}(A)\) \(n \times k\) 的矩阵。此外，对于矩阵 \(A\)

\(\text{op}(A) = \left\{ \begin{matrix} A & {\text{if }\textsf{trans == $\mathrm{CUBLAS\_OP\_N}$}} \\ A^{T} & {\text{if }\textsf{trans == $\mathrm{CUBLAS\_OP\_T}$}} \\ \end{matrix} \right.\)

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
uplo	主机	输入	指示矩阵 C 存储的是下半部分还是上半部分，另一个对称部分不被引用，并从存储的元素中推断出来。
trans	主机	输入	运算 op(A) 是非转置或转置。
n	主机	输入	sub(A) 和 sub(C) 的行数。
k	主机	输入	sub(A) 的列数。
alpha	主机	输入	<type> scalar used for multiplication.
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。ia 必须是行分块维度 mbA 的倍数。
ja	主机	输入	sub(A) 第一列的列索引。ja 必须是列分块维度 nbA 的倍数。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。
beta	主机	输入	<type> scalar used for multiplication.
c	设备	输入/输出	指向全局矩阵 A 的局部部分的第一个条目的指针。
ic	主机	输入	sub(C) 第一行的行索引。ic 必须是行分块维度 mbC 的倍数。
jc	主机	输入	sub(C) 第一列的列索引。jc 必须是列分块维度 nbC 的倍数。
descC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
computeType	主机	输入	cuBLAS 计算类型，用于计算。请参阅下表了解支持的组合。
d_work	设备	输出	大小为 workspaceInBytesOnDevice 的设备工作区。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作空间大小（以字节为单位），由 cublasMpSyrk_bufferSize() 提供。
h_work	主机	输出	大小为 workspaceInBytesOnHost 的主机工作区。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作空间大小（以字节为单位），由 cublasMpSyrk_bufferSize() 提供。

此函数需要正方形分块大小。

此例程支持以下数据类型组合

计算类型	标量类型 (alpha 和 beta)	Atype/Btype	Ctype
CUBLAS_COMPUTE_32F	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUBLAS_COMPUTE_64F	CUDA_R_64F	CUDA_R_64F	CUDA_R_64F
	CUDA_C_64F	CUDA_C_64F	CUDA_C_64F

提供给此函数的 computeType 参数仅用于内部矩阵-矩阵乘法。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpSyrk_bufferSize

cublasMpStatus_t cublasMpSyrk_bufferSize(
        cublasMpHandle_t handle,
        cublasFillMode_t uplo,
        cublasOperation_t trans,
        int64_t n,
        int64_t k,
        const void* alpha,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        const void* beta,
        void* c,
        int64_t ic,
        int64_t jc,
        cublasMpMatrixDescriptor_t descC,
        cublasComputeType_t computeType,
        size_t* workspaceSizeInBytesOnDevice,
        size_t* workspaceSizeInBytesOnHost);

此函数返回在给定输入上执行 cublasMpSyrk() 所需的缓冲区大小。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
uplo	主机	输入	指示矩阵 C 存储的是下半部分还是上半部分，另一个对称部分不被引用，并从存储的元素中推断出来。
trans	主机	输入	运算 op(A) 是非转置或转置。
n	主机	输入	sub(A) 和 sub(C) 的行数。
k	主机	输入	sub(A) 的列数。
alpha	主机	输入	<type> scalar used for multiplication.
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。ia 必须是行分块维度 mbA 的倍数。
ja	主机	输入	sub(A) 第一列的列索引。ja 必须是列分块维度 nbA 的倍数。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。
beta	主机	输入	<type> scalar used for multiplication.
c	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ic	主机	输入	sub(C) 第一行的行索引。ic 必须是行分块维度 mbC 的倍数。
jc	主机	输入	sub(C) 第一列的列索引。jc 必须是列分块维度 nbC 的倍数。
descC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
computeType	主机	输入	cuBLAS 计算类型，用于计算。请参阅下表了解支持的组合。
workspaceInBytesOnDevice	主机	输出	输出时，包含 cublasMpSyrk() 所需的本地设备工作空间大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	输出时，包含 cublasMpSyrk() 所需的本地主机工作空间大小（以字节为单位）。

此函数需要正方形分块大小。

此例程支持以下数据类型组合

计算类型	标量类型 (alpha 和 beta)	Atype/Btype	Ctype
CUBLAS_COMPUTE_32F	CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
	CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUBLAS_COMPUTE_64F	CUDA_R_64F	CUDA_R_64F	CUDA_R_64F
	CUDA_C_64F	CUDA_C_64F	CUDA_C_64F

提供给此函数的 computeType 参数仅用于内部矩阵-矩阵乘法。

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpGeadd

cublasMpStatus_t cublasMpGeadd(
        cublasMpHandle_t handle,
        cublasOperation_t trans,
        int64_t m,
        int64_t n,
        const void* alpha,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        const void* beta,
        void* c,
        int64_t ic,
        int64_t jc,
        cublasMpMatrixDescriptor_t descC,
        void* d_work,
        size_t workspaceSizeInBytesOnDevice,
        void* h_work,
        size_t workspaceSizeInBytesOnHost);

此函数执行矩阵-矩阵加法

\(C = \alpha\text{op}(A) + \beta C\)

其中 \(\alpha\) 和 \(\beta\) 是标量，而 \(A\) 和 \(C\) 是以列优先格式存储的矩阵，维度分别为 \(\text{op}(A)\) \(m \times n\) 和 \(C\) \(m \times n\) 。此外，对于矩阵 \(A\)

\(\text{op}(A) = \left\{ \begin{matrix} A & {\text{if }\textsf{trans == $\mathrm{CUBLAS\_OP\_N}$}} \\ A^{T} & {\text{if }\textsf{trans == $\mathrm{CUBLAS\_OP\_T}$}} \\ A^{H} & {\text{if }\textsf{trans == $\mathrm{CUBLAS\_OP\_C}$}} \\ \end{matrix} \right.\)

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
trans	主机	输入	非转置或（共轭）转置的运算 op(A)。
m	主机	输入	sub(A) 和 sub(C) 的行数。
n	主机	输入	sub(A) 和 sub(C) 的列数。
alpha	主机	输入	<type> scalar used for multiplication.
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。ia 必须是行分块维度 mbA 的倍数。
ja	主机	输入	sub(A) 第一列的列索引。ja 必须是列分块维度 nbA 的倍数。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。
beta	主机	输入	<type> scalar used for multiplication.
c	设备	输入/输出	指向全局矩阵 C 的局部部分的第一个条目的指针。
ic	主机	输入	sub(C) 第一行的行索引。ic 必须是行分块维度 mbC 的倍数。
jc	主机	输入	sub(C) 第一列的列索引。jc 必须是列分块维度 nbC 的倍数。
descC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
d_work	设备	输出	大小为 workspaceInBytesOnDevice 的设备工作区。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作空间大小（以字节为单位），由 cublasMpGeadd_bufferSize() 提供。
h_work	主机	输出	大小为 workspaceInBytesOnHost 的主机工作区。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作空间大小（以字节为单位），由 cublasMpGeadd_bufferSize() 提供。

此函数需要正方形分块大小。

此例程支持以下数据类型组合

A 的数据类型	computeType	输出数据类型
CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
CUDA_R_64F	CUDA_R_64F	CUDA_R_64F
CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUDA_C_64F	CUDA_C_64F	CUDA_C_64F

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpGeadd_bufferSize

cublasMpStatus_t cublasMpGeadd_bufferSize(
        cublasMpHandle_t handle,
        cublasOperation_t trans,
        int64_t m,
        int64_t n,
        const void* alpha,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        const void* beta,
        void* c,
        int64_t ic,
        int64_t jc,
        cublasMpMatrixDescriptor_t descC,
        size_t* workspaceSizeInBytesOnDevice,
        size_t* workspaceSizeInBytesOnHost);

此函数返回在给定输入上执行 cublasMpGeadd() 所需的缓冲区大小。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
trans	主机	输入	非转置或（共轭）转置的运算 op(A)。
m	主机	输入	sub(A) 和 sub(C) 的行数。
n	主机	输入	sub(A) 和 sub(C) 的列数。
alpha	主机	输入	<type> scalar used for multiplication.
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。ia 必须是行分块维度 mbA 的倍数。
ja	主机	输入	sub(A) 第一列的列索引。ja 必须是列分块维度 nbA 的倍数。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。
beta	主机	输入	<type> scalar used for multiplication.
c	设备	输入	指向全局矩阵 C 的局部部分的第一个条目的指针。
ic	主机	输入	sub(C) 第一行的行索引。ic 必须是行分块维度 mbC 的倍数。
jc	主机	输入	sub(C) 第一列的列索引。jc 必须是列分块维度 nbC 的倍数。
descC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
workspaceInBytesOnDevice	主机	输出	输出时，包含 cublasMpGeadd() 所需的本地设备工作空间大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	输出时，包含 cublasMpGeadd() 所需的本地主机工作空间大小（以字节为单位）。

此函数需要正方形分块大小。

此例程支持以下数据类型组合

A 的数据类型	computeType	输出数据类型
CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
CUDA_R_64F	CUDA_R_64F	CUDA_R_64F
CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUDA_C_64F	CUDA_C_64F	CUDA_C_64F

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpTradd

cublasMpStatus_t cublasMpTradd(
        cublasMpHandle_t handle,
        cublasFillMode_t uplo,
        cublasOperation_t trans,
        int64_t m,
        int64_t n,
        const void* alpha,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        const void* beta,
        void* c,
        int64_t ic,
        int64_t jc,
        cublasMpMatrixDescriptor_t descC,
        void* d_work,
        size_t workspaceSizeInBytesOnDevice,
        void* h_work,
        size_t workspaceSizeInBytesOnHost);

此函数执行梯形矩阵-矩阵加法

\(C = \alpha\text{op}(A) + \beta C\)

其中 \(\alpha\) 和 \(\beta\) 是标量，而 \(A\) 和 \(C\) 是以列优先格式存储的矩阵，维度分别为 \(\text{op}(A)\) \(m \times n\) 和 \(C\) \(m \times n\) 。此外，对于矩阵 \(A\)

\(\text{op}(A) = \left\{ \begin{matrix} A & {\text{if }\textsf{trans == $\mathrm{CUBLAS\_OP\_N}$}} \\ A^{T} & {\text{if }\textsf{trans == $\mathrm{CUBLAS\_OP\_T}$}} \\ A^{H} & {\text{if }\textsf{trans == $\mathrm{CUBLAS\_OP\_C}$}} \\ \end{matrix} \right.\)

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
uplo	主机	输入	指示矩阵 C 存储的是下半部分还是上半部分，另一部分不被引用，并从存储的元素中推断出来。
trans	主机	输入	非转置或（共轭）转置的运算 op(A)。
m	主机	输入	sub(A) 和 sub(C) 的行数。
n	主机	输入	sub(A) 和 sub(C) 的列数。
alpha	主机	输入	<type> scalar used for multiplication.
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。ia 必须是行分块维度 mbA 的倍数。
ja	主机	输入	sub(A) 第一列的列索引。ja 必须是列分块维度 nbA 的倍数。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。
beta	主机	输入	<type> scalar used for multiplication.
c	设备	输入/输出	指向全局矩阵 C 的局部部分的第一个条目的指针。
ic	主机	输入	sub(C) 第一行的行索引。ic 必须是行分块维度 mbC 的倍数。
jc	主机	输入	sub(C) 第一列的列索引。jc 必须是列分块维度 nbC 的倍数。
descC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
d_work	设备	输出	大小为 workspaceInBytesOnDevice 的设备工作区。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作空间大小（以字节为单位），由 cublasMpTradd_bufferSize() 提供。
h_work	主机	输出	大小为 workspaceInBytesOnHost 的主机工作区。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作空间大小（以字节为单位），由 cublasMpTradd_bufferSize() 提供。

此函数需要正方形分块大小。

此例程支持以下数据类型组合

A 的数据类型	computeType	输出数据类型
CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
CUDA_R_64F	CUDA_R_64F	CUDA_R_64F
CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUDA_C_64F	CUDA_C_64F	CUDA_C_64F

有关返回状态的描述，请参阅 cublasMpStatus_t。

---

cublasMpTradd_bufferSize

cublasMpStatus_t cublasMpTradd_bufferSize(
        cublasMpHandle_t handle,
        cublasFillMode_t uplo,
        cublasOperation_t trans,
        int64_t m,
        int64_t n,
        const void* alpha,
        const void* a,
        int64_t ia,
        int64_t ja,
        cublasMpMatrixDescriptor_t descA,
        const void* beta,
        void* c,
        int64_t ic,
        int64_t jc,
        cublasMpMatrixDescriptor_t descC,
        size_t* workspaceSizeInBytesOnDevice,
        size_t* workspaceSizeInBytesOnHost);

此函数返回在给定输入上执行 cublasMpTradd() 所需的缓冲区大小。

参数	内存	输入/输出	描述
handle	主机	输入	cuBLASMp 库句柄。
uplo	主机	输入	指示矩阵 C 存储的是下半部分还是上半部分，另一部分不被引用，并从存储的元素中推断出来。
trans	主机	输入	非转置或（共轭）转置的运算 op(A)。
m	主机	输入	sub(A) 和 sub(C) 的行数。
n	主机	输入	sub(A) 和 sub(C) 的列数。
alpha	主机	输入	<type> scalar used for multiplication.
a	设备	输入	指向全局矩阵 A 的局部部分的第一个条目的指针。
ia	主机	输入	sub(A) 第一行的行索引。ia 必须是行分块维度 mbA 的倍数。
ja	主机	输入	sub(A) 第一列的列索引。ja 必须是列分块维度 nbA 的倍数。
descA	主机	输入	与全局矩阵 A 关联的矩阵描述符。
beta	主机	输入	<type> scalar used for multiplication.
c	设备	输入	指向全局矩阵 C 的局部部分的第一个条目的指针。
ic	主机	输入	sub(C) 第一行的行索引。ic 必须是行分块维度 mbC 的倍数。
jc	主机	输入	sub(C) 第一列的列索引。jc 必须是列分块维度 nbC 的倍数。
descC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
workspaceInBytesOnDevice	主机	输出	输出时，包含 cublasMpTradd() 所需的本地设备工作空间大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	输出时，包含 cublasMpTradd() 所需的本地主机工作空间大小（以字节为单位）。

此函数需要正方形分块大小。

此例程支持以下数据类型组合

A 的数据类型	computeType	输出数据类型
CUDA_R_32F	CUDA_R_32F	CUDA_R_32F
CUDA_R_64F	CUDA_R_64F	CUDA_R_64F
CUDA_C_32F	CUDA_C_32F	CUDA_C_32F
CUDA_C_64F	CUDA_C_64F	CUDA_C_64F

有关返回状态的描述，请参阅 cublasMpStatus_t。