8. mcSPARSE 2 级函数参考
这一章介绍了在稀疏矩阵和稠密向量之间执行相关操作的稀疏线性代数函数。
在求解稀疏三角线性系统的问题时，通常会分为两个阶段。
首先，在分析阶段，通过调用适当的 csrsv2_analysis() 函数来分析稀疏三角矩阵，以确定其元素之间的依赖关系。
该分析过程针对给定矩阵的稀疏模式和特定的 mcsparseOperation_t 函数类型。 分析阶段的信息会存储在提前使用 mcsparseCreateCsrsv2Info() 函数初始化的 csrsv2Info_t 类型的参数中。
其次，在求解阶段，通过调用适当的 csrsv2Info_t 函数，使用存储在 csrsv2Info_t 参数中的信息来求解给定的稀疏三角线性系统。
可以每次使用不同的右侧表达式来多次执行求解阶段的操作，但是分析阶段只能执行一次。
当需要逐个求解一组系数矩阵保持不变但是拥有不同右侧表达式的稀疏三角线性系统时，这钟方法是非常有用的。
最后，一旦所有求解操作完成， csrsv2Info_t 参数指向的不透明数据结构将通过调用 mcsparseDestroyCsrsv2Info() 函数释放。
8.1. mcsparse<t>bsrmv()
mcsparseStatus_t
mcsparseSbsrmv(mcsparseHandle_t handle,
mcsparseDirection_t dir,
mcsparseOperation_t trans,
int mb,
int nb,
int nnzb,
const float* alpha,
const mcsparseMatDescr_t descr,
const float* bsrVal,
const int* bsrRowPtr,
const int* bsrColInd,
int blockDim,
const float* x,
const float* beta,
float* y)
mcsparseStatus_t
mcsparseDbsrmv(mcsparseHandle_t handle,
mcsparseDirection_t dir,
mcsparseOperation_t trans,
int mb,
int nb,
int nnzb,
const double* alpha,
const mcsparseMatDescr_t descr,
const double* bsrVal,
const int* bsrRowPtr,
const int* bsrColInd,
int blockDim,
const double* x,
const double* beta,
double* y)
mcsparseStatus_t
mcsparseCbsrmv(mcsparseHandle_t handle,
mcsparseDirection_t dir,
mcsparseOperation_t trans,
int mb,
int nb,
int nnzb,
const mcComplex* alpha,
const mcsparseMatDescr_t descr,
const mcComplex* bsrVal,
const int* bsrRowPtr,
const int* bsrColInd,
int blockDim,
const mcComplex* x,
const mcComplex* beta,
mcComplex* y)
mcsparseStatus_t
mcsparseZbsrmv(mcsparseHandle_t handle,
mcsparseDirection_t dir,
mcsparseOperation_t trans,
int mb,
int nb,
int nnzb,
const mcDoubleComplex* alpha,
const mcsparseMatDescr_t descr,
const mcDoubleComplex* bsrVal,
const int* bsrRowPtr,
const int* bsrColInd,
int blockDim,
const mcDoubleComplex* x,
const mcDoubleComplex* beta,
mcDoubleComplex* y)
此函数执行矩阵-向量操作。
bsrmv() 具有以下特性：
该例程不需要额外的存储空间。
该例程支持异步执行。
bsrmv() 的几个注意事项：
仅支持
blockDim > 1仅支持
MCSPARSE_OPERATION_NON_TRANSPOSE仅支持
MCSPARSE_MATRIX_TYPE_GENERAL
例如，假设用户有一个CSR格式的矩阵，并希望尝试使用 bsrmv() 函数。下面的代码说明了如何在单精度计算中使用 csr2bsr() 转换和 bsrmv() 乘法。
// 假设A是一个用CSR格式表示的m x n的稀疏矩阵。 // hx是一个大小为n的主机向量，hy是一个大小为m的主机向量。 // m和n不是blockDim的倍数。 // 步骤1：将CSR转换为列优先的BSR格式 int base, nnz; int nnzb; mcsparseDirection_t dirA = MCSPARSE_DIRECTION_COLUMN; int mb = (m + blockDim-1)/blockDim; int nb = (n + blockDim-1)/blockDim; mcMalloc((void**)&bsrRowPtrC, sizeof(int) *(mb+1)); mcsparseXcsr2bsrNnz(handle, dirA, m, n, descrA, csrRowPtrA, csrColIndA, blockDim, descrC, bsrRowPtrC, &nnzb); mcMalloc((void**)&bsrColIndC, sizeof(int)*nnzb); mcMalloc((void**)&bsrValC, sizeof(float)*(blockDim*blockDim)*nnzb); mcsparseScsr2bsr(handle, dirA, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, blockDim, descrC, bsrValC, bsrRowPtrC, bsrColIndC); // 第二步，为bsrmv分配足够大的向量x和向量y mcMalloc((void**)&x, sizeof(float)*(nb*blockDim)); mcMalloc((void**)&y, sizeof(float)*(mb*blockDim)); mcMemcpy(x, hx, sizeof(float)*n, mcMemcpyHostToDevice); mcMemcpy(y, hy, sizeof(float)*m, mcMemcpyHostToDevice); // 第三步：执行 bsrmv mcsparseSbsrmv(handle, dirA, transA, mb, nb, nnzb, &alpha, descrC, bsrValC, bsrRowPtrC, bsrColIndC, blockDim, x, &beta, y);输入
handle处理mcSPARSE库上下文的句柄。
dir块的存储格式，可以是
MCSPARSE_DIRECTION_ROW或MCSPARSE_DIRECTION_COLUMN。
trans仅支持
MCSPARSE_OPERATION_NON_TRANSPOSE
mb矩阵的块行数
nb矩阵的块列数。
nnzb矩阵的非零块数。
alpha用于乘法运算的<type> 标量。
descr矩阵的描述符。支持的矩阵类型有
MCSPARSE_MATRIX_TYPE_GENERAL此外，支持的索引基准有MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。
bsrVal存储矩阵非零块的 <type> 数组。
bsrRowPtr包含每个块行的起始位置和最后一个块行 结束位置后移一位的整数数组，数组长度 为
mb。
bsrColInd存储了矩阵非零块的列索引的整数数组
blockDim稀疏矩阵的块维度，大于零。
x指向<type> 元素的向量。
beta<type> 标量用于乘法运算。如果
beta为零，y可以不是有效的 输入。
y指向<type> 元素的向量。
输出
y更新后的<type>向量。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
8.2. mcsparse<t>bsrxmv()
mcsparseStatus_t
mcsparseSbsrxmv(mcsparseHandle_t handle,
mcsparseDirection_t dir,
mcsparseOperation_t trans,
int sizeOfMask,
int mb,
int nb,
int nnzb,
const float* alpha,
const mcsparseMatDescr_t descr,
const float* bsrVal,
const int* bsrMaskPtr,
const int* bsrRowPtr,
const int* bsrEndPtr,
const int* bsrColInd,
int blockDim,
const float* x,
const float* beta,
float* y)
mcsparseStatus_t
mcsparseDbsrxmv(mcsparseHandle_t handle,
mcsparseDirection_t dir,
mcsparseOperation_t trans,
int sizeOfMask,
int mb,
int nb,
int nnzb,
const double* alpha,
const mcsparseMatDescr_t descr,
const double* bsrVal,
const int* bsrMaskPtr,
const int* bsrRowPtr,
const int* bsrEndPtr,
const int* bsrColInd,
int blockDim,
const double* x,
const double* beta,
double* y)
mcsparseStatus_t
mcsparseCbsrxmv(mcsparseHandle_t handle,
mcsparseDirection_t dir,
mcsparseOperation_t trans,
int sizeOfMask,
int mb,
int nb,
int nnzb,
const mcComplex* alpha,
const mcsparseMatDescr_t descr,
const mcComplex* bsrVal,
const int* bsrMaskPtr,
const int* bsrRowPtr,
const int* bsrEndPtr,
const int* bsrColInd,
int blockDim,
const mcComplex* x,
const mcComplex* beta,
mcComplex* y)
mcsparseStatus_t
mcsparseZbsrxmv(mcsparseHandle_t handle,
mcsparseDirection_t dir,
mcsparseOperation_t trans,
int sizeOfMask,
int mb,
int nb,
int nnzb,
const mcDoubleComplex* alpha,
const mcsparseMatDescr_t descr,
const mcDoubleComplex* bsrVal,
const int* bsrMaskPtr,
const int* bsrRowPtr,
const int* bsrEndPtr,
const int* bsrColInd,
int blockDim,
const mcDoubleComplex* x,
const mcDoubleComplex* beta,
mcDoubleComplex* y)
此函数执行了一个 bsrmv 操作和一个掩码操作。
bsrmv() 具有以下特性：
该例程不需要额外的存储空间。
该例程支持异步执行。
bsrmv() 的几个注意事项：
仅支持
blockDim > 1。仅支持
MCSPARSE_OPERATION_NON_TRANSPOSE和MCSPARSE_MATRIX_TYPE_GENERAL。参数
bsrMaskPtr，bsrRowPtr，bsrEndPtr与bsrColInd与基准索引一致，可以是基于一的基准索引或基于零的基准索引。上面的示例是基数为一的基准索引。输入
handle处理mcSPARSE库上下文的句柄。
dir块的存储格式，可以是
MCSPARSE_DIRECTION_ROW或MCSPARSE_DIRECTION_COLUMN。trans仅支持
MCSPARSE_OPERATION_NON_TRANSPOSEsizeOfMasky中被更新的块行的数量。
mb矩阵的块行数。
nb矩阵的块列数。
nnzb矩阵的非零块数。
alpha用于乘法运算的<type> 标量。
descr矩阵的描述符。支持的矩阵类型有
MCSPARSE_MATRIX_TYPE_GENERAL此外，支持的索引基准有MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。bsrVal矩阵的
nnz个非零块的 <type> 数组。bsrMaskPtr存储与更新的块行相对应索引的长度为
sizeOfMask整数数组。bsrRowPtr包含每个块行的起始位置的整数数组，数 组长度为
mb。bsrEndPtr包含最后一个块行结束位置后移一位的 整数数组，数组长度为
mb。bsrColInd存储了矩阵非零块
nnzb个列索引信 息的整数数组。blockDim稀疏矩阵的块维度，大于零。
x指向元素的<type>向量。
beta<type>标量用于乘法运算。如果
beta为零，y可以不是有效的 输入。y元素的<type>向量。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
8.3. mcsparse<t>bsrsv2_bufferSize()
mcsparseStatus_t
mcsparseSbsrsv2_bufferSize(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
mcsparseOperation_t transA,
int mb,
int nnzb,
const mcsparseMatDescr_t descrA,
float* bsrValA,
const int* bsrRowPtrA,
const int* bsrColIndA,
int blockDim,
bsrsv2Info_t info,
int* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseDbsrsv2_bufferSize(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
mcsparseOperation_t transA,
int mb,
int nnzb,
const mcsparseMatDescr_t descrA,
double* bsrValA,
const int* bsrRowPtrA,
const int* bsrColIndA,
int blockDim,
bsrsv2Info_t info,
int* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseCbsrsv2_bufferSize(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
mcsparseOperation_t transA,
int mb,
int nnzb,
const mcsparseMatDescr_t descrA,
mcComplex* bsrValA,
const int* bsrRowPtrA,
const int* bsrColIndA,
int blockDim,
bsrsv2Info_t info,
int* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseZbsrsv2_bufferSize(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
mcsparseOperation_t transA,
int mb,
int nnzb,
const mcsparseMatDescr_t descrA,
mcDoubleComplex* bsrValA,
const int* bsrRowPtrA,
const int* bsrColIndA,
int blockDim,
bsrsv2Info_t info,
int* pBufferSizeInBytes)
此函数返回在新稀疏三角线性系统 bsrsv2 中使用的缓冲区大小。
虽然参数 trans 和矩阵 A 的上(下)三角部分有六种组合，但是 bsrsv2_bufferSize() 仅会返回这些组合中最大缓冲区的大小。
缓冲区的大小取决于维度 mb， blockDim 以及矩阵的非零块数 nnzb。
如果用户更改了矩阵，则必须再次调用 bsrsv2_bufferSize() 来获取正确的缓冲区大小；否则可能会导致段错误。
该例程不需要额外的存储空间。
该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
dir块的存储格式，可以是
MCSPARSE_DIRECTION_ROW或MCSPARSE_DIRECTION_COLUMN。transAop(A)操作
mb矩阵
A的块行数。nnzb矩阵
A中非零块的数量。descrA矩阵
A的描述符。支持的矩阵类 型有MCSPARSE_MATRIX_TYPE_GENERAL此外，支持的索引基准有MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。bsrValA存储矩阵
Annzb个非零 块的<type>数组。bsrRowPtrA包含每个块行的起始位置和最后一个块 行结束位置后移一位的整数数组，数组 长度为
mb。bsrColIndA存储了矩阵
A中非零块nnzb个列索引信息的整数数组。blockDim稀疏矩阵
A的块维度，必须大于 零。输出
info根据不同的算法记录的内部状态。
pBufferSizeInBytes在
bsrsv2_analysis()和bsrsv2_solve()函数中使用的缓冲区的字节 数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
8.4. mcsparse<t>bsrsv2_analysis()
mcsparseStatus_t
mcsparseSbsrsv2_analysis(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
mcsparseOperation_t transA,
int mb,
int nnzb,
const mcsparseMatDescr_t descrA,
const float* bsrValA,
const int* bsrRowPtrA,
const int* bsrColIndA,
int blockDim,
bsrsv2Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseDbsrsv2_analysis(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
mcsparseOperation_t transA,
int mb,
int nnzb,
const mcsparseMatDescr_t descrA,
const double* bsrValA,
const int* bsrRowPtrA,
const int* bsrColIndA,
int blockDim,
bsrsv2Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseDbsrsv2_analysis(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
mcsparseOperation_t transA,
int mb,
int nnzb,
const mcsparseMatDescr_t descrA,
const mcComplex* bsrValA,
const int* bsrRowPtrA,
const int* bsrColIndA,
int blockDim,
bsrsv2Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseZbsrsv2_analysis(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
mcsparseOperation_t transA,
int mb,
int nnzb,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* bsrValA,
const int* bsrRowPtrA,
const int* bsrColIndA,
int blockDim,
bsrsv2Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
此函数执行新稀疏三角线性系统 bsrsv2 的分析阶段。
BSR格式的块大小为 blockDim*blockDim，根据参数 dirA 的设置可以按列主序或行主序存储。参数 dirA 可以为 MCSPARSE_DIRECTION_COLUMN 或 MCSPARSE_DIRECTION_ROW。
矩阵类型必须是 MCSPARSE_MATRIX_TYPE_GENERAL，而填充模式和对角线类型则没有要求。
此函数预计只会在给定矩阵和特定操作类型下执行一次。
此函数需要由 bsrsv2_bufferSize() 返回缓冲区大小。 pBuffer 的地址必须是128字节的倍数，
如果不是，将返回 MCSPARSE_STATUS_INVALID_VALUE 参数。
函数 bsrsv2_analysis() 报告了存储在不透明结构 info 中的一个结构零与计算级别信息。
级别信息可以提高三角求解器的并行效率。
然而， bsrsv2_solve() 可以在没有级别信息的情况下完成求解。
要禁用级别信息，用户需要将三角求解器的策略指定为 MCSPARSE_SOLVE_POLICY_NO_LEVEL。
函数 bsrsv2_analysis() 总是报告第一个结构零，即使参数 policy 为 MCSPARSE_SOLVE_POLICY_NO_LEVEL。
指定为 MCSPARSE_DIAG_TYPE_UNIT 时，即使某些 j 的块 A(j,j) 缺失，也不会报告任何结构零。
用户需要调用 mcsparseXbsrsv2_zeroPivot() 来确定结构零的位置。
如果 bsrsv2_analysis() 报告了一个结构零，用户可以选择是否调用 bsrsv2_solve()。在这种情况下，用户仍然可以调用 bsrsv2_solve()，此函数将在与结构零相同的位置返回一个数值零。
然而，结果 x 是没有意义的。
此函数需要内部分配的临时额外存储空间。
如果流式有序内存分配器是可用的话，该例程将支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
dir块的存储格式，可以是
MCSPARSE_DIRECTION_ROW或MCSPARSE_DIRECTION_COLUMN。transAop(A)操作
mb矩阵
A的块行数。nnzb矩阵
A中非零块的数量。descrA矩阵
A的描述符。支持的矩阵类型有MCSPARSE_MATRIX_TYPE_GENERAL此外，支持的基准索引有MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。bsrValA存储矩阵
Annzb个非零块的 <type>数组。bsrRowPtrA包含每个块行的起始位置和最后一个块行结 束位置后移一位的整数数组，数组长度为
mb。bsrColIndA存储了矩阵
A中非零块nnzb个 列索引信息的整数数组。blockDim稀疏矩阵
A的块维度，大于零infomcsparseCreateBsrsv2Info()初始化的结构。policy支持的策略有
MCSPARSE_SOLVE_POLICY_NO_LEVEL和MCSPARSE_SOLVE_POLICY_USE_LEVEL。pBuffer用户分配的缓冲区，其大小由
bsrsv2_bufferSize()返回。输出
info将在分析阶段收集的信息填充到结构中 (应该在传递给求解阶段时保持不变)。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
8.5. mcsparse<t>bsrsv2_solve()
mcsparseStatus_t
mcsparseSbsrsv2_solve(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
mcsparseOperation_t transA,
int mb,
int nnzb,
const float* alpha,
const mcsparseMatDescr_t descrA,
const float* bsrValA,
const int* bsrRowPtrA,
const int* bsrColIndA,
int blockDim,
bsrsv2Info_t info,
const float* x,
float* y,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseDbsrsv2_solve(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
mcsparseOperation_t transA,
int mb,
int nnzb,
const double* alpha,
const mcsparseMatDescr_t descrA,
const double* bsrValA,
const int* bsrRowPtrA,
const int* bsrColIndA,
int blockDim,
bsrsv2Info_t info,
const double* x,
double* y,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseCbsrsv2_solve(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
mcsparseOperation_t transA,
int mb,
int nnzb,
const mcComplex* alpha,
const mcsparseMatDescr_t descrA,
const mcComplex* bsrValA,
const int* bsrRowPtrA,
const int* bsrColIndA,
int blockDim,
bsrsv2Info_t info,
const mcComplex* x,
mcComplex* y,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseZbsrsv2_solve(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
mcsparseOperation_t transA,
int mb,
int nnzb,
const mcDoubleComplex* alpha,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* bsrValA,
const int* bsrRowPtrA,
const int* bsrColIndA,
int blockDim,
bsrsv2Info_t info,
const mcDoubleComplex* x,
mcDoubleComplex* y,
mcsparseSolvePolicy_t policy,
void* pBuffer)
此函数执行新稀疏三角线性系统 bsrsv2 的求解阶段。
BSR格式中的块大小为 blockDim*blockDim，并根据参数 dirA 确定是按列主序(column-major)还是按行主序(row-major)存储。 dirA 参数的取值可以是 MCSPARSE_DIRECTION_COLUMN 或 MCSPARSE_DIRECTION_ROW。
矩阵类型必须为 MCSPARSE_MATRIX_TYPE_GENERAL，而填充模式和对角线类型则没有要求。函数 bsrsv02_solve() 可以支持任意的 blockDim 大小。
此函数预计会在给定矩阵和特定操作类型下多次执行。
此函数需要由 bsrsv2_bufferSize() 返回缓冲区大小。 pBuffer 的地址必须是128字节的倍数，
如果不是，将返回 MCSPARSE_STATUS_INVALID_VALUE 参数。
尽管 bsrsv2_solve() 可以在没有级别信息的情况下执行，用户仍然需要注意一致性。
如果使用策略 MCSPARSE_SOLVE_POLICY_USE_LEVEL 来调用 bsrsv2_analysis()，则使不使用级别都能运行 bsrsv2_solve()。
另外，如果使用 MCSPARSE_SOLVE_POLICY_NO_LEVEL 调用 bsrsv2_analysis()，那么 bsrsv2_solve() 只能接受 MCSPARSE_SOLVE_POLICY_NO_LEVEL 来运行；
否则，将返回 MCSPARSE_STATUS_INVALID_VALUE。
级别信息可能不仅不会提高性能，还可能会花费额外的时间进行分析。
例如，三对角矩阵没有并行性。
在这种情况下， MCSPARSE_SOLVE_POLICY_NO_LEVEL 比 MCSPARSE_SOLVE_POLICY_USE_LEVEL 性能更好。
如果用户有一个迭代求解器，最好的方法是使用 MCSPARSE_SOLVE_POLICY_USE_LEVEL 进行一次 bsrsv2_analysis()。
然后，在第一次运行中使用 MCSPARSE_SOLVE_POLICY_NO_LEVEL 进行 bsrsv2_solve()，在第二次运行中使用 MCSPARSE_SOLVE_POLICY_USE_LEVEL，然后选择最快的方法来执行剩余的迭代。
函数 bsrsv02_solve() 的行为与 csrsv02_solve() 相同。
也就是说， bsr2csr(bsrsv02(A)) = csrsv02(bsr2csr(A))。
csrsv02_solve() 中的数值零意味着存在某个零元素 A(j,j)。
bsrsv02_solve() 中的数值零意味着存在某个不可逆的块 A(j,j)。
函数 bsrsv2_solve() 会报告第一个数值零，包括结构零。
指定 MCSPARSE_DIAG_TYPE_UNIT 时，即使 A(j,j) 对于某些 j 不可逆，也不会报告数值零。
用户需要调用 mcsparseXbsrsv2_zeroPivot() 来了解数值零的位置。
如果 pBuffer != NULL，此函数将支持以下属性。
该例程不需要额外的存储空间。
该例程支持异步执行。
例如，假设L是一个具有单位对角线的下三角矩阵，那么以下代码可以通过级别信息求解有关 L*y=x 的问题。
// 假设L是由BSR格式表示的m x m稀疏矩阵。 // 块行/列的数量为mb， // 非零块的数量为nnzb。 // L是下三角矩阵，并且具有单位对角线。 // 假设： // - 矩阵L的维度为m(=mb*blockDim)， // - 矩阵L有nnz(=nnzb*blockDim*blockDim) 个非零元素， // - 句柄已经通过mcsparseCreate()函数创建， // - (d_bsrRowPtr, d_bsrColInd, d_bsrVal) 是存储在设备内存中的L的BSR格式， // - d_x是存储在设备内存中的右侧向量， // - d_y是存储在设备内存中的解向量， // - d_x和d_y的大小为m。 mcsparseMatDescr_t descr = 0; bsrsv2Info_t info = 0; int pBufferSize; void *pBuffer = 0; int structural_zero; int numerical_zero; const double alpha = 1.; const mcsparseSolvePolicy_t policy = MCSPARSE_SOLVE_POLICY_USE_LEVEL; const mcsparseOperation_t trans = MCSPARSE_OPERATION_NON_TRANSPOSE; const mcsparseDirection_t dir = MCSPARSE_DIRECTION_COLUMN; // 步骤1：创建一个描述符，其中包含以下内容： // - 矩阵L是从1开始编号的 // - 矩阵L是下三角矩阵 // - 矩阵L具有由参数MCSPARSE_DIAG_TYPE_UNIT指定的单位对角线 // (L可能并不具有所有对角线元素。) mcsparseCreateMatDescr(&descr); mcsparseSetMatIndexBase(descr, MCSPARSE_INDEX_BASE_ONE); mcsparseSetMatFillMode(descr, MCSPARSE_FILL_MODE_LOWER); mcsparseSetMatDiagType(descr, MCSPARSE_DIAG_TYPE_UNIT); // 步骤2：创建一个空的信息结构体 mcsparseCreateBsrsv2Info(&info); // 步骤3：查询bsrsv2中使用了多少内存，并分配缓冲区 mcsparseDbsrsv2_bufferSize(handle, dir, trans, mb, nnzb, descr, d_bsrVal, d_bsrRowPtr, d_bsrColInd, blockDim, &pBufferSize); // 由mcMalloc返回的pBuffer会自动对齐到128字节。 mcMalloc((void**)&pBuffer, pBufferSize); // 步骤4：执行分析 mcsparseDbsrsv2_analysis(handle, dir, trans, mb, nnzb, descr, d_bsrVal, d_bsrRowPtr, d_bsrColInd, blockDim, info, policy, pBuffer); // L具有单位对角线，因此不会报告结构性零。 status = mcsparseXbsrsv2_zeroPivot(handle, info, &structural_zero); if (MCSPARSE_STATUS_ZERO_PIVOT == status){ printf("L(%d,%d) is missing\n", structural_zero, structural_zero); } // 步骤5: 处理 L*y = x mcsparseDbsrsv2_solve(handle, dir, trans, mb, nnzb, &alpha, descr, d_bsrVal, d_bsrRowPtr, d_bsrColInd, blockDim, info, d_x, d_y, policy, pBuffer); // L具有单位对角线，因此不会报告任何数值零。 status = mcsparseXbsrsv2_zeroPivot(handle, info, &numerical_zero); if (MCSPARSE_STATUS_ZERO_PIVOT == status){ printf("L(%d,%d) is zero\n", numerical_zero, numerical_zero); } // 步骤6: 释放资源 mcFree(pBuffer); mcsparseDestroyBsrsv2Info(info); mcsparseDestroyMatDescr(descr); mcsparseDestroy(handle);输入
handle处理mcSPARSE库上下文的句柄。
dir块的存储格式，可以是
MCSPARSE_DIRECTION_ROW或MCSPARSE_DIRECTION_COLUMN。
transAop(A)操作
mb矩阵
A中块的行数和列数。
alpha用于乘法运算的<type>标量。
descrA矩阵
A的描述符。支持的矩阵类型有MCSPARSE_MATRIX_TYPE_GENERAL此外，支持的索引基准有MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。
bsrValA存储矩阵
A中nnzb个非零块的 <type>数组。
bsrRowPtrA包含每个块行的起始位置和最后一个块行结 结束位置后移一位的整数数组，数组长度为
mb。
bsrColIndA存储了矩阵
A中非零块nnzb个 列索引信息的整数数组。
blockDim稀疏矩阵
A的块维度，大于零。
info在分析阶段收集的结构信息 (应该未经修改地传递到求解阶段)。
x大小为
m的<type>右侧向量。
policy支持的策略有
MCSPARSE_SOLVE_POLICY_NO_LEVEL和MCSPARSE_SOLVE_POLICY_USE_LEVEL。
pBuffer用户分配的缓冲区，其大小由
bsrsv2_bufferSize()返回。输出
y解向量的类型<type>，大小为
m。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
8.6. mcsparseXbsrsv2_zeroPivot()
mcsparseStatus_t
mcsparseXbsrsv2_zeroPivot(mcsparseHandle_t handle,
bsrsv2Info_t info,
int* position)
如果返回的错误代码是 MCSPARSE_STATUS_ZERO_PIVOT， position=j 表示 A(j,j) 是结构零或数值零（奇异块）。否则为 position=-1。
position 可以从0开始，也可以从1开始，与矩阵相同。
函数 mcsparseXbsrsv2_zeroPivot() 是一个阻塞调用。
它调用 mcDeviceSynchronize() 来确保所有先前的核都已完成。
position 可以位于主机内存或设备内存中。
用户可以使用 mcsparseSetPointerMode() 设置正确的模式。
例程不需要额外的存储空间
如果流式有序内存分配器可用，则该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
info如果用户已调用
bsrsv2_analysis()或bsrsv2_solve()， 那么info包含结构零的或数值零。输出
position如果没有结构或数值为零，则
position为-1； 否则如果缺少A(j,j)或U(j,j)为零，则position=j。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
8.7. mcsparseCsrmvEx()
mcsparseStatus_t
mcsparseCsrmvEx_bufferSize(mcsparseHandle_t handle,
mcsparseAlgMode_t alg,
mcsparseOperation_t transA,
int m,
int n,
int nnz,
const void* alpha,
macaDataType alphatype,
const mcsparseMatDescr_t descrA,
const void* csrValA,
macaDataType csrValAtype,
const int* csrRowPtrA,
const int* csrColIndA,
const void* x,
macaDataType xtype,
const void* beta,
macaDataType betatype,
void* y,
macaDataType ytype,
macaDataType executiontype,
size_t* bufferSizeInBytes)
mcsparseStatus_t
mcsparseCsrmvEx(mcsparseHandle_t handle,
mcsparseAlgMode_t alg,
mcsparseOperation_t transA,
int m,
int n,
int nnz,
const void* alpha,
macaDataType alphatype,
const mcsparseMatDescr_t descrA,
const void* csrValA,
macaDataType csrValAtype,
const int* csrRowPtrA,
const int* csrColIndA,
const void* x,
macaDataType xtype,
const void* beta,
macaDataType betatype,
void* y,
macaDataType ytype,
macaDataType executiontype,
void* buffer)
此函数执行矩阵到向量的操作。
函数 mcsparseCsrmvEx_bufferSize 返回 mcsparseCsrmvEx 所需的工作区大小。
此函数具有以下限制：
所有指针都应该与128字节对齐
仅支持
MCSPARSE_OPERATION_NON_TRANSPOSE操作仅支持
MCSPARSE_MATRIX_TYPE_GENERAL矩阵类型仅支持
MCSPARSE_INDEX_BASE_ZERO索引不支持半精度
支持的最低GPU架构为SM_53
此函数具有以下特性：
例程不需要额外的存储空间
例程支持异步执行
输入
alg对于csrmv算法的实现，请参见 4.9 mcsparseAlgMode_t 可能的取值。
alphatype数据类型为
alpha。csrValAtype数据类型为
csrValA。xtype数据类型为
x。betatype数据类型为
beta。ytype数据类型为
y。executiontype用于计算的数据类型。
bufferSizeInBytes指向
size_t变量的指针，将被分配mcsparseCsrmvEx所需的工作区大小。buffer指向工作区缓冲区的指针。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
8.8. mcsparse<t>csrsv2_bufferSize()
mcsparseStatus_t
mcsparseScsrsv2_bufferSize(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrsv2Info_t info,
int* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseDcsrsv2_bufferSize(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrsv2Info_t info,
int* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseCcsrsv2_bufferSize(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
mcComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrsv2Info_t info,
int* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseZcsrsv2_bufferSize(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
mcDoubleComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrsv2Info_t info,
int* pBufferSizeInBytes)
此函数返回 csrsv2 (一种新的稀疏三角线性系统)中使用的缓冲区大小。
虽然参数 trans 和 A 的上(下)三角部分有六种组合，但 csrsv2_bufferSize() 返回这些组合中所需的最大缓冲区大小。
缓冲区大小取决于矩阵的维度和非零元素的数量。
如果用户更改了矩阵，就需要再次调用 csrsv2_bufferSize() 来获得正确的缓冲区大小；否则，可能会发生分段错误。
例程不需要额外的存储空间
例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
transA操作op(A)。
m矩阵
A的行数。nnz矩阵
A的非零元素数。descrA矩阵
A的描述符。 支持的矩阵类型为MCSPARSE_MATRIX_TYPE_GENERAL， 而支持的对角线类型为MCSPARSE_DIAG_TYPE_UNIT和MCSPARSE_DIAG_TYPE_NON_UNIT。csrValA类型为<type>的数组， 其中包含矩阵
A的nnz个非零元素。csrRowPtrA由整数组成的长度为
m+ 1 的数组， 其中包含每一行的起始位置 和最后一行结束位置加一。csrColIndA整数数组，长度为
nnz， 包含矩阵A非零元素的列索引。输出
info基于不同算法的内部状态记录。
pBufferSizeInBytes在
csrsv2_analysis和csrsv2_solve中使用的缓冲区的字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
8.9. mcsparse<t>csrsv2_analysis()
mcsparseStatus_t
mcsparseScsrsv2_analysis(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrsv2Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseDcsrsv2_analysis(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrsv2Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseCcsrsv2_analysis(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
const mcComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrsv2Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseZcsrsv2_analysis(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrsv2Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
此函数执行新稀疏三角线性系统 csrsv2 的分析阶段。
对于给定的矩阵和特定的操作类型，预计此函数将仅执行一次。
此函数需要由 csrsv2_bufferSize() 返回的缓冲区大小。
pBuffer 的地址必须是128字节的倍数。
如果不是，则返回 MCSPARSE_STATUS_INVALID_VALUE。
函数 csrsv2_analysis() 报告一个结构零并计算存储在不透明结构 info 中的级别信息。
层次信息可以为三角求解器提高更多的并行效率。
但是， csrsv2_solve() 可以在没有级别信息的情况下完成。
要禁用级别信息，用户需要将三角求解器的策略指定为 MCSPARSE_SOLVE_POLICY_NO_LEVEL。
函数 csrsv2_analysis() 始终报告第一个结构零，即使策略是 MCSPARSE_SOLVE_POLICY_NO_LEVEL。
如果指定了 MCSPARSE_DIAG_TYPE_UNIT，即使某些 j 缺少 A(j,j)，也不会报告结构零。
用户需要调用 mcsparseXcsrsv2_zeroPivot() 才能知道结构零的位置。
如果 csrsv2_analysis() 报告了一个结构零，则用户可以选择是否调用 csrsv2_solve()。
在这种情况下，用户仍然可以调用 csrsv2_solve()，它将在与结构零相同的位置返回一个数值零。
然而，结果 x 是没有意义的。
此功能需要内部分配的临时额外存储
如果流式有序内存分配器可用，则该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
transA操作op(A)。
m矩阵
A的行数。nnz矩阵
A的非零元素数。descrA矩阵
A的描述符。 支持的矩阵类型为MCSPARSE_MATRIX_TYPE_GENERAL， 而支持的对角线类型为MCSPARSE_DIAG_TYPE_UNIT和MCSPARSE_DIAG_TYPE_NON_UNIT。csrValA类型为<type>的数组， 其中包含矩阵
A的nnz个非零元素。csrRowPtrA由整数组成的长度为
m+ 1 的数组， 其中包含每一行的起始位置 和最后一行结束位置加一。csrColIndA整数数组，长度为
nnz， 包含矩阵A非零元素的列索引。info用
mcsparseCreateCsrsv2Info()初始化的结构。policy支持的策略包括
MCSPARSE_SOLVE_POLICY_NO_LEVEL和HCSPARSE_SOLVE_POLICY_ USE_LEVEL。pBuffer缓冲区由用户分配，大小由
csrsv2_bufferSize()返回。输出
info在分析阶段收集的信息填充的结构(应在分析阶段传递 给求解阶段而不变)。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
8.10. mcsparse<t>csrsv2_solve()
mcsparseStatus_t
mcsparseScsrsv2_solve(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int nnz,
const float* alpha,
const mcsparseMatDescr_t descra,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrsv2Info_t info,
const float* x,
float* y,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseDcsrsv2_solve(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int nnz,
const double* alpha,
const mcsparseMatDescr_t descra,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrsv2Info_t info,
const double* x,
double* y,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseCcsrsv2_solve(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int nnz,
const mcComplex* alpha,
const mcsparseMatDescr_t descra,
const mcComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrsv2Info_t info,
const mcComplex* x,
mcComplex* y,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseZcsrsv2_solve(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int nnz,
const mcDoubleComplex* alpha,
const mcsparseMatDescr_t descra,
const mcDoubleComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrsv2Info_t info,
const mcDoubleComplex* x,
mcDoubleComplex* y,
mcsparseSolvePolicy_t policy,
void* pBuffer)
此函数执行 csrsv2 的求解阶段，这是一个新的稀疏三角线性系统。
对于给定矩阵和特定操作类型，可以多次执行此函数。
此函数需要由 csrsv2_bufferSize() 返回缓冲区大小。 pBuffer 的地址必须是128字节的倍数。如果不是，则返回 MCSPARSE_STATUS_INVALID_VALUE。
尽管可以在没有级别信息的情况下完成 csrsv2_solve()，但用户仍然需要注意一致性。
如果使用策略 MCSPARSE_SOLVE_POLICY_USE_LEVEL 调用 csrsv2_analysis()，则可以在有或没有级别的情况下运行 csrsv2_solve()。相反，如果使用 MCSPARSE_SOLVE_POLICY_NO_LEVEL 调用 csrsv2_analysis()，则 csrsv2_solve() 只能接受 MCSPARSE_SOLVE_POLICY_NO_LEVEL。
否则，返回 MCSPARSE_STATUS_INVALID_VALUE。
级别信息可能不会提高性能，但会花费额外的时间进行分析。
例如，一个三对角矩阵没有并行性。
在这种情况下， MCSPARSE_SOLVE_POLICY_NO_LEVEL 比 MCSPARSE_SOLVE_POLICY_USE_LEVEL 性能更好。
如果用户有一个迭代求解器，最好的方法是用 MCSPARSE_SOLVE_POLICY_USE_LEVEL 执行一次 csrsv2_analysis()。
然后在第一次运行中使用 MCSPARSE_SOLVE_POLICY_NO_LEVEL 执行 csrsv2_solve() 函数，在第二次运行中使用 MCSPARSE_SOLVE_POLICY_USE_LEVEL，选择更快的一个函数来执行剩余的迭代。
函数 csrsv2_solve() 会报告第一个数值零，包括结构零。
如果 status 为0，则表示没有找到任何数值零。
此外，如果指定了 MCSPARSE_DIAG_TYPE_UNIT，则即使某些 j 对应的 A(j,j) 为零，也不会报告任何数值零。
用户需要调用 mcsparseXcsrsv2_zeroPivot() 才能知道数值零的位置。
例如，假设L是一个具有单位对角线的下三角矩阵，下面的代码通过级别信息求解 L*y=x。
// 假设L是一个用CSR格式表示的m x m的稀疏矩阵。 // L是具有单位对角线的下三角矩阵。 // 假设： // - 矩阵L的维度为m， // - 矩阵L拥有nnz个零元素， // - 句柄已经由mcsparseCreate()创建， // - (d_csrRowPtr，d_csrColInd，d_csrVal)用设备内存上矩阵L的CSR格式表示， // - d_x是设备内存上的右侧向量， // - d_y是设备内存上的解向量。 mcsparseMatDescr_t descr = 0; csrsv2Info_t info = 0; int pBufferSize; void *pBuffer = 0; int structural_zero; int numerical_zero; const double alpha = 1.; const mcsparseSolvePolicy_t policy = MCSPARSE_SOLVE_POLICY_USE_LEVEL; const mcsparseOperation_t trans = MCSPARSE_OPERATION_NON_TRANSPOSE; // 步骤1：创建包含以下内容的描述符 // - 矩阵L以1为基数 // - 矩阵L为下三角形 // - 矩阵L具有单位对角线，由参数MCSPARSE_DIAG_TYPE_UNIT指定 // (L可能没有所有对角线元素。) mcsparseCreateMatDescr(&descr); mcsparseSetMatIndexBase(descr, MCSPARSE_INDEX_BASE_ONE); mcsparseSetMatFillMode(descr, MCSPARSE_FILL_MODE_LOWER); mcsparseSetMatDiagType(descr, MCSPARSE_DIAG_TYPE_UNIT); // 步骤2：创建一个空的info结构 mcsparseCreateCsrsv2Info(&info); // 步骤3：查询csrsv2中使用了多少内存，并分配缓冲区 mcsparseDcsrsv2_bufferSize(handle, trans, m, nnz, descr, d_csrVal, d_csrRowPtr, d_csrColInd, info, &pBufferSize); // 由mcMalloc返回的pBuffer会自动对齐到128字节。 mcMalloc((void**)&pBuffer, pBufferSize); // 步骤4：执行分析 mcsparseDcsrsv2_analysis(handle, trans, m, nnz, descr, d_csrVal, d_csrRowPtr, d_csrColInd, info, policy, pBuffer); // L具有单位对角线，因此不会报告任何结构零的位置。 status = mcsparseXcsrsv2_zeroPivot(handle, info, &structural_zero); if (MCSPARSE_STATUS_ZERO_PIVOT == status){ printf("L(%d,%d) is missing\n", structural_zero, structural_zero); } // 步骤5：求解L*y = x mcsparseDcsrsv2_solve(handle, trans, m, nnz, &alpha, descr, d_csrVal, d_csrRowPtr, d_csrColInd, info, d_x, d_y, policy, pBuffer); // L具有单位对角线，因此不会报告任何数值零的位置。 status = mcsparseXcsrsv2_zeroPivot(handle, info, &numerical_zero); if (MCSPARSE_STATUS_ZERO_PIVOT == status){ printf("L(%d,%d) is zero\n", numerical_zero, numerical_zero); } // 步骤6：释放资源 mcFree(pBuffer); mcsparseDestroyCsrsv2Info(info); mcsparseDestroyMatDescr(descr); mcsparseDestroy(handle);
备注
csrsv2_solve() 每行需要更多的非零元素才能达到良好的性能。如果平均每行超过 16 个非零元素，它的性能会更好。
如果 pBuffer != NULL，则此函数将支持以下属性
例程不需要额外的存储空间
例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
transA操作op(A)。
m矩阵
A的行数和列数。alpha用于乘法的<type>标量。
descrA矩阵
A的描述符。 支持的矩阵类型为MCSPARSE_MATRIX_TYPE_GENERAL， 而支持的对角线类型为MCSPARSE_DIAG_TYPE_UNIT和MCSPARSE_DIAG_TYPE_NON_UNIT。csrValA类型为<type>的数组， 其中包含矩阵
A的nnz个非零元素。csrRowPtrA由整数组成的长度为
m+ 1 的数组， 其中包含每一行的起始位置 和最后一行结束位置加一。csrColIndA整数数组，包含矩阵
A中nnz个非零元素的列索引。info在分析阶段收集的信息的结构 (应该不经更改地传递到求解阶段)。
x大小为
m的<type>右侧向量。policy支持的策略包括
MCSPARSE_SOLVE_POLICY_NO_LEVEL和MCSPARSE_SOLVE_POLICY_ USE_LEVEL。pBuffer缓冲区由用户分配，大小由
csrsv2_bufferSize()返回。输出
y大小为
m的<type>解向量
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
8.11. mcsparseXcsrsv2_zeroPivot()
mcsparseStatus_t
mcsparseXcsrsv2_zeroPivot(mcsparseHandle_t handle,
csrsv2Info_t info,
int* position)
如果返回的错误代码为 MCSPARSE_STATUS_ZERO_PIVOT， position=j 表示 A(j,j) 存在结构零或数值零。否则 position=-1。
position 可以从0开始，也可以从1开始，与矩阵相同。
函数 mcsparseXcsrsv2_zeroPivot() 是一个阻塞调用。
它调用 mcDeviceSynchronize() 来确保所有先前的核都已完成。
position 可以位于主机内存或设备内存中。
用户可以使用 mcsparseSetPointerMode() 设置正确的模式。
例程不需要额外的存储空间
如果流式有序内存分配器可用，则该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
info如果用户已调用
csrsv2_analysis()或csrsv2_solve()info包含结构零或数值零输出
position如果没有结构零或数值零，则
position为 -1；否则如果缺少A(j,j)或U(j,j)为零，则position=j。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
8.12. mcsparse<t>gemvi()
mcsparseStatus_t
mcsparseSgemvi_bufferSize(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int n,
int nnz,
int* pBufferSize)
mcsparseStatus_t
mcsparseDgemvi_bufferSize(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int n,
int nnz,
int* pBufferSize)
mcsparseStatus_t
mcsparseCgemvi_bufferSize(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int n,
int nnz,
int* pBufferSize)
mcsparseStatus_t
mcsparseZgemvi_bufferSize(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int n,
int nnz,
int* pBufferSize)
mcsparseStatus_t
mcsparseSgemvi(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int n,
const float* alpha,
const float* A,
int lda,
int nnz,
const float* x,
const int* xInd,
const float* beta,
float* y,
mcsparseIndexBase_t idxBase,
void* pBuffer)
mcsparseStatus_t
mcsparseDgemvi(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int n,
const double* alpha,
const double* A,
int lda,
int nnz,
const double* x,
const int* xInd,
const float* beta,
double* y,
mcsparseIndexBase_t idxBase,
void* pBuffer)
mcsparseStatus_t
mcsparseCgemvi(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int n,
const mcComplex* alpha,
const mcComplex* A,
int lda,
int nnz,
const mcComplex* x,
const int* xInd,
const float* beta,
mcComplex* y,
mcsparseIndexBase_t idxBase,
void* pBuffer)
mcsparseStatus_t
mcsparseZgemvi(mcsparseHandle_t handle,
mcsparseOperation_t transA,
int m,
int n,
const mcDoubleComplex* alpha,
const mcDoubleComplex* A,
int lda,
int nnz,
const mcDoubleComplex* x,
const int* xInd,
const float* beta,
mcDoubleComplex* y,
mcsparseIndexBase_t idxBase,
void* pBuffer)
此函数执行矩阵到向量的操作。
例程不需要额外的存储空间
例程支持异步执行
函数 mcsparse<t>gemvi_bufferSize() 返回 mcsparse<t>gemvi() 中使用的缓冲区大小。
输入
handle处理mcSPARSE库上下文的句柄。
trans操作op(A)
m矩阵
A的行数。
n矩阵
A的列数。
alpha用于乘法的<type>标量。
A指向稠密矩阵
A的指针。
lda
A的主维度的大小。
nnz向量
x的非零元素数。
x大小为
n的<type>稀疏向量， 具有nnz个非零元素。
xInd
x中非零值的索引
beta用于乘法的<type>标量。 如果
beta为零，y不需要是一个有效的输入。
y包含
m个元素的稠密向量。
idxBase0或1，分别表示基于0或基于1的索引。
pBufferSize在
mcsparse<t>gemvi()函数中 使用的缓冲区所需的元素数量。
pBuffer工作空间缓冲区
输出
y更新后的<type>稠密向量
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。