cuSOLVERMp C API

库管理

cusolverMpCreate

cusolverStatus_t cusolverMpCreate(
        cusolverMpHandle_t *handle,
        int device,
        cudaStream_t stream)

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

调用任何使用 cusolverMpHandle_t 的 cuSOLVERMp 函数，而之前未调用 cusolverMpCreate() 将返回错误。

cuSOLVERMp 库上下文绑定到 device 提供的 CUDA 设备和 CUDA 流 stream。

每个进程和每个 GPU 仅支持一个句柄。与多个进程共享设备将导致未定义的行为。目前，stream 不能是默认 (NULL 或 0) 流。

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

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

cusolverMpDestroy

cusolverStatus_t cusolverMpDestroy(
        cusolverMpHandle_t handle)

此函数销毁 cuSOLVERMp 库句柄 (cusolverMpHandle_t)，它保存 cuSOLVERMp 库上下文。

cuSOLVERMp 库上下文绑定到 device 提供的 CUDA 设备。每个进程和每个 GPU 仅支持一个句柄。

参数	内存	输入/输出	描述
handle	主机	输入/输出	cuSOLVERMp 库句柄

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

cusolverMpGetStream

cusolverStatus_t cusolverMpGetStream(
        cusolverMpHandle_t handle,
        cudaStream_t *stream)

此函数返回与句柄关联的 stream。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄
stream	主机	输出	与句柄关联的流。

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

---

cusolverMpGetVersion

cusolverStatus_t cusolverMpGetVersion(
        cusolverMpHandle_t handle,
        int *version)

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

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄
version	主机	输出	cuSOLVERMp 库版本。值为 CUSOLVERMP_VER_MAJOR * 1000 + CUSOLVERMP_VER_MINOR * 100 + CUSOLVERMP_VER_PATCH

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

---

网格管理

cusolverMpCreateDeviceGrid

cusolverStatus_t cusolverMpCreateDeviceGrid(
        cusolverMpHandle_t handle,
        cusolverMpGrid_t *grid,
        cal_comm_t comm,
        int32_t numRowDevices,
        int32_t numColDevices,
        cusolverMpGridMapping_t mapping)

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

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

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄
grid	主机	输出	要初始化的网格对象。
comm	主机	输入	将与网格关联的通信器。
numRowDevices	主机	输入	网格将包含多少进程行。
numColDevices	主机	输入	网格将包含多少进程列。
mapping	主机	输入	如何将进程映射到网格。有关更多详细信息，请参阅 cusolverMpGrid_t 的描述。目前，仅支持 CUSOLVERMP_GRID_MAPPING_COL_MAJOR

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

---

cusolverMpDestroyGrid

cusolverStatus_t cusolverMpDestroyGrid(
        cusolverMpGrid_t grid)

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

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

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

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

---

矩阵管理

cusolverMpCreateMatrixDesc

cusolverStatus_t cusolverMpCreateMatrixDesc(
        cusolverMpMatrixDescriptor_t *descr,
        cusolverMpGrid_t grid,
        cudaDataType dataType,
        int64_t M_A,
        int64_t N_A,
        int64_t MB_A,
        int64_t NB_A,
        uint32_t RSRC_A,
        uint32_t CSRC_A,
        int64_t LLD_A)

此函数初始化 cusolverMpMatrixDescriptor_t 对象。

参数	内存	输入/输出	描述
descr	主机	输出	由此函数初始化的矩阵描述符对象。
dataType	主机	输入	矩阵 A 的数据类型。
M_A	主机	输入	全局数组 A 中的行数。
N_A	主机	输入	全局矩阵 A 中的列数。
MB_A	主机	输入	用于分布全局矩阵 A 的行的块因子。
NB_A	主机	输入	用于分布全局矩阵 A 的列的块因子。
RSRC_A	主机	输入	矩阵 A 的第一行分布在其上的进程行。目前仅支持值 0。
CSRC_A	主机	输入	矩阵 A 的第一行分布在其上的进程列。目前仅支持值 0。
LLD_A	主机	输入	本地矩阵的引导维度。

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

A 的数据类型	描述
CUDA_R_32I	32 位整数值。
CUDA_R_64I	64 位整数值。
CUDA_R_32F	单精度实数值。
CUDA_R_64F	双精度实数值。
CUDA_C_32F	单精度复数值。
CUDA_C_64F	双精度复数值。

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

---

cusolverMpDestroyMatrixDesc

cusolverStatus_t cusolverMpDestroyMatrixDesc(
        cusolverMpMatrixDescriptor_t descr )

此函数销毁 cusolverMpMatrixDescriptor_t 对象。

参数	内存	输入/输出	描述
descr	主机	输入/输出	由此函数销毁的矩阵描述符对象。

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

---

实用工具

cusolverMpNUMROC

int64_t cusolverMpNUMROC(
        int64_t n,
        int64_t nb,
        uint32_t iproc,
        uint32_t isrcproc,
        uint32_t nprocs)

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

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

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

---

cusolverMpMatrixGatherD2H

cusolverStatus_t cusolverMpMatrixGatherD2H(
        cusolverMpHandle_t handle,
        int64_t M,
        int64_t N,
        void *d_A,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        int root,
        void *h_dst,
        int64_t h_lddst)

在进程 root 上提供的缓冲区中收集全局分布式矩阵 A。输入矩阵 A 最初使用 2D 块循环格式分布，在输出时 h_dst 包含列主序格式的矩阵。

请注意，对于此函数，输入数据在设备上，输出存储在主机内存中。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
M	主机	输入	全局分布式矩阵 A 的行数。
M	主机	输入	全局分布式矩阵 A 的列数。
d_A	设备	输入	全局分布式矩阵 A 的列数。
d_A	设备	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 M×N 分布式矩阵 sub(A) 的本地部分。
IA	主机	输入	全局矩阵 A 中的行索引，指示 sub(A) 的第一行。此函数不对 IA 的对齐方式做任何假设。
JA	主机	输入	全局矩阵 A 中的列索引，指示 sub(A) 的第一列。此函数不对 JA 的对齐方式做任何假设。
descrA	主机	输入	全局矩阵 A 的矩阵描述符。
root	主机	输入	将在其上收集矩阵 A 的进程 ID。
h_dst	主机	输出	进程 root 上的目标主机缓冲区。在输出时，它包含以列主序格式存储的全局矩阵 A。总大小必须至少为 M*N 个字。
h_lddst	主机	输入	进程 root 上 h_dst 的引导维度。必须大于 M。

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

警告

此函数旨在作为实用工具函数来验证数据布局的正确性，并不旨在在大输入上实现高性能。

---

cusolverMpMatrixScatterH2D

cusolverStatus_t cusolverMpMatrixScatterH2D(
        cusolverMpHandle_t handle,
        int64_t M,
        int64_t N,
        void *d_A,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        int root,
        void *h_src,
        int64_t h_ldsrc)

将存储在 root 进程的本地缓冲区 h_src 中的矩阵分散到分布式全局矩阵 A。

输入矩阵 h_src 以列主序格式存储。在输出时，d_A 包含以 2D 块循环格式分布的全局矩阵 A 的本地部分。

请注意，对于此函数，输入数据在主机上，输出存储在设备内存中。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
M	主机	输入	全局分布式矩阵 A 的行数。
M	主机	输入	全局分布式矩阵 A 的列数。
d_A	设备	输出	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输出时，此数组包含 M×N 分布式矩阵 sub(A) 的本地部分。
IA	主机	输入	全局矩阵 A 中的行索引，指示 sub(A) 的第一行。此函数不对 IA 的对齐方式做任何假设。
JA	主机	输入	全局矩阵 A 中的列索引，指示 sub(A) 的第一列。此函数不对 JA 的对齐方式做任何假设。
descrA	主机	输入	全局矩阵 A 的矩阵描述符。
root	主机	输入	用于分布全局矩阵 A 的列的块因子。
h_src	主机	输入	进程 root 上的源缓冲区。在输入时，它包含以列主序格式存储的全局 M × N 矩阵 A。
h_ldsrc	主机	输入	进程 root 上 h_dst 的引导维度。必须大于 M。

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

警告

此函数旨在作为实用工具函数来验证数据布局的正确性，并不旨在在大输入上实现高性能。

---

日志记录

cusolverMpLoggerSetCallback

cusolverStatus_t cusolverMpLoggerSetCallback(
        cusolverMpLoggerCallback_t callback)

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

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

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

警告

这是一个实验性功能。

---

cusolverMpLoggerSetFile

cusolverStatus_t cusolverMpLoggerSetFile(
        FILE *file)

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

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

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

警告

这是一个实验性功能。

---

cusolverMpLoggerOpenFile

cusolverStatus_t cusolverMpLoggerOpenFile(
        const char* logFile)

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

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

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

警告

这是一个实验性功能。

---

cusolverMpLoggerSetLevel

cusolverStatus_t cusolverMpLoggerSetLevel(
        int level)

完整

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

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

警告

这是一个实验性功能。

---

cusolverMpLoggerSetMask

cusolverStatus_t cusolverMpLoggerSetMask(
        int mask)

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

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

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

警告

这是一个实验性功能。

---

cusolverMpLoggerForceDisable

cusolverStatus_t cusolverMpLoggerForceDisable(
        int level)

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

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

警告

这是一个实验性功能。

---

稠密线性代数 API

cusolverMpGetrf

cusolverStatus_t cusolverMpGetrf(
        cusolverMpHandle_t handle,
        int64_t M,
        int64_t N,
        void *d_A,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        int64_t  *d_ipiv,
        cudaDataType_t computeType,
        void *d_work,
        size_t workspaceInBytesOnDevice,
        void *h_work,
        size_t workspaceInBytesOnHost,
        int *info)

此例程使用部分主元法计算通用 M×N 分布式矩阵 sub(A) 的 LU 分解。用户还可以通过设置 d_ipiv=NULL 来禁用主元法。

分解形式为

\[sub(A) = P \cdot L \cdot U\]

其中 \(P\) 是置换矩阵，\(L\) 是具有单位对角线元素的下三角矩阵（如果 \(m > n\)，则为下梯形矩阵），\(U\) 是上三角矩阵（如果 \(m < n\)，则为上梯形矩阵）。\(L\) 和 \(U\) 存储在 sub(A) 中。

用户可以组合 cusolverMpGetrf() 和 cusolverMpGetrs() 来求解线性方程组。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
M	主机	输入	sub(A) 的行数。
N	主机	输入	sub(A) 的列数。
d_A	设备	输入/输出	指向全局矩阵 A 的本地部分的第一项的指针。在输出时，sub(A) 将被 L 和 U 因子覆盖。
IA	主机	输入	sub(A) 的第一行的行索引。此函数不对 IA 的对齐方式做任何假设。
JA	主机	输入	sub(A) 的第一列的列索引。此函数不对 JA 的对齐方式做任何假设。
descrA	主机	输入	与全局矩阵 A 关联的矩阵描述符
d_ipiv	设备	输出	维度为 (LOCr(M_A)+MB_A) 的本地数组。如果用户设置 d_ipiv != NULL，则在输出时，此数组包含主元信息。d_ipiv[i] 指示与本地行 i 交换的全局行。此数组绑定到分布式矩阵 A。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
d_work	主机	输出	设备工作区，大小为 workspaceInBytesOnDevice。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作区的大小（以字节为单位），由 cusolverMpGetrf_bufferSize() 提供。
h_work	主机	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作区的大小（以字节为单位），由 cusolverMpGetrf_bufferSize() 提供。
info	设备	输出	info < 0 表示函数的第 i 个参数的值不正确。info > 0 表示奇异矩阵情况下前导子式 (leading minor) 的索引。

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

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

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

---

cusolverMpGetrf_bufferSize

cusolverStatus_t cusolverMpGetrf_bufferSize(
        cusolverMpHandle_t handle,
        int64_t M,
        int64_t N,
        void *d_A,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        int64_t *d_ipiv,
        cudaDataType_t computeType,
        size_t *workspaceInBytesOnDevice,
        size_t *workspaceInBytesOnHost)

计算 cusolverMpGetrf() 所需的主机和设备工作缓冲区的大小（以字节为单位）。

用户可以设置 d_ipiv=NULL，以便 cusolverMpGetrf() 将计算输入矩阵 A 的 LU 分解，而无需主元法。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
M	主机	输入	sub(A) 的行数。
N	主机	输入	sub(A) 的列数。
d_A	设备	输入	指向全局矩阵 A 的本地部分的第一项的指针。
IA	主机	输入	sub(A) 的第一行的行索引。此函数不对 IA 的对齐方式做任何假设。
JA	主机	输入	sub(A) 的第一列的列索引。此函数不对 JA 的对齐方式做任何假设。
descrA	主机	输入	与全局矩阵 A 关联的矩阵描述符
d_ipiv	设备	输入	指示指向分布式整数数组的指针。当它不是 null 时，将考虑用于主元法的工作区。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
workspaceInBytesOnDevice	主机	输出	在输出时，包含 cusolverMpGetrf() 所需的本地设备工作区的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	在输出时，包含 cusolverMpGetrf() 所需的本地主机工作区的大小（以字节为单位）。

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

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

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

---

cusolverMpGetrs

cusolverStatus_t cusolverMpGetrs(
        cusolverMpHandle_t handle,
        cublasOperation_t trans,
        int64_t N,
        int64_t NRHS,
        const void *d_A,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        const int64_t *d_ipiv,
        void *d_B,
        int64_t IB,
        int64_t JB,
        cusolverMpMatrixDescriptor_t descrB,
        cudaDataType_t computeType,
        void *d_work,
        size_t workspaceInBytesOnDevice,
        void *h_work,
        size_t workspaceInBytesOnHost,
        int *d_info)

此例程求解分布式线性方程组

\[op(sub(A)) \cdot X = sub(B)\]

对于使用 cusolverMpGetrf() 计算的 LU 分解的通用 N×N 分布式矩阵 sub(A)。

其中 \(op\) 由参数 trans 定义，它允许求解以下形式的线性系统

trans	线性系统的形式
CUBLAS_OP_N	\(sub(A) \cdot X = sub(B)\)
CUBLAS_OP_T	\(sub(A)^T \cdot X = sub(B)\)
CUBLAS_OP_C	\(sub(A)^H \cdot X = sub(B)\)

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
trans	主机	输入	指定线性系统的形式。目前仅支持 CUBLAS_OP_N。
N	主机	输入	sub(A) 的行数。
NRHS	主机	输入	sub(B) 的列数。目前，此例程仅支持 NRHS=1。
d_A	设备	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 M×N 分布式 L 和 U 因子 sub(A) 的本地部分，如 cusolverMpGetrf() 计算的那样。
IA	主机	输入	sub(A) 的第一行的行索引。此函数不对 IA 的对齐方式做任何假设。
JA	主机	输入	sub(A) 的第一列的列索引。此函数不对 JA 的对齐方式做任何假设。
descrA	主机	输入	与全局矩阵 A 关联的矩阵描述符
d_ipiv	设备	输入	维度为 (LOCr(M_A)+MB_A) 的本地数组，包含由 cusolverMpGetrf() 计算的主元信息。
d_B	设备	输入/输出	指向本地内存的指针，指向维度为 (LLD_B,LOCc(JB+NRHS-1)) 的数组。在输入时，右侧 sub(B)。在退出时，sub(B) 将被解分布式矩阵 X 覆盖。
IB	主机	输入	sub(B) 的第一行的行索引。此函数不对 IB 的对齐方式做任何假设。
JB	主机	输入	sub(B) 的第一列的列索引。此函数不对 JB 的对齐方式做任何假设。
descrB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
d_work	设备	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作区的大小（以字节为单位），由 cusolverMpGetrs_bufferSize() 提供。
h_work	主机	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作区的大小（以字节为单位），由 cusolverMpGetrs_bufferSize() 提供。
info	设备	输出	info < 0 表示函数的第 i 个参数的值不正确。info > 0 表示奇异矩阵情况下前导子式 (leading minor) 的索引。

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

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

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

---

cusolverMpGetrs_bufferSize

cusolverStatus_t cusolverMpGetrs_bufferSize(
        cusolverMpHandle_t handle,
        cublasOperation_t trans,
        int64_t N,
        int64_t NRHS,
        const void *d_A,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        const int64_t *d_ipiv,
        void *d_B,
        int64_t IB,
        int64_t JB,
        cusolverMpMatrixDescriptor_t descrB,
        cudaDataType_t computeType,
        size_t *workspaceInBytesOnDevice,
        size_t *workspaceInBytesOnHost)

计算 cusolverMpGetrs() 所需的主机和设备工作缓冲区的大小（以字节为单位）。

如果在 cusolverMpGetrf() 期间禁用了主元法，则用户必须设置 d_ipiv=NULL。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
trans	主机	输入	指定线性系统的形式。目前仅支持 CUBLAS_OP_N。
N	主机	输入	sub(A) 的行数。
NRHS	主机	输入	sub(B) 的列数。目前，此例程仅支持 NRHS=1。
d_A	设备	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 M×N 分布式 L 和 U 因子 sub(A) 的本地部分，如 cusolverMpGetrf() 计算的那样。
IA	主机	输入	sub(A) 的第一行的行索引。此函数不对 IA 的对齐方式做任何假设。
JA	主机	输入	sub(A) 的第一列的列索引。此函数不对 JA 的对齐方式做任何假设。
descrA	主机	输入	与全局矩阵 A 关联的矩阵描述符
d_ipiv	设备	输入	维度为 (LOCr(M_A)+MB_A) 的本地数组，包含由 cusolverMpGetrf() 计算的主元信息。
d_B	设备	输入	指向全局矩阵 B 的本地部分的第一项的指针。在输出时，B 将被线性方程组的解覆盖。
IB	主机	输入	sub(B) 的第一行的行索引。此函数不对 IB 的对齐方式做任何假设。
JB	主机	输入	sub(B) 的第一列的列索引。此函数不对 JB 的对齐方式做任何假设。
descrB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
workspaceInBytesOnDevice	主机	输出	在输出时，包含 cusolverMpGetrs() 所需的本地设备工作区的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	在输出时，包含 cusolverMpGetrs() 所需的本地主机工作区的大小（以字节为单位）。

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

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

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

---

cusolverMpPotrf

cusolverStatus_t cusolverMpPotrf(
        cusolverMpHandle_t handle,
        cublasFillMode_t uplo,
        int64_t N,
        void *d_A,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        cudaDataType_t computeType,
        void *d_work,
        size_t workspaceInBytesOnDevice,
        void *h_work,
        size_t workspaceInBytesOnHost,
        int *info)

计算 N×N 实对称或复 Hermitian 正定分布式矩阵 sub(A)（表示为 A(IA:IA+N-1, JA:JA+N-1)）的 Cholesky 分解。

如果 A 是上三角矩阵且 uplo=CUBLAS_FILL_MODE_UPPER，则分解形式为

\[sub(A) = U^H \cdot U\]

其中 U 是上三角矩阵。

如果矩阵是下三角矩阵且 uplo 设置为 CUBLAS_FILL_MODE_LOWER，则分解形式为

\[sub(A) = L \cdot L^H\]

其中 L 是下三角矩阵。

用户可以组合 cusolverMpPotrf() 和 cusolverMpPotrs() 来求解线性方程组。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
uplo	主机	输入	指定 A 是上三角矩阵 (CUBLAS_FILL_MODE_UPPER) 还是下三角矩阵 (CUBLAS_FILL_MODE_LOWER)。
N	主机	输入	N
d_A	设备	输入	sub(A) 的行数和列数。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	IA
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
d_work	设备	输出	设备工作区，大小为 workspaceInBytesOnDevice。
workspaceInBytesOnDevice	主机	输入	JA
h_work	主机	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnHost	主机	输入	sub(A) 的第一列的列索引。JA 必须是列块维度 NB_A 的倍数。
info	设备	输出	info < 0 表示函数的第 i 个参数的值不正确。info > 0 表示奇异矩阵情况下前导子式 (leading minor) 的索引。

descrA

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

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

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

---

与全局矩阵 A 关联的矩阵描述符。

cusolverStatus_t cusolverMpPotrf_bufferSize(
        cusolverMpHandle_t handle,
        cublasFillMode_t uplo,
        int64_t N,
        const void *d_A,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        cudaDataType_t computeType,
        size_t* workspaceInBytesOnDevice,
        size_t* workspaceInBytesOnHost)

例程所需的本地设备工作区的大小（以字节为单位），由 cusolverMpPotrf_bufferSize() 提供。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
uplo	主机	输入	指定 A 是上三角矩阵 (CUBLAS_FILL_MODE_UPPER) 还是下三角矩阵 (CUBLAS_FILL_MODE_LOWER)。
N	主机	输入	N
d_A	设备	输入	sub(A) 的行数和列数。
IA	主机	输入	sub(A) 的第一行的行索引。此函数不对 IA 的对齐方式做任何假设。
JA	主机	输入	sub(A) 的第一列的列索引。此函数不对 JA 的对齐方式做任何假设。
descrA	主机	输入	与全局矩阵 A 关联的矩阵描述符
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
workspaceInBytesOnDevice	主机	输出	例程所需的本地主机工作区的大小（以字节为单位），由 cusolverMpPotrf_bufferSize() 提供。
workspaceInBytesOnHost	主机	输出	此函数需要正方形块大小 (MB_A == NB_A)。

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

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

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

---

cusolverMpPotrf_bufferSize

cusolverStatus_t cusolverMpPotrs(
        cusolverMpHandle_t handle,
        cublasFillMode_t uplo,
        int64_t N,
        int64_t NRHS,
        const void *d_A,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        void *d_B,
        int64_t IB,
        int64_t JB,
        cusolverMpMatrixDescriptor_t descB,
        cudaDataType_t computeType,
        void *d_work,
        size_t workspaceInBytesOnDevice,
        void *h_work,
        size_t workspaceInBytesOnHost,
        int *info)

计算 cusolverMpPotrf() 所需的主机和设备工作缓冲区的大小（以字节为单位）。

在输出时，包含 cusolverMpPotrf() 所需的本地设备工作区的大小（以字节为单位）。

在输出时，包含 cusolverMpPotrf() 所需的本地主机工作区的大小（以字节为单位）。

\[sub(A) = U^H \cdot U\]

cusolverMpPotrs

求解线性方程组

\[sub(A) \cdot X = sub(B)\]

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
uplo	主机	输入	指定 A 是上三角矩阵 (CUBLAS_FILL_MODE_UPPER) 还是下三角矩阵 (CUBLAS_FILL_MODE_LOWER)。
N	主机	输入	N
NRHS	主机	输入	sub(B) 的列数。目前，此例程仅支持 NRHS=1。
d_A	设备	输入	其中 sub(A) 表示 A(IA:IA+N-1,JA:JA+N-1)，是使用 Cholesky 分解的 N×N 对称或 Hermitian 正定分布式矩阵
IA	主机	输入	或
JA	主机	输入	\[sub(B) = L \cdot L^H\]
descrA	主机	输入	与全局矩阵 A 关联的矩阵描述符
d_B	设备	输入/输出	指向本地内存的指针，指向维度为 (LLD_B,LOCc(JB+NRHS-1)) 的数组。在输入时，右侧 sub(B)。在退出时，sub(B) 将被解分布式矩阵 X 覆盖。
IB	主机	输入	sub(B) 的第一行的行索引。此函数不对 IB 的对齐方式做任何假设。
JB	主机	输入	sub(B) 的第一列的列索引。此函数不对 JB 的对齐方式做任何假设。
descrB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
d_work	设备	输出	设备工作区，大小为 workspaceInBytesOnDevice。
workspaceInBytesOnDevice	主机	输入	由 cusolverMpPotrf() 计算，sub(B) 表示分布式矩阵 B(IB:IB+N-1,JB:JB+NRHS-1)。
h_work	主机	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnHost	主机	输入	d_A
info	设备	输出	info < 0 表示函数的第 i 个参数的值不正确。info > 0 表示奇异矩阵情况下前导子式 (leading minor) 的索引。

指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。包含 N×N 分布式 L 或 U 因子 sub(A) 的本地部分，如 cusolverMpPotrf() 计算的那样。

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

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

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

IA

sub(A) 的第一行的行索引。IA 必须是行块维度 NB_A 的倍数。

cusolverStatus_t cusolverMpPotrs_bufferSize(
        cusolverMpHandle_t handle,
        cublasFillMode_t uplo,
        int64_t n,
        int64_t nrhs,
        const void *a,
        int64_t ia,
        int64_t ja,
        cusolverMpMatrixDescriptor_t descrA,
        const void *b,
        int64_t ib,
        int64_t jb,
        cusolverMpMatrixDescriptor_t descB,
        cudaDataType_t computeType,
        size_t* workspaceInBytesOnDevice,
        size_t* workspaceInBytesOnHost)

JA

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
uplo	主机	输入	指定 A 是上三角矩阵 (CUBLAS_FILL_MODE_UPPER) 还是下三角矩阵 (CUBLAS_FILL_MODE_LOWER)。
N	主机	输入	N
NRHS	主机	输入	sub(B) 的列数。目前，此例程仅支持 NRHS=1。
d_A	设备	输入	其中 sub(A) 表示 A(IA:IA+N-1,JA:JA+N-1)，是使用 Cholesky 分解的 N×N 对称或 Hermitian 正定分布式矩阵
IA	主机	输入	或
JA	主机	输入	\[sub(B) = L \cdot L^H\]
descrA	主机	输入	与全局矩阵 A 关联的矩阵描述符
d_B	设备	输入	指向本地内存的指针，指向维度为 (LLD_B,LOCc(JB+NRHS-1)) 的数组。在输入时，右侧 sub(B)。在退出时，sub(B) 将被解分布式矩阵 X 覆盖。
IB	主机	输入	sub(B) 的第一行的行索引。此函数不对 IB 的对齐方式做任何假设。
JB	主机	输入	sub(B) 的第一列的列索引。此函数不对 JB 的对齐方式做任何假设。
descrB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
workspaceInBytesOnDevice	主机	输出	sub(A) 的第一列的列索引。JA 必须是列块维度 MB_A 的倍数。
workspaceInBytesOnHost	主机	输出	例程所需的本地设备工作区的大小（以字节为单位），由 cusolverMpPotrs_bufferSize() 提供。

指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。包含 N×N 分布式 L 或 U 因子 sub(A) 的本地部分，如 cusolverMpPotrf() 计算的那样。

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

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

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

IA

cusolverMpGeqrf

cusolverStatus_t cusolverMpGeqrf(
        cusolverMpHandle_t handle,
        int64_t M,
        int64_t N,
        void *d_A,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        void *d_tau,
        cudaDataType_t computeType,
        void *d_work,
        size_t workspaceInBytesOnDevice,
        void *h_work,
        size_t workspaceInBytesOnHost,
        int *info)

计算分布式 M×N 矩阵 sub(A)（表示为 A(IA:IA+M-1, JA:JA+N-1)）的 QR 分解。

\[sub(A) = Q \cdot R\]

其中 Q 是由 Householder 反射器的乘积表示的正交矩阵，带有 tau 数组，R 是上三角矩阵。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
M	主机	输入	sub(A) 的行数。
N	主机	输入	sub(A) 的列数。
d_A	设备	输入/输出	指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组的本地内存指针。在输入时，此数组包含 M×N 分布式矩阵 sub(A) 的本地块。在输出时，此数组包含 A 的 R 因子和对角线下方的 Householder 反射器，带有 tau 向量。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	sub(A) 的第一列的列索引。JA 必须是列分块维度 NB_A 的倍数。
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
d_tau	设备	输出	指向维度为 LOCc(JA+N-1) 的数组的本地内存指针。此数组包含 Householder 反射器的标量因子。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
d_work	设备	输出	设备工作区，大小为 workspaceInBytesOnDevice。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作空间的大小（以字节为单位），由 cusolverMpGeqrf_bufferSize() 提供。
h_work	主机	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作空间的大小（以字节为单位），由 cusolverMpGeqrf_bufferSize() 提供。
info	设备	输出	info < 0 表示函数的第 i 个参数值不正确。

descrA

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

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

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

---

cusolverMpGeqrf_bufferSize

cusolverStatus_t cusolverMpGeqrf_bufferSize(
        cusolverMpHandle_t handle,
        int64_t M,
        int64_t N,
        const void *d_A,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        cudaDataType_t computeType,
        size_t* workspaceInBytesOnDevice,
        size_t* workspaceInBytesOnHost)

计算 cusolverMpGeqrf() 所需的主机和设备工作缓冲区的大小（以字节为单位）。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
M	主机	输入	sub(A) 的行数。
N	主机	输入	sub(A) 的列数。
d_A	设备	输入	指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组的本地内存指针。
IA	主机	输入	全局矩阵 A 中的行索引，指示 sub(A) 的第一行。此函数不对 IA 的对齐方式做任何假设。
JA	主机	输入	全局矩阵 A 中的列索引，指示 sub(A) 的第一列。此函数不对 JA 的对齐方式做任何假设。
descrA	主机	输入	与全局矩阵 A 关联的矩阵描述符
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
workspaceInBytesOnDevice	主机	输出	在输出时，包含 cusolverMpGeqrf() 所需的本地设备工作空间的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	在输出时，包含 cusolverMpGeqrf() 所需的本地主机工作空间的大小（以字节为单位）。

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

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

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

IA

cusolverMpOrmqr

cusolverStatus_t cusolverMpOrmqr(
        cusolverMpHandle_t handle,
        cublasSideMode_t side,
        cublasOperation_t trans,
        int64_t M,
        int64_t N,
        int64_t K,
        const void *d_A,
        int64_t IA,
        int64_t JA,
        const cusolverMpMatrixDescriptor_t descrA,
        const void *d_tau,
        void *d_C,
        int64_t IC,
        int64_t JC,
        const cusolverMpMatrixDescriptor_t descC,
        cudaDataType_t computeType,
        void *d_work,
        size_t workspaceInBytesOnDevice,
        void *h_work,
        size_t workspaceInBytesOnHost,
        int *info)

将分布式 M×N 矩阵 sub(C)（表示为 C(IC:IC+M-1, JC:JC+N-1)）乘以可以从 cusolverMpGeqrf() 给出的正交矩阵 Q。

该函数可以执行以下矩阵乘积，并将结果覆盖到 sub(C) 上。

\[\begin{split}sub(C) = op(Q) \cdot sub(C) \\ sub(C) = sub(C) \cdot op(Q)\end{split}\]

分别对于 side 为 CUBLAS_SIDE_LEFT 和 CUBLAS_SIDE_RIGHT 的情况。请注意，当前实现仅支持 CUBLAS_SIDE_LEFT。

Q 是一个正交矩阵，由从 cusolverMpGeqrf() 返回的 Householder 反射器的乘积构成。

\[Q = H(1) H(2) ... H(K)\]

Householder 反射器的数量受 CUBLAS_SIDE_LEFT 和 CUBLAS_SIDE_RIGHT 分别为 K <= M 和 K <= N 的约束。

op 可以根据 trans 参数 CUBLAS_OP_N、CUBLAS_OP_T 和 CUBLAS_OP_H 转换为 \(Q\)、\(Q^T\)、\(Q^H\)。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
side	主机	输入	指示 Q 从左侧还是右侧应用。
trans	主机	输入	指示 Q 应用时是否不转置或（共轭）转置。
M	主机	输入	sub(C) 的行数。
N	主机	输入	sub(C) 的列数。
K	主机	输入	定义 Q 的 Householder 反射器的数量。
d_A	设备	输入	指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组的本地内存指针。此数组包含对角线下方的 Householder 反射器，带有 tau 向量。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	IA
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
d_tau	设备	输入	指向维度为 LOCc(JA+N-1) 的数组的本地内存指针。此数组包含 Householder 反射器的标量因子。
d_C	设备	输入/输出	指向维度为 (LLD_C, LOCc(JC+N-1)) 的数组的本地内存指针。在输入时，该数组包含 M×N 分布式矩阵 sub(C) 的本地块。在输出时，sub(C) 被 op(Q)*sub(C) 或 sub(C)*op(Q) 覆盖。
IC	主机	输入	sub(C) 的第一行的行索引。IC 必须是行分块维度 MB_C 的倍数。
JC	主机	输入	sub(C) 的第一列的列索引。JC 必须是列分块维度 NB_C 的倍数。
descrC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
d_work	设备	输出	设备工作区，大小为 workspaceInBytesOnDevice。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作空间的大小（以字节为单位），由 cusolverMpOrmqr_bufferSize() 提供。
h_work	主机	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作空间的大小（以字节为单位），由 cusolverMpOrmqr_bufferSize() 提供。
info	设备	输出	info < 0 表示函数的第 i 个参数值不正确。

此函数要求正方形块大小 (MB_A == NB_A) 以及 sub(A) 和 sub(C) 矩阵的对齐，即 (MB_A == MB_C) 和 (IA == IC)。

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

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

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

---

cusolverMpOrmqr_bufferSize

cusolverStatus_t cusolverMpOrmqr_bufferSize(
        cusolverMpHandle_t handle,
        cublasSideMode_t side,
        cublasOperation_t trans,
        int64_t M,
        int64_t N,
        int64_t K,
        const void *d_A,
        int64_t IA,
        int64_t JA,
        const cusolverMpMatrixDescriptor_t descrA,
        const void *d_tau,
        void *d_C,
        int64_t IC,
        int64_t JC,
        const cusolverMpMatrixDescriptor_t descrC,
        cudaDataType_t computeType,
        size_t* workspaceInBytesOnDevice,
        size_t* workspaceInBytesOnHost)

计算 cusolverMpOrmqr() 所需的主机和设备工作缓冲区的大小（以字节为单位）。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
side	主机	输入	指示 Q 从左侧还是右侧应用。
trans	主机	输入	指示 Q 应用时是否不转置或（共轭）转置。
M	主机	输入	sub(C) 的行数。
N	主机	输入	sub(C) 的列数。
K	主机	输入	定义 Q 的 Householder 反射器的数量。
d_A	设备	输入	指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组的本地内存指针。此数组包含对角线下方的 Householder 反射器，带有 tau 向量。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	IA
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
d_tau	设备	输入	指向维度为 LOCc(JA+N-1) 的数组的本地内存指针。此数组包含 Householder 反射器的标量因子。
d_C	设备	输入	指向维度为 (LLD_C, LOCc(JC+N-1)) 的数组的本地内存指针。在输入时，该数组包含 M×N 分布式矩阵 sub(C) 的本地块。在输出时，sub(C) 被 op(Q)*sub(C) 或 sub(C)*op(Q) 覆盖。
IC	主机	输入	sub(C) 的第一行的行索引。IC 必须是行分块维度 MB_C 的倍数。
JC	主机	输入	sub(C) 的第一列的列索引。JC 必须是列分块维度 NB_C 的倍数。
descrC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
workspaceInBytesOnDevice	主机	输出	cusolverMpOrmqr() 所需的本地设备工作空间的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	cusolverMpOrmqr() 所需的本地主机工作空间的大小（以字节为单位）。

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

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

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

---

cusolverMpGels

cusolverStatus_t cusolverMpGels(
        cusolverMpHandle_t handle,
        cublasOperation_t trans,
        int64_t M,
        int64_t N,
        int64_t NRHS,
        void *d_A,
        int64_t IA,
        int64_t JA,
        const cusolverMpMatrixDescriptor_t descrA,
        void *d_B,
        int64_t IB,
        int64_t JB,
        const cusolverMpMatrixDescriptor_t descrB,
        cudaDataType_t computeType,
        void *d_work,
        size_t workspaceInBytesOnDevice,
        void *h_work,
        size_t workspaceInBytesOnHost,
        int *info)

使用 sub(A) 的 QR 或 LQ 分解，求解涉及分布式 M×N 矩阵 sub(A)（表示为 A(IA:IA+M-1, JA:JA+N-1)）或其转置的超定或欠定线性系统。

请注意，对于没有转置选项的超定系统 (M >= N) 的解，仅支持通过 QR 分解 cusolverMpGeqrf()。

\[X \leftarrow \mbox{argmin} | sub(B) - sub(A) \cdot X |\]

其中 sub(B) 是一个分布式 M×NRHS 多向量，表示为 B(IB:IB+M-1, JB:JB+NRHS-1)，解多向量 X 被覆盖到 sub(B) 上。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
trans	主机	输入	指示 sub(A) 的线性系统是否涉及不转置或（共轭）转置。
M	主机	输入	sub(A) 的行数。
N	主机	输入	sub(A) 的列数。
NRHS	主机	输入	右手边向量的数量，即 sub(B) 和 X 的列数。
d_A	设备	输入	指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组的本地内存指针。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	sub(A) 的第一列的列索引。JA 必须是列分块维度 NB_A 的倍数。
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
d_B	设备	输入/输出	指向维度为 (LLD_B, LOCc(JB+NRHS-1)) 的数组的本地内存指针。在输入时，该数组包含 M×NRHS 分布式矩阵 sub(B) 的本地块。在输出时，sub(B) 被解向量的解覆盖。
IB	主机	输入	sub(B) 的第一行的行索引。IB 必须是行分块维度 MB_B 的倍数。
JB	主机	输入	sub(B) 的第一列的列索引。JB 必须是列分块维度 NB_B 的倍数。
descrB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
d_work	设备	输出	设备工作区，大小为 workspaceInBytesOnDevice。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作空间的大小（以字节为单位），由 cusolverMpGels_bufferSize() 提供。
h_work	主机	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作空间的大小（以字节为单位），由 cusolverMpGels_bufferSize() 提供。
info	设备	输出	info < 0 表示函数的第 i 个参数值不正确。

指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。包含 N×N 分布式 L 或 U 因子 sub(A) 的本地部分，如 cusolverMpPotrf() 计算的那样。

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

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

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

---

cusolverMpGels_bufferSize

cusolverStatus_t cusolverMpGels_bufferSize(
        cusolverMpHandle_t handle,
        cublasOperation_t trans,
        int64_t M,
        int64_t N,
        int64_t NRHS,
        void *d_A,
        int64_t IA,
        int64_t JA,
        const cusolverMpMatrixDescriptor_t descrA,
        void *d_B,
        int64_t IB,
        int64_t JB,
        const cusolverMpMatrixDescriptor_t descrB,
        cudaDataType_t computeType,
        size_t* workspaceInBytesOnDevice,
        size_t* workspaceInBytesOnHost)

计算 cusolverMpGels() 所需的主机和设备工作缓冲区的大小（以字节为单位）。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
trans	主机	输入	指示 sub(A) 的线性系统是否涉及不转置或（共轭）转置。
M	主机	输入	sub(A) 的行数。
N	主机	输入	sub(A) 的列数。
NRHS	主机	输入	右手边向量的数量，即 sub(B) 和 X 的列数。
d_A	设备	输入	指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组的本地内存指针。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	sub(A) 的第一列的列索引。JA 必须是列分块维度 NB_A 的倍数。
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
d_B	设备	输入	指向维度为 (LLD_B, LOCc(JB+NRHS-1)) 的数组的本地内存指针。
IB	主机	输入	sub(B) 的第一行的行索引。IB 必须是行分块维度 MB_B 的倍数。
JB	主机	输入	sub(B) 的第一列的列索引。JB 必须是列分块维度 NB_B 的倍数。
descrB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
workspaceInBytesOnDevice	主机	输出	cusolverMpGels() 所需的本地设备工作空间的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	cusolverMpGels() 所需的本地主机工作空间的大小（以字节为单位）。

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

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

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

---

cusolverMpSytrd

cusolverStatus_t cusolverMpSytrd(
        cusolverMpHandle_t handle,
        cublasFillMode_t uplo,
        int64_t N,
        void *d_A,
        int64_t IA,
        int64_t JA,
        const cusolverMpMatrixDescriptor_t descrA,
        void *d_d,
        void *d_e,
        void *d_tau,
        cudaDataType_t computeType,
        void *d_work,
        size_t workspaceInBytesOnDevice,
        void *h_work,
        size_t workspaceInBytesOnHost,
        int *info)

将对称（或复数值类型的埃尔米特）分布式 N×N 矩阵 sub(A)（表示为 A(IA:IA+N-1, JA:JA+N-1)）约化为三对角形式。

\[A \rightarrow Q \cdot T \cdot Q^H\]

目前，该函数仅为 CUBLAS_FILL_MODE_LOWER 实现。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
uplo	主机	输入	指示函数使用 sub(A) 的上三角部分或下三角部分。
N	主机	输入	方阵 sub(A) 的行数/列数。
d_A	设备	输入/输出	指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组的本地内存指针。在输入时，该数组包含对称分布式矩阵 sub(A) 的本地部分。在输出时，如果设置了 CUBLAS_FILL_MODE_UPPER，则 sub(A) 的三对角矩阵的对角线和第一条超对角线被相应的三对角矩阵覆盖，并且 Householder 反射器存储在 sub(A) 的超对角线上方。如果设置了 CUBLAS_FILL_MODE_LOWER，则 sub(A) 的对角线和第一条次对角线被相应的三对角矩阵覆盖，并且 Householder 反射器存储在 sub(A) 的次对角线下方。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	sub(A) 的第一列的列索引。JA 必须是列分块维度 NB_A 的倍数。
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
d_d	设备	输出	指向维度为 LOCc(JA+N-1) 的数组的本地内存指针。三对角矩阵的对角线元素存储为：d(i) = A(i,i)。
d_e	设备	输出	指向维度为 LOCc(JA+N-1) 的数组的本地内存指针。三对角矩阵的非对角线元素存储为：对于 CUBLAS_FILL_MODE_UPPER，e(i) = A(i,i+1)；对于 CUBLAS_FILL_MODE_LOWER，e(i) = A(i+1,i)。
d_tau	设备	输出	指向维度为 LOCc(JA+N-1) 的数组的本地内存指针。此数组包含 Householder 反射器的标量因子。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
d_work	设备	输出	设备工作区，大小为 workspaceInBytesOnDevice。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作空间的大小（以字节为单位），由 cusolverMpSytrd_bufferSize() 提供。
h_work	主机	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作空间的大小（以字节为单位），由 cusolverMpSytrd_bufferSize() 提供。
info	设备	输出	info < 0 表示函数的第 i 个参数值不正确。

此函数要求 A 的块大小为正方形，(MB_A == NB_A)。

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

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

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

---

cusolverMpSytrd_bufferSize

cusolverStatus_t cusolverMpSytrd_bufferSize(
        cusolverMpHandle_t handle,
        cublasFillMode_t uplo,
        int64_t N,
        void *d_A,
        int64_t IA,
        int64_t JA,
        const cusolverMpMatrixDescriptor_t descrA,
        void *d_d,
        void *d_e,
        void *d_tau,
        cudaDataType_t computeType,
        size_t *workspaceInBytesOnDevice,
        size_t *workspaceInBytesOnHost)

计算 cusolverMpSytrd() 所需的主机和设备工作缓冲区的大小（以字节为单位）。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
uplo	主机	输入	指示函数使用 sub(A) 的上三角部分或下三角部分。
N	主机	输入	方阵 sub(A) 的行数/列数。
d_A	设备	输入	指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组的本地内存指针。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	sub(A) 的第一列的列索引。JA 必须是列分块维度 NB_A 的倍数。
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
d_d	设备	输入	指向维度为 LOCc(JA+N-1) 的数组的本地内存指针。
d_e	设备	输入	指向维度为 LOCc(JA+N-1) 的数组的本地内存指针。
d_tau	设备	输入	指向维度为 LOCc(JA+N-1) 的数组的本地内存指针。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
workspaceInBytesOnDevice	主机	输出	cusolverMpSytrd() 所需的本地设备工作空间的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	cusolverMpSytrd() 所需的本地主机工作空间的大小（以字节为单位）。

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

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

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

---

cusolverMpStedc

cusolverStatus_t cusolverMpStedc(
        cusolverMpHandle_t handle,
        char *compz,
        int64_t N,
        void *d_d,
        void *d_e,
        void *d_Q,
        int64_t IQ,
        int64_t JQ,
        const cusolverMpMatrixDescriptor_t descrQ,
        cudaDataType_t computeType,
        void *d_work,
        size_t workspaceInBytesOnDevice,
        void *h_work,
        size_t workspaceInBytesOnHost,
        int *info)

使用分治算法计算对称三对角矩阵的所有特征值和特征向量。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
compz	主机	输入	仅计算特征值 (compz=N) 或同时计算特征值/向量 (compz=I) 的选项。目前，仅实现了 I。
N	主机	输入	方阵 sub(A) 的行数/列数。
d_d	设备	输入/输出	指向维度为 N 的数组的指针。在输入时，该数组包含三对角矩阵的对角线元素。在输出时，特征值按降序存储。
d_e	设备	输入/输出	指向维度为 N-1 的数组的指针。在输入时，该数组包含三对角矩阵的次对角线元素。在输出时，数组的内容将被破坏。
d_Q	设备	输出	指向维度为 (LLD_Q, LOCc(JQ+N-1)) 的数组的本地内存指针。在输出时，该数组包含对称对角矩阵的正交特征向量的本地元素。
IQ	主机	输入	sub(Q) 的第一行的行索引。IQ 必须是行分块维度 MB_Q 的倍数。
JQ	主机	输入	sub(A) 的第一列的列索引。JQ 必须是列分块维度 NB_Q 的倍数。
descrQ	主机	输入	与全局矩阵 Q 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
d_work	设备	输出	设备工作区，大小为 workspaceInBytesOnDevice。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作空间的大小（以字节为单位），由 cusolverMpStedc_bufferSize() 提供。
h_work	主机	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作空间的大小（以字节为单位），由 cusolverMpStedc_bufferSize() 提供。
info	设备	输出	info < 0 表示函数的第 i 个参数值不正确。

此函数要求 Q 的块大小为正方形，(MB_Q == NB_Q)。

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

三对角矩阵的数据类型	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

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

请注意，此函数使用分治算法来计算特征对。目前，当块大小不是 2 的幂时，该函数可能会失败。这是一个已知问题，我们将在稍后解决该问题。

---

cusolverMpStedc_bufferSize

cusolverStatus_t cusolverMpStedc_bufferSize(
        cusolverMpHandle_t handle,
        char *compz,
        int64_t N,
        void *d_d,
        void *d_e,
        void *d_Q,
        int64_t IQ,
        int64_t JQ,
        const cusolverMpMatrixDescriptor_t descrQ,
        cudaDataType_t computeType,
        size_t *workspaceInBytesOnDevice,
        size_t *workspaceInBytesOnHost,
        int *iwork)

计算 cusolverMpStedc() 所需的主机和设备工作缓冲区的大小（以字节为单位）。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
compz	主机	输入	仅计算特征值 (compz=N) 或同时计算特征值/向量 (compz=I) 的选项。目前，仅实现了 I。
N	主机	输入	方阵 sub(A) 的行数/列数。
d_d	设备	输入	指向维度为 N 的数组的指针。
d_e	设备	输入	指向维度为 N-1 的数组的指针。
d_Q	设备	输入	指向维度为 (LLD_Q, LOCc(JQ+N-1)) 的数组的本地内存指针。
IQ	主机	输入	sub(Q) 的第一行的行索引。IQ 必须是行分块维度 MB_Q 的倍数。
JQ	主机	输入	sub(A) 的第一列的列索引。JQ 必须是列分块维度 NB_Q 的倍数。
descrQ	主机	输入	与全局矩阵 Q 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
workspaceInBytesOnDevice	主机	输出	例程 cusolverMpStedc() 所需的本地设备工作空间的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	cusolverMpStedc() 所需的本地主机工作空间的大小（以字节为单位）。
info	设备	输出	info < 0 表示函数的第 i 个参数值不正确。

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

三对角矩阵的数据类型	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

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

---

cusolverMpOrmtr

cusolverStatus_t cusolverMpOrmtr(
        cusolverMpHandle_t handle,
        cublasSideMode_t side,
        cublasFillMode_t uplo,
        cublasOperation_t trans,
        int64_t M,
        int64_t N,
        const void *d_A,
        int64_t IA,
        int64_t JA,
        const cusolverMpMatrixDescriptor_t descrA,
        const void *d_tau,
        void *d_C,
        int64_t IC,
        int64_t JC,
        const cusolverMpMatrixDescriptor_t descrC,
        cudaDataType_t computeType,
        void *d_work,
        size_t workspaceInBytesOnDevice,
        void *h_work,
        size_t workspaceInBytesOnHost,
        int *info)

将分布式 M×N 矩阵 sub(C)（表示为 C(IC:IC+M-1, JC:JC+N-1)）乘以可以从 cusolverMpSytrd() 给出的正交矩阵 Q。

该函数可以执行以下矩阵乘积，并将结果覆盖到 sub(C) 上，对于 side 参数 CUBLAS_SIDE_LEFT 和 CUBLAS_SIDE_RIGHT。

\[\begin{split}sub(C) = op(Q) \cdot sub(C) \\ sub(C) = sub(C) \cdot op(Q)\end{split}\]

op 可以根据 trans 参数 CUBLAS_OP_N、CUBLAS_OP_T 和 CUBLAS_OP_H 转换为 \(Q\)、\(Q^T\)、\(Q^H\)。

Q 是一个正交矩阵，由 Householder 反射器的乘积构成，对于 uplo 参数 CUBLAS_FILL_MODE_UPPER 和 CUBLAS_FILL_MODE_LOWER，如下所示：

\[\begin{split}Q = H(1) H(2) ... H(nq-1) \\ Q = H(nq-1) H(nq-2) ... H(1)\end{split}\]

其中 nq 根据 CUBLAS_SIDE_LEFT 或 CUBLAS_SIDE_RIGHT 的 side 参数，为 m 或 n。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
side	主机	输入	指示 Q 从左侧还是右侧应用。
uplo	主机	输入	指示 sub(A) 的上三角或下三角部分包含 Householder 反射器。
trans	主机	输入	指示 Q 应用时是否不转置或（共轭）转置。
M	主机	输入	sub(C) 的行数。
N	主机	输入	sub(C) 的列数。
d_A	设备	输入	指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组的本地内存指针。此数组包含对角线下方的 Householder 反射器，带有 tau 向量。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	IA
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
d_tau	设备	输入	指向维度为 LOCc(JA+N-1) 的数组的本地内存指针。此数组包含 Householder 反射器的标量因子。
d_C	设备	输入/输出	指向维度为 (LLD_C, LOCc(JC+N-1)) 的数组的本地内存指针。在输入时，该数组包含 M×N 分布式矩阵 sub(C) 的本地块。在输出时，sub(C) 被 op(Q)*sub(C) 或 sub(C)*op(Q) 覆盖。
IC	主机	输入	sub(C) 的第一行的行索引。IC 必须是行分块维度 MB_C 的倍数。
JC	主机	输入	sub(C) 的第一列的列索引。JC 必须是列分块维度 NB_C 的倍数。
descrC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
d_work	设备	输出	设备工作区，大小为 workspaceInBytesOnDevice。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作空间的大小（以字节为单位），由 cusolverMpOrmtr_bufferSize() 提供。
h_work	主机	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作空间的大小（以字节为单位），由 cusolverMpOrmtr_bufferSize() 提供。
info	设备	输出	info < 0 表示函数的第 i 个参数值不正确。

此函数要求正方形块大小 (MB_A == NB_A) 以及 sub(A) 和 sub(B) 矩阵的对齐，即 (MB_A == MB_C) 和 (IA == IC)。

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

A 和 C 的数据类型	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

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

---

cusolverMpOrmtr_bufferSize

cusolverStatus_t cusolverMpOrmtr_bufferSize(
        cusolverMpHandle_t handle,
        cublasSideMode_t side,
        cublasFillMode_t uplo,
        cublasOperation_t trans,
        int64_t M,
        int64_t N,
        const void *d_A,
        int64_t IA,
        int64_t JA,
        const cusolverMpMatrixDescriptor_t descrA,
        const void *d_tau,
        void *d_C,
        int64_t IC,
        int64_t JC,
        const cusolverMpMatrixDescriptor_t descrC,
        cudaDataType_t computeType,
        size_t* workspaceInBytesOnDevice,
        size_t* workspaceInBytesOnHost)

计算 cusolverMpOrmtr() 所需的主机和设备工作缓冲区的大小（以字节为单位）。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
side	主机	输入	指示 Q 从左侧还是右侧应用。
uplo	主机	输入	指示 sub(A) 的上三角或下三角部分包含 Householder 反射器。
trans	主机	输入	指示 Q 应用时是否不转置或（共轭）转置。
M	主机	输入	sub(C) 的行数。
N	主机	输入	sub(C) 的列数。
d_A	设备	输入	指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组的本地内存指针。此数组包含对角线下方的 Householder 反射器，带有 tau 向量。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	IA
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
d_tau	设备	输入	指向维度为 LOCc(JA+N-1) 的数组的本地内存指针。此数组包含 Householder 反射器的标量因子。
d_C	设备	输入	指向维度为 (LLD_C, LOCc(JC+N-1)) 的数组的本地内存指针。在输入时，该数组包含 M×N 分布式矩阵 sub(C) 的本地块。在输出时，sub(C) 被 op(Q)*sub(C) 或 sub(C)*op(Q) 覆盖，具体取决于 side 输入 CUBLAS_SIDE_LEFT 或 CUBLAS_SIDE_RIGHT。
IC	主机	输入	sub(C) 的第一行的行索引。IC 必须是行分块维度 MB_C 的倍数。
JC	主机	输入	sub(C) 的第一列的列索引。`JC` 必须是列分块维度 NB_C 的倍数。
descrC	主机	输入	与全局矩阵 C 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
workspaceInBytesOnDevice	主机	输出	cusolverMpOrmtr() 所需的本地设备工作空间的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	cusolverMpOrmtr() 所需的本地主机工作空间的大小（以字节为单位）。

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

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

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

---

cusolverMpSyevd

cusolverStatus_t cusolverMpSyevd(
        cusolverMpHandle_t handle,
        char *jobz,
        cublasFillMode_t uplo,
        int64_t N,
        void *d_A,
        int64_t IA,
        int64_t JA,
        const cusolverMpMatrixDescriptor_t descrA,
        void *d_d,
        void *d_Z,
        int64_t IZ,
        int64_t JZ,
        const cusolverMpMatrixDescriptor_t descrZ,
        cudaDataType_t computeType,
        void *d_work,
        size_t workspaceInBytesOnDevice,
        void *h_work,
        size_t workspaceInBytesOnHost,
        int *info)

使用分治算法 cusolverMpStedc() 计算对称分布式 N×N 矩阵 sub(A) A(IA:IA+N-1, JA:JA+N-1) 的所有特征值和可选的特征向量。请注意，当块大小不是 2 的幂时，当前 cusolverMpStedc 的实现可能会失败。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
jobz	主机	输入	如果 jobz = N，则计算特征值；如果 jobz = V，则计算特征值和特征向量。
uplo	主机	输入	指示 sub(A) 的上三角或下三角部分用于计算特征解。
N	主机	输入	N
d_A	设备	输入	指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组的本地内存指针。此数组包含对称矩阵 A 的本地部分。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	IA
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
d_d	设备	输出	指向维度为全局大小 N 的数组的内存指针。在输出时，此数组包含矩阵 A 的实特征值。
d_Z	设备	输出	指向维度为 (LLD_Z, LOCc(JZ+N-1)) 的数组的本地内存指针。在输出时，该数组包含矩阵 A 的正交特征向量的本地部分。
IZ	主机	输入	sub(Z) 的第一行的行索引。IZ 必须是行分块维度 MB_Z 的倍数。
JZ	主机	输入	sub(Z) 的第一列的列索引。JZ 必须是列分块维度 NB_Z 的倍数。
descrZ	主机	输入	与全局矩阵 Z 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
d_work	设备	输出	设备工作区，大小为 workspaceInBytesOnDevice。
workspaceInBytesOnDevice	主机	输入	例程所需的本地设备工作空间的大小（以字节为单位），由 cusolverMpSyevd_bufferSize() 提供。
h_work	主机	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnHost	主机	输入	例程所需的本地主机工作空间的大小（以字节为单位），由 cusolverMpSyevd_bufferSize() 提供。
info	设备	输出	info < 0 表示函数的第 i 个参数值不正确。

此函数要求正方形块大小 (MB_A == NB_A) 以及 sub(A) 和 sub(B) 矩阵的对齐，即 (MB_A == MB_Z) 和 (IZ == IZ)。

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

A 和 C 的数据类型	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

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

---

cusolverMpSyevd_bufferSize

cusolverStatus_t cusolverMpSyevd_bufferSize(
        cusolverMpHandle_t handle,
        char *jobz,
        cublasFillMode_t uplo,
        int64_t N,
        void *d_A,
        int64_t IA,
        int64_t JA,
        const cusolverMpMatrixDescriptor_t descrA,
        void *d_d,
        void *d_Z,
        int64_t IZ,
        int64_t JZ,
        const cusolverMpMatrixDescriptor_t descrZ,
        cudaDataType_t computeType,
        size_t *workspaceInBytesOnDevice,
        size_t *workspaceInBytesOnHost)

计算 cusolverMpSyevd() 所需的主机和设备工作缓冲区的大小（以字节为单位）。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
jobz	主机	输入	如果 jobz = N，则计算特征值；如果 jobz = V，则计算特征值和特征向量。
uplo	主机	输入	指示 sub(A) 的上三角或下三角部分用于计算特征解。
N	主机	输入	N
d_A	设备	输入	指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组的本地内存指针。此数组包含对称矩阵 A 的本地部分。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	IA
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
d_d	设备	输入	指向维度为全局大小 N 的数组的内存指针。在输出时，此数组包含矩阵 A 的实特征值。
d_Z	设备	输入	指向维度为 (LLD_Z, LOCc(JZ+N-1)) 的数组的本地内存指针。在输出时，该数组包含矩阵 A 的正交特征向量的本地部分。
IZ	主机	输入	sub(Z) 的第一行的行索引。IZ 必须是行分块维度 MB_Z 的倍数。
JZ	主机	输入	sub(Z) 的第一列的列索引。JZ 必须是列分块维度 NB_Z 的倍数。
descrZ	主机	输入	与全局矩阵 Z 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
workspaceInBytesOnDevice	主机	输出	cusolverMpSyevd() 所需的本地设备工作空间的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	cusolverMpSyevd() 所需的本地主机工作空间的大小（以字节为单位）。

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

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

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

---

cusolverMpSygst

cusolverStatus_t cusolverMpSygst(
        cusolverMpHandle_t handle,
        cusolverEigType_t ibtype,
        cublasFillMode_t uplo,
        int64_t N,
        void *d_A,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        const void *d_B,
        int64_t IB,
        int64_t JB,
        cusolverMpMatrixDescriptor_t descrB,
        cudaDataType_t computeType,
        void *d_work,
        size_t workspaceInBytesOnDevice,
        void *h_work,
        size_t workspaceInBytesOnHost,
        int *info)

将埃尔米特-正定广义特征值问题简化为标准形式。分别将 sub(A) 和 sub(B) 表示为 A(IA:IA+N-1, JA:JA+N-1) 和 B(IB:IB+N-1, JB:JB+N-1)，该例程考虑以下情况。

• ibtype = CUSOLVER_EIG_TYPE_1：问题是 sub(A)*x = lambda*sub(B)*x，sub(A) 被 inv(L)*sub(A)*inv(L^H) 或 inv(U^H)*sub(A)*inv(U) 覆盖。

• ibtype = CUSOLVER_EIG_TYPE_2 or 3：问题是 sub(A)*sub(B)*x = lambda*x 或 sub(B)*sub(A)*x = lambda*x，sub(A) 被 L^H*sub(A)*L 或 U*sub(A)*U^H 覆盖。

sub(B) 包括先前由 cusolverMpPotrf() 计算的下或上 Cholesky 因子。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
ibtype	主机	输入	指示特征值问题类型 sub(A)*x=(lambda)*sub(B)*x、sub(A)*sub(B)x=(lambda)*x 或 sub(B)*sub(A)*x=(lambda)*x。
uplo	主机	输入	指示 sub(A) 和 sub(B) 的下三角 CUBLAS_FILL_MODE_LOWER 或上三角 CUBLAS_FILL_MODE_UPPER 用于计算特征解。
N	主机	输入	sub(A) 和 sub(B) 的行数和列数。
d_A	设备	输入/输出	指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组的本地内存指针。此数组包含对称矩阵 A 的本地部分。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	sub(A) 的第一列的列索引。JA 必须是列分块维度 NB_A 的倍数。
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
d_B	设备	输入	指向维度为 (LLD_B, LOCc(JB+N-1)) 的数组的本地内存指针。此数组包含对称矩阵 B 的本地部分。
IB	主机	输入	sub(B) 的第一行的行索引。IB 必须是行分块维度 MB_B 的倍数。
JB	主机	输入	sub(B) 的第一列的列索引。JB 必须是列分块维度 NB_B 的倍数。
descrB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
d_work	设备	输出	设备工作区，大小为 workspaceInBytesOnDevice。
workspaceInBytesOnDevice	主机	输入	cusolverMpSygst() 所需的本地设备工作空间的大小（以字节为单位）。
h_work	主机	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnHost	主机	输入	cusolverMpSygst() 所需的本地主机工作空间的大小（以字节为单位）。
info	设备	输出	info < 0 表示函数的第 i 个参数值不正确。

该例程需要一些对齐属性

• 矩阵 A 和 B 使用相同的正方形块大小 (MB == NB)。

• A 和 B 的起始行和列彼此对齐，即 (IA == IB) 和 (JA == JB。

请注意，当前实现支持 ibtype = CUSOLVER_EIG_TYPE_1、uplo = CUBLAS_FILL_MODE_LOWER 的输入。

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

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

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

---

cusolverMpSygst_bufferSize

cusolverStatus_t cusolverMpSygst_bufferSize(
        cusolverMpHandle_t handle,
        cusolverEigType_t ibtype,
        cublasFillMode_t uplo,
        int64_t N,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        int64_t IB,
        int64_t JB,
        cusolverMpMatrixDescriptor_t descrB,
        cudaDataType_t computeType,
        size_t *workspaceInBytesOnDevice,
        size_t *workspaceInBytesOnHost)

计算 cusolverMpSygst() 所需的主机和设备工作缓冲区的大小（以字节为单位）。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
ibtype	主机	输入	指示特征值问题类型 sub(A)*x=(lambda)*sub(B)*x、sub(A)*sub(B)x=(lambda)*x 或 sub(B)*sub(A)*x=(lambda)*x。
uplo	主机	输入	指示 sub(A) 和 sub(B) 的下三角 CUBLAS_FILL_MODE_LOWER 或上三角 CUBLAS_FILL_MODE_UPPER 用于计算特征解。
N	主机	输入	sub(A) 和 sub(B) 的行数和列数。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	sub(A) 的第一列的列索引。JA 必须是列分块维度 NB_A 的倍数。
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
IB	主机	输入	sub(B) 的第一行的行索引。IB 必须是行分块维度 MB_B 的倍数。
JB	主机	输入	sub(B) 的第一列的列索引。JB 必须是列分块维度 NB_B 的倍数。
descrB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
workspaceInBytesOnDevice	主机	输出	cusolverMpSygst() 所需的本地设备工作空间的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	cusolverMpSygst() 所需的本地主机工作空间的大小（以字节为单位）。

该例程需要一些对齐属性

• 矩阵 A 和 B 使用相同的正方形块大小 (MB == NB)。

• A 和 B 的起始行和列彼此对齐，即 (IA == IB) 和 (JA == JB。

请注意，当前实现支持 ibtype = CUSOLVER_EIG_TYPE_1、uplo = CUBLAS_FILL_MODE_LOWER 的输入。

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

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

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

---

cusolverMpSygvd

cusolverStatus_t cusolverMpSygvd(
        cusolverMpHandle_t handle,
        cusolverEigType_t ibtype,
        cusolverEigMode_t jobz,
        cublasFillMode_t uplo,
        int64_t N,
        void *d_A,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        void *d_B,
        int64_t IB,
        int64_t JB,
        cusolverMpMatrixDescriptor_t descrB,
        void *d_d,
        void *d_Z,
        int64_t IZ,
        int64_t JZ,
        cusolverMpMatrixDescriptor_t descrZ,
        cudaDataType_t computeType,
        void *d_work,
        size_t workspaceInBytesOnDevice,
        void *h_work,
        size_t workspaceInBytesOnHost,
        int *info)

使用 cusolverMpSyevd() 计算埃尔米特-正定广义特征值问题。分别将 sub(A) 和 sub(B) 表示为 A(IA:IA+N-1, JA:JA+N-1) 和 B(IB:IB+N-1, JB:JB+N-1)，该例程考虑以下情况。

• ibtype = CUSOLVER_EIG_TYPE_1：问题是 sub(A)*x = lambda*sub(B)*x。

• ibtype = CUSOLVER_EIG_TYPE_2：问题是 sub(A)*sub(B)*x = lambda*x。

• ibtype = CUSOLVER_EIG_TYPE_3：问题是 sub(B)*sub(A)*x = lambda*x。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
ibtype	主机	输入	指示特征值问题类型 sub(A)*x=(lambda)*sub(B)*x、sub(A)*sub(B)x=(lambda)*x 或 sub(B)*sub(A)*x=(lambda)*x。
jobz	主机	输入	指示例程是仅计算特征值 CUSOLVER_EIG_MODE_NOVECTOR 还是也包括特征向量 CUSOLVER_EIG_MODE_VECTOR。
uplo	主机	输入	指示 sub(A) 和 sub(B) 的下三角 CUBLAS_FILL_MODE_LOWER 或上三角 CUBLAS_FILL_MODE_UPPER 用于计算特征解。
N	主机	输入	sub(A) 和 sub(B) 的行数和列数。
d_A	设备	输入/输出	指向本地内存的指针，该内存指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。此数组包含对称矩阵 A 的局部部分，并将被标准特征值问题覆盖。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	sub(A) 的第一列的列索引。JA 必须是列分块维度 NB_A 的倍数。
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
d_B	设备	输入/输出	指向本地内存的指针，该内存指向维度为 (LLD_B, LOCc(JB+N-1)) 的数组。此数组包含对称矩阵 B 的局部部分，并将被 Cholesky 因子覆盖。
IB	主机	输入	sub(B) 的第一行的行索引。IB 必须是行分块维度 MB_B 的倍数。
JB	主机	输入	sub(B) 的第一列的列索引。JB 必须是列分块维度 NB_B 的倍数。
descrB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
d_d	设备	输出	指向维度为全局大小 N 的数组的内存指针。在输出时，此数组包含矩阵 A 的实特征值。
d_Z	设备	输出	指向维度为 (LLD_Z, LOCc(JZ+N-1)) 的数组的本地内存指针。在输出时，该数组包含矩阵 A 的正交特征向量的本地部分。
IZ	主机	输入	sub(Z) 的第一行的行索引。IZ 必须是行分块维度 MB_Z 的倍数。
JZ	主机	输入	sub(Z) 的第一列的列索引。JZ 必须是列分块维度 NB_Z 的倍数。
descrZ	主机	输入	与全局矩阵 Z 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
d_work	设备	输出	设备工作区，大小为 workspaceInBytesOnDevice。
workspaceInBytesOnDevice	主机	输出	cusolverMpSygvd() 所需的本地设备工作空间的大小（以字节为单位）。
h_work	主机	输出	主机工作区，大小为 workspaceInBytesOnHost。
workspaceInBytesOnHost	主机	输出	cusolverMpSygvd() 所需的本地主机工作空间的大小（以字节为单位）。
info	设备	输出	info < 0 表示函数的第 i 个参数值不正确。

该例程需要一些对齐属性

• 矩阵 A、B 和 Z 使用相同的正方形分块大小 (MB == NB)。

• A、B 和 Z 的起始行和列彼此对齐，即 (IA == IB == IZ) 和 (JA == JB == JZ。

请注意，当前实现支持 ibtype = CUSOLVER_EIG_TYPE_1、jobz = CUSOLVER_EIG_MODE_VECTOR、uplo = CUBLAS_FILL_MODE_LOWER 的输入。

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

A 和 C 的数据类型	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

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

---

cusolverMpSygvd_bufferSize

cusolverStatus_t cusolverMpSygvd_bufferSize(
        cusolverMpHandle_t handle,
        cusolverEigType_t ibtype,
        cusolverEigMode_t jobz,
        cublasFillMode_t uplo,
        int64_t N,
        int64_t IA,
        int64_t JA,
        cusolverMpMatrixDescriptor_t descrA,
        int64_t IB,
        int64_t JB,
        cusolverMpMatrixDescriptor_t descrB,
        int64_t IZ,
        int64_t JZ,
        cusolverMpMatrixDescriptor_t descrZ,
        cudaDataType_t computeType,
        size_t *workspaceInBytesOnDevice,
        size_t *workspaceInBytesOnHost)

计算 cusolverMpSygvd() 所需的主机和设备工作缓冲区的大小（以字节为单位）。

参数	内存	输入/输出	描述
handle	主机	输入	cuSOLVERMp 库句柄。
ibtype	主机	输入	指示特征值问题类型 sub(A)*x=(lambda)*sub(B)*x、sub(A)*sub(B)x=(lambda)*x 或 sub(B)*sub(A)*x=(lambda)*x。
jobz	主机	输入	指示例程是仅计算特征值 CUSOLVER_EIG_MODE_NOVECTOR 还是也包括特征向量 CUSOLVER_EIG_MODE_VECTOR。
uplo	主机	输入	指示 sub(A) 和 sub(B) 的下三角 CUBLAS_FILL_MODE_LOWER 或上三角 CUBLAS_FILL_MODE_UPPER 用于计算特征解。
N	主机	输入	sub(A) 和 sub(B) 的行数和列数。
IA	主机	输入	指向本地内存的指针，指向维度为 (LLD_A, LOCc(JA+N-1)) 的数组。在输入时，此数组包含 N×N 分布式矩阵 sub(A) 的本地部分。在输出时，此数组包含 A 的 L 或 U 因子，具体取决于 uplo 的值。
JA	主机	输入	sub(A) 的第一列的列索引。JA 必须是列分块维度 NB_A 的倍数。
descrA	主机	输入	sub(A) 的第一行的行索引。IA 必须是行块维度 MB_A 的倍数。
IB	主机	输入	sub(B) 的第一行的行索引。IB 必须是行分块维度 MB_B 的倍数。
JB	主机	输入	sub(B) 的第一列的列索引。JB 必须是列分块维度 NB_B 的倍数。
descrB	主机	输入	与全局矩阵 B 关联的矩阵描述符。
IZ	主机	输入	sub(Z) 的第一行的行索引。IZ 必须是行分块维度 MB_Z 的倍数。
JZ	主机	输入	sub(Z) 的第一列的列索引。JZ 必须是列分块维度 NB_Z 的倍数。
descrZ	主机	输入	与全局矩阵 Z 关联的矩阵描述符。
computeType	主机	输入	用于计算的数据类型。有关支持的组合，请参见下表。
workspaceInBytesOnDevice	主机	输出	cusolverMpSygvd() 所需的本地设备工作空间的大小（以字节为单位）。
workspaceInBytesOnHost	主机	输出	cusolverMpSygvd() 所需的本地主机工作空间的大小（以字节为单位）。

该例程需要一些对齐属性

• 矩阵 A、B 和 Z 使用相同的正方形分块大小 (MB == NB)。

• A、B 和 Z 的起始行和列彼此对齐，即 (IA == IB == IZ) 和 (JA == JB == JZ。

请注意，当前实现支持 ibtype = CUSOLVER_EIG_TYPE_1、jobz = CUSOLVER_EIG_MODE_VECTOR、uplo = CUBLAS_FILL_MODE_LOWER 的输入。

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

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

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