这篇博客详细介绍了cuSPARSE库，包括其管理函数和帮助函数的使用，如库初始化、错误处理、矩阵描述符操作等。还涵盖了库的三级功能，如稀疏矩阵与密集向量的运算，以及解决稀疏线性系统的分析和求解过程，强调了不同函数的输入输出和限制条件。
前言
- 级别1：稀疏格式的向量与密集格式的向量之间的操作
- 级别2：稀疏格式的矩阵与稠密向量之间的操作格式
- 级别3：稀疏格式的矩阵和一组密集格式的矢量（通常也可以看作密集的高矩阵）之间的运算
- 转换：允许在不同格式之间进行转换的运算矩阵格式，以及
csr矩阵的压缩。
cuSPARSE库函数可用于数据类型float，double，cuComplex和cuDoubleComplex。sparse的1级，2级和3级函数遵循以下命名约定：
cusparse<t>[<matrix data format>]<operation>[<output matrix data format>]
其中 < t > 可以是S，D，C，Z或X，分别对应于数据类型float，double，cuComplex，cuDoubleComplex和泛型类型。
< matrix data format > 可以是dense，coo，csr或csc，分别对应于稠密，坐标格式，压缩稀疏行和压缩稀疏列格式
最后，< operation >可以是axpyi，gthr，gthrz，roti或sctr，对应于1级功能。它也可以是对应于2级功能的mv或sv，以及对应于3级功能的mm或sm。
所有函数的返回类型均为cusparseStatus_t，并在随后的各章中详细介绍。
cuSparse管理函数
1. cusparseCreate()
cusparseStatus_t
cusparseCreate(cusparseHandle_t *handle)
这个函数初始化cuSPARSE库并在cuSPARSE上下文中创建一个句柄。必须在调用任何其他cuSPARSE API函数之前调用它。它分配访问GPU所需的硬件资源。
2.cusparseDestroy()
cusparseStatus_t
cusparseDestroy(cusparseHandle_t handle)
这个函数释放cuSPARSE库使用的cpu端资源。gpu端资源的释放可能会推迟到应用程序关闭时。
3. cusparseGetErrorString()
const char*
cusparseGetErrorString(cusparseStatus_t status)
函数返回错误代码枚举名的字符串表示形式。如果无法识别错误代码，则返回“无法识别的错误代码”。
4.cusparseGetProperty()
cusparseStatus_t
cusparseGetProperty(libraryPropertyType type,
int* value)
该函数返回所请求属性的值。
libraryPropertyType (定义在library_types.h):
| 值 | 含义 |
|---|---|
| MAJOR_VERSION | 枚举器查询最大版本 |
| MINOR_VERSION | 枚举器查询最小版本 |
| PATCH_LEVEL | 识别补丁级别编号 |
5.cusparseGetVersion()
cusparseStatus_t
cusparseGetVersion(cusparseHandle_t handle,
int* version)
获得库的版本号
6.cusparseGetPointerMode()
cusparseStatus_t
cusparseGetPointerMode(cusparseHandlet handle,
cusparsePointerMode_t *mode)
这个函数获得cuSPARSE库使用的指针模式。请参阅cusparsePointerMode_t类型部分了解更多细节。
此类型指示标量值是在主机上还是在设备上通过引用传递。需要指出的重要一点是，如果在函数调用中通过引用传递了几个标量值，那么所有这些值都将遵循相同的单指针模式。指针模式可以分别使用cusparseSetPointerMode()和cusparseGetPointerMode()例程设置和检索。
| 值 | 含义 |
|---|---|
| CUSPARSE_POINTER_MODE_HOST | 标量在主机上通过引用传递 |
| CUSPARSE_POINTER_MODE_DEVICE | 标量在设备上通过引用传递 |
7.cusparseSetPointerMode()
cusparseStatus_t
cusparseSetPointerMode(cusparseHandle_t handle,
cusparsePointerMode_t mode)
这个函数设置cuSPARSE库使用的指针模式。默认值是通过主机上的引用传递的。默认值是通过主机上的引用传递的。
8.cusparseGetStream()
cusparseStatus_t
cusparseGetStream(cusparseHandle_t handle, cudaStream_t *streamId)
这个函数获取cuSPARSE库流，用于执行对cuSPARSE库函数的所有调用。如果cuSPARSE库流没有设置，那么所有内核都使用默认的空流。
9. cusparseSetStream()
这个函数设置cuSPARSE库用来执行其例程的流。
cuSparse帮助函数
1.cusparseCreate/DestroyColorInfo()
cusparseStatus_t cusparseCreate/DestroyColorInfo(cusparseColorInfo_t* info)
此函数创建/销毁并将cusparseColorInfo_t结构初始化为默认值。
2. cusparseCreate/DestroyMatDescr()
cusparseStatus_t cusparseCreate/DestroyMatDescr(cusparseMatDescr_t *descrA)
这个函数初始化/销毁矩阵描述符。它将字段MatrixType和IndexBase设置为默认值CUSPARSE_MATRIX_TYPE_GENERAL和CUSPARSE_INDEX_BASE_ZERO，而其他字段未初始化。
3. cusparseSet/GetMatDiagType()
cusparseDiagType_t
cusparseGetMatDiagType(const cusparseMatDescr_t descrA)
这个函数设置/返回矩阵描述符descrA的DiagType字段。
cusparseDiagType_t
这种类型表示矩阵对角线项是否为一。对角线元素总是被假定存在，但是如果CUSPARSE_DIAG_TYPE_UNIT被传递给API例程，那么例程假设所有的对角线元素都是1，并且不会读取或修改这些元素。注意，在这种情况下，例程假设对角线上的条目等于1，而不管这些条目在内存中实际设置为什么。有两种值CUSPARSE_DIAG_TYPE_NON_UNIT和CUSPARSE_DIAG_TYPE_UNIT
4. cusparseSet/GetMatFillMode()
cusparseFillMode_t
cusparseSet/GetMatFillMode(const cusparseMatDescr_t descrA)
这个函数设置/返回矩阵描述符descrA的FillMode字段。
cusparseFillMode_t
该类型表示矩阵的上/下部分是否存储在稀疏存储中。
| 值 | 含义 |
|---|---|
| CUSPARSE_FILL_MODE_LOWER | 存储下三角形部分。 |
| CUSPARSE_FILL_MODE_UPPER | 存储上三角形部分。 |
5. cusparseSet/GetMatIndexBase()
cusparseIndexBase_t
cusparseSet/GetMatIndexBase(const cusparseMatDescr_t descrA)
这个函数设置/返回矩阵描述符descrA的IndexBase字段。
cusparseIndexBase_t
这种类型表示矩阵索引的基底是0还是1。
| 值 | 含义 |
|---|---|
| CUSPARSE_INDEX_BASE_ZERO | 基准索引是零。 |
| CUSPARSE_INDEX_BASE_ONE | 基准索引是一。 |
6. cusparseSet/GetMatType()
cusparseMatrixType_t
cusparseSet/GetMatType(const cusparseMatDescr_t descrA)
这个函数设置/返回矩阵描述符descrA的MatrixType字段。
cusparseMatrixType_t
| 值 | 含义 |
|---|---|
| CUSPARSE_MATRIX_TYPE_GENERAL | 一般矩阵 |
| CUSPARSE_MATRIX_TYPE_SYMMETRIC | 对称矩阵 |
| CUSPARSE_MATRIX_TYPE_HERMITIAN | 厄米特矩阵 |
| CUSPARSE_MATRIX_TYPE_TRIANGULAR | 三角矩阵 |
7. cusparseCreate/DestroyCsrsv2Info()
cusparseStatus_t
cusparseCreate/DestroyCsrsv2Info(csrsv2Info_t *info);
此函数用于创建/销毁csrsv2的求解和分析结构并将其初始化为默认值。csrsv2_solve和csrsv2_analysis。
8. cusparseCreate/DestroyCsrsm2Info()
cusparseStatus_t
cusparseCreate/DestroyCsrsm2Info(csrsm2Info_t *info);
此函数用于创建/销毁csrsm2的求解和分析结构并将其初始化为默认值。csrsm2_solve和csrsm2_analysis。
9. cusparseCreate/DestroyCsric02Info()
cusparseStatus_t
cusparseCreate/DestroyCsric02Info(csric02Info_t *info);
此函数创建/销毁不完整的Cholesky的求解和分析结构并将其初始化为默认值。csric02_solve和csric02_analysis。
10. cusparseCreate/DestroyCsrilu02Info()
cusparseStatus_t
cusparseCreate/DestroyCsrilu02Info(csrilu02Info_t *info);
此函数创建/销毁不完整LU的求解和分析结构并将其初始化为默认值。
11. cusparseCreate/DestroyBsrsv2Info()
cusparseStatus_t
cusparseCreate/DestroyBsrsv2Info(bsrsv2Info_t *info);
此函数创建/销毁bsrsv2的求解和分析结构并将其初始化为默认值。
12. cusparseCreate/DestroyBsrsm2Info()
cusparseStatus_t
cusparseCreate/DestroyBsrsm2Info(bsrsm2Info_t *info);
此函数创建/销毁bsrsm2的求解和分析结构并将其初始化为默认值。
13. cusparseCreate/DestroyBsric02Info()
cusparseStatus_t
cusparseCreate/DestroyBsric02Info(bsric02Info_t *info);
此函数创建/销毁块不完整的Cholesky的求解和分析结构并将其初始化为默认值。
14. cusparseCreate/DestroyBsrilu02Info()
cusparseStatus_t
cusparseCreate/DestroyBsrilu02Info(bsrilu02Info_t *info);
此函数创建/销毁块不完整LU的求解和分析结构并初始化为默认值。
15. cusparseCreate/DestroyCsrgemm2Info()
cusparseStatus_t
cusparseCreate/DestroyCsrgemm2Info(csrgemm2Info_t *info);
此函数创建/销毁通用稀疏矩阵-矩阵乘法的分析结构并初始化。
16. cusparseCreate/DestroyPruneInfo()
cusparseStatus_t
cusparseCreate/DestroyPruneInfo(pruneInfo_t *info);
此函数创建/销毁修剪结构并初始化为默认值。
cuSparse库三级功能参考
本章介绍在稀疏和（通常是较高的）稠密矩阵之间执行运算的稀疏线性代数函数。
特别是，具有多个右侧值的稀疏三角线性系统的解决方案分两个阶段实现。首先，在分析阶段，通过调用适当的csrsm2_analysis()函数，分析稀疏三角矩阵以确定其元素之间的依赖性。该分析特定于给定矩阵的稀疏模式和所选的cusparseOperation_t类型。来自分析阶段的信息存储在csrsm2Info_t类型的参数中，该参数已通过调用cusparseCreateCsrsm2Info()进行了初始化。
其次，在求解阶段，使用存储的信息来求解给定的稀疏三角线性系统通过调用适当的csrsm2_solve()函数在csrsm2Info_t参数中输入。求解阶段可以使用不同的多个右侧值进行多次，而分析阶段只需执行一次。当必须同时针对一组多个右侧值的不同集合求解稀疏三角形线性系统时，这特别有用，而其系数矩阵保持不变。
最后，一旦所有求解都完成，可以通过调用cusparseDestroyCsrsm2Info()释放由csrsm2Info_t参数指向的不透明数据结构。
cusparse<t>bsrmm()
cusparseStatus_t
cusparseSbsrmm(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transB,
int mb,
int n,
int kb,
int nnzb,
const <t>* alpha,
const cusparseMatDescr_t descrA,
const <t>* bsrValA,
const int* bsrRowPtrA,
const int* bsrColIndA,
int blockDim,
const <t>* B,
int ldb,
const <t>* beta,
<t>* C,
int ldc)
<t>表示当前数据类型，可以是S，D，C，Z或X，分别对应于数据类型float，double，cuComplex，cuDoubleComplex和泛型类型。
此函数执行以下矩阵操作之一：
C = α ∗ op ( A ) ∗ op ( B ) + β ∗ C
A是** mb×kb 的稀疏矩阵，由BsrValA，bsrRowPtrA和bsrColIndA三个数组以BSR存储格式定义； B和C**是密集矩阵； α、β是标量；
o
p
(
A
)
=
{
A
i
f
t
r
a
n
s
A
=
=
C
U
S
P
A
R
S
E
O
P
E
R
A
T
I
O
N
N
O
N
T
R
A
N
S
P
O
S
E
A
T
i
f
t
r
a
n
s
A
=
=
C
U
S
P
A
R
S
E
O
P
E
R
A
T
I
O
N
T
R
A
N
S
P
O
S
E
(
n
o
t
s
u
p
p
o
r
t
e
d
)
A
H
i
f
t
r
a
n
s
A
=
=
C
U
S
P
A
R
S
E
O
P
E
R
A
T
I
O
N
C
O
N
J
U
G
A
T
E
T
R
A
N
S
P
O
S
E
(
n
o
t
s
u
p
p
o
r
t
e
d
)
op(A)=\left\{ \begin{array}{rcl} A & {if transA == CUSPARSE_OPERATION_NON_TRANSPOSE}\\ A^T & {if transA == CUSPARSE_OPERATION_TRANSPOSE(not supported)}\\ A^H & {if transA == CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE (not supported)} \end{array} \right.
op(A)=⎩⎨⎧AATAHiftransA==CUSPARSEOPERATIONNONTRANSPOSEiftransA==CUSPARSEOPERATIONTRANSPOSE(notsupported)iftransA==CUSPARSEOPERATIONCONJUGATETRANSPOSE(notsupported)
和
o
p
(
A
)
=
{
B
i
f
t
r
a
n
s
B
=
=
C
U
S
P
A
R
S
E
O
P
E
R
A
T
I
O
N
N
O
N
T
R
A
N
S
P
O
S
E
B
T
i
f
t
r
a
n
s
B
=
=
C
U
S
P
A
R
S
E
O
P
E
R
A
T
I
O
N
T
R
A
N
S
P
O
S
E
B
H
i
f
t
r
a
n
s
B
=
=
C
U
S
P
A
R
S
E
O
P
E
R
A
T
I
O
N
C
O
N
J
U
G
A
T
E
T
R
A
N
S
P
O
S
E
(
n
o
t
s
u
p
p
o
r
t
e
d
)
op(A)=\left\{ \begin{array}{rcl} B & {if transB == CUSPARSE_OPERATION_NON_TRANSPOSE}\\ B^T & {if transB == CUSPARSE_OPERATION_TRANSPOSE}\\ B^H & {if transB == CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE (not supported)} \end{array} \right.
op(A)=⎩⎨⎧BBTBHiftransB==CUSPARSEOPERATIONNONTRANSPOSEiftransB==CUSPARSEOPERATIONTRANSPOSEiftransB==CUSPARSEOPERATIONCONJUGATETRANSPOSE(notsupported)
该函数具有以下限制：
- 仅支持
CUSPARSE_MATRIX_TYPE_GENERAL矩阵类型 - 仅支持
blockDim > 1
Transpose(B)的动机是为了改善矩阵B的内存访问。A*transpose(B)（B以列为主的形式存储）计算模式等价于A*B（B以行为主形式存储）
实际上，在迭代求解器或特征值求解器中没有任何操作使用A * transpose（B）。但是，我们可以执行与A * B相同的A*transpose(transpose(B))。例如，假设A为mb * kb，B为k * n，C为m * n，以下代码显示cusparseDbsrmm()的用法。
// A is mb*kb, B is k*n and C is m*n
const int m = mb*blockSize;
const int k = kb*blockSize;
const int ldb_B = k; // leading dimension of B
const int ldc = m; // leading dimension of C
// perform C:=alpha*A*B + beta*C
cusparseSetMatType(descrA, CUSPARSE_MATRIX_TYPE_GENERAL );
cusparseDbsrmm(cusparse_handle,
CUSPARSE_DIRECTION_COLUMN,
CUSPARSE_OPERATION_NON_TRANSPOSE,
CUSPARSE_OPERATION_NON_TRANSPOSE,
mb, n, kb, nnzb, alpha,
descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockSize,
B, ldb_B,
beta, C, ldc);
我们的建议不是使用A * B，而是通过首先调用cublas<t>geam()，然后执行A * transpose(Bt)，将B转置为Bt。
// step 1: Bt := transpose(B)
const int m = mb*blockSize;
const int k = kb*blockSize;
double *Bt;
const int ldb_Bt = n; // leading dimension of Bt
cudaMalloc((void**)&Bt, sizeof(double)*ldb_Bt*k);
double one = 1.0;
double zero = 0.0;
cublasSetPointerMode(cublas_handle, CUBLAS_POINTER_MODE_HOST);
cublasDgeam(cublas_handle, CUBLAS_OP_T, CUBLAS_OP_T,
n, k, &one, B, int ldb_B, &zero, B, int ldb_B, Bt, ldb_Bt);
// step 2: perform C:=alpha*A*transpose(Bt) + beta*C
cusparseDbsrmm(cusparse_handle,
CUSPARSE_DIRECTION_COLUMN,
CUSPARSE_OPERATION_NON_TRANSPOSE,
CUSPARSE_OPERATION_TRANSPOSE,
mb, n, kb, nnzb, alpha,
descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockSize,
Bt, ldb_Bt,
beta, C, ldc);
bsrmm()具有以下属性：
- 例程不需要额外的存储空间
- 例程支持异步执行
- 例程支持CUDA图形捕获
输入
| 参数 | 含义 |
|---|---|
handle | 处理cuSPARSE库上下文的句柄 |
dir | 块的存储格式，CUSPARSE_DIRECTION_ROW或CUSPARSE_DIRECTION_COLUMN |
transA | 操作op(A) |
transB | 操作op(B) |
mb | 稀疏矩阵A的块行数 |
n | 密集矩阵op(B)和A的列数 |
kb | 稀疏矩阵A的块列数。 |
nnzb | 稀疏矩阵A的非零块数。 |
alpha | 用于乘法的标量 |
descrA | 矩阵A的描述符。支持的矩阵类型为CUSPARSE_MATRIX_TYPE_GENERAL。另外，支持的索引库为CUSPARSE_INDEX_BASE_ZERO和CUSPARSE_INDEX_BASE_ONE。 |
bsrValA | 矩阵A的nnzb(=bsrRowPtrA(mb) - bsrRowPtrA(0))非零块的数组。 |
bsrRowPtrA | mb + 1个元素的整数数组，包含每个块行的开头和最后一个块行的结尾加1。 |
bsrColIndA | 矩阵A的非零块的nnzb(=bsrRowPtrA(mb) - bsrRowPtrA(0))列索引的整数数组。 |
blockDim | 稀疏矩阵A的块的维数，大于0 |
B | 如果op（B）= B，则为尺寸数组（ldb，n），否则为（ldb，k）。 |
ldb | 如果op（B）= B，则必须至少为max（1，n）。如果op（B）!= B，则必须至少为max（1，n）。 |
beta | 标量用于乘法。如果beta为零，则C不必是有效输入。 |
C | 数组(ldc, n) |
ldc | C的前导尺寸。如果op（A）= A，则必须至少为max（1，m），否则为至少max（1，k）。 |
输出
| 值 | 含义 |
|---|---|
| C | 更新了的数组（ldc，n）。 |
cusparse<t>bsrsm2_bufferSize()
cusparseStatus_t
cusparse<t>bsrsm2_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transX,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
<t>* bsrSortedValA,
const int* bsrSortedRowPtrA,
const int* bsrSortedColIndA,
int blockDim,
bsrsm2Info_t info,
int* pBufferSizeInBytes)
此函数返回bsrsm2（）中使用的缓冲区大小，这是一个新的稀疏三角线性系统op（A）* op（X）= op（B）。
A是一个（mb * blockDim）x（mb * blockDim）稀疏矩阵，由三个数组bsrValA，bsrRowPtrA和bsrColIndA以BSR存储格式定义； B和X是右侧和解矩阵；α是标量；
o
p
(
A
)
=
{
A
i
f
t
r
a
n
s
A
=
=
C
U
S
P
A
R
S
E
O
P
E
R
A
T
I
O
N
N
O
N
T
R
A
N
S
P
O
S
E
A
T
i
f
t
r
a
n
s
A
=
=
C
U
S
P
A
R
S
E
O
P
E
R
A
T
I
O
N
T
R
A
N
S
P
O
S
E
A
H
i
f
t
r
a
n
s
A
=
=
C
U
S
P
A
R
S
E
O
P
E
R
A
T
I
O
N
C
O
N
J
U
G
A
T
E
T
R
A
N
S
P
O
S
E
op(A)=\left\{ \begin{array}{rcl} A& {if transA == CUSPARSE_OPERATION_NON_TRANSPOSE}\\ A^T& {if transA == CUSPARSE_OPERATION_TRANSPOSE}\\ A^H& {if transA == CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.
op(A)=⎩⎨⎧AATAHiftransA==CUSPARSEOPERATIONNONTRANSPOSEiftransA==CUSPARSEOPERATIONTRANSPOSEiftransA==CUSPARSEOPERATIONCONJUGATETRANSPOSE
尽管就参数trans和A的上三角部分（和下三角部分）而言，存在六个组合，但是bsrsm2_bufferSize()返回这些组合中缓冲区的最大大小。缓冲区大小取决于大小mb，blockDim和矩阵的非零数nnzb。如果用户更改矩阵，则必须再次调用bsrsm2_bufferSize（）以获得正确的缓冲区大小，否则可能会发生分段错误。
- 例程不需要额外的存储空间
- 例程支持异步执行
- 例程支持CUDA图形捕获
输入
| 参数 | 含义 |
|---|---|
handle | 处理cuSPARSE库上下文的句柄 |
dir | 块的存储格式，CUSPARSE_DIRECTION_ROW或CUSPARSE_DIRECTION_COLUMN |
transA | 操作op(A) |
transB | 操作op(B) |
mb | 矩阵A的块行数 |
n | 矩阵op(B)和op(X)的列数 |
nnzb | 稀疏矩阵A的非零块数。 |
descrA | 矩阵A的描述符。支持的矩阵类型为CUSPARSE_MATRIX_TYPE_GENERAL。支持的对角线类型为CUSPARSE_DIAG_TYPE_UNIT和CUSPARSE_DIAG_TYPE_NON_UNIT。 |
bsrValA | 矩阵A的nnzb(=bsrRowPtrA(mb) - bsrRowPtrA(0))非零块的数组。 |
bsrRowPtrA | mb + 1个元素的整数数组，包含每个块行的开头和最后一个块行的结尾加1。 |
bsrColIndA | 矩阵A的非零块的nnzb(=bsrRowPtrA(mb) - bsrRowPtrA(0))列索引的整数数组。 |
blockDim | 稀疏矩阵A的块的维数，大于0 |
cusparse<t>bsrsm2_analysis()
cusparseStatus_t
cusparse<t>bsrsm2_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transX,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
const <t>* bsrSortedVal,
const int* bsrSortedRowPtr,
const int* bsrSortedColInd,
int blockDim,
bsrsm2Info_t info,
cusparseSolvePolicy_t policy,
void* pBuffer)
此函数执行bsrsm2（）的分析阶段，这是一个新的稀疏三角线性系统op（A）* op（X）= αop（B）。
A是一个（mb * blockDim）x（mb * blockDim）稀疏矩阵，由三个数组bsrValA，bsrRowPtrA和bsrColIndA以BSR存储格式定义； B和X是右侧和解矩阵；α是标量；
o p ( A ) = { A i f t r a n s A = = C U S P A R S E O P E R A T I O N N O N T R A N S P O S E A T i f t r a n s A = = C U S P A R S E O P E R A T I O N T R A N S P O S E A H i f t r a n s A = = C U S P A R S E O P E R A T I O N C O N J U G A T E T R A N S P O S E op(A)=\left\{ \begin{array}{rcl} A& {if transA == CUSPARSE_OPERATION_NON_TRANSPOSE}\\ A^T& {if transA == CUSPARSE_OPERATION_TRANSPOSE}\\ A^H& {if transA == CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right. op(A)=⎩⎨⎧AATAHiftransA==CUSPARSEOPERATIONNONTRANSPOSEiftransA==CUSPARSEOPERATIONTRANSPOSEiftransA==CUSPARSEOPERATIONCONJUGATETRANSPOSE
o p ( A ) = { X i f t r a n s X = = C U S P A R S E O P E R A T I O N N O N T R A N S P O S E X T i f t r a n s X = = C U S P A R S E O P E R A T I O N T R A N S P O S E X H i f t r a n s X = = C U S P A R S E O P E R A T I O N C O N J U G A T E T R A N S P O S E op(A)=\left\{ \begin{array}{rcl} X& {if transX == CUSPARSE_OPERATION_NON_TRANSPOSE}\\ X^T& {if transX == CUSPARSE_OPERATION_TRANSPOSE}\\ X^H& {if transX == CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right. op(A)=⎩⎨⎧XXTXHiftransX==CUSPARSEOPERATIONNONTRANSPOSEiftransX==CUSPARSEOPERATIONTRANSPOSEiftransX==CUSPARSEOPERATIONCONJUGATETRANSPOSE
且op(B)和op(X)是相同的
BSR格式的块大小为blockDim * blockDim，存储在由参数dirA确定的列为主或行为主的，该参数为CUSPARSE_DIRECTION_ROW或CUSPARSE_DIRECTION_COLUMN。矩阵类型必须为CUSPARSE_MATRIX_TYPE_GENERAL，并且填充模式和对角线类型将被忽略。
预期对于给定的矩阵和特定的操作类型，此函数将仅执行一次。
此函数需要bsrsm2_bufferSize（）返回的缓冲区大小。 pBuffer的地址必须是128个字节的倍数。如果不是，则返回CUSPARSE_STATUS_INVALID_VALUE。
函数bsrsm2_analysis（）报告结构零，并计算存储在不透明结构info中的级别信息。级别信息可以在三角形求解器中提取更多的并行度。但是，可以在没有级别信息的情况下完成bsrsm2_solve（）。要禁用级别信息，用户需要将三角求解器的策略指定为CUSPARSE_SOLVE_POLICY_NO_LEVEL。
函数bsrsm2_analysis（）始终报告第一个结构零，即使参数policy为CUSPARSE_SOLVE_POLICY_NO_LEVEL。此外，即使指定了CUSPARSE_DIAG_TYPE_UNIT，也不会报告结构零，即使对于某些j而言，块A（j，j）也不存在。用户必须调用cusparseXbsrsm2_query_zero_pivot（）才能知道结构零在哪里。
如果bsrsm2_analysis（）报告结构零，则求解将在与结构零相同的位置返回数字零，但结果X毫无意义。
- 此功能需要在内部分配的临时额外存储空间
- 例程不支持异步执行
- 例程不支持CUDA图形捕获
输入
| 参数 | 含义 |
|---|---|
handle | 处理cuSPARSE库上下文的句柄 |
dir | 块的存储格式，CUSPARSE_DIRECTION_ROW或CUSPARSE_DIRECTION_COLUMN |
transA | 操作op(A) |
transX | 操作op(B)和op(X) |
mb | 矩阵A的块行数 |
n | 矩阵op(B)的列数 |
nnzb | 稀疏矩阵A的非零块数。 |
descrA | 矩阵A的描述符。支持的矩阵类型为CUSPARSE_MATRIX_TYPE_GENERAL。支持的对角线类型为CUSPARSE_DIAG_TYPE_UNIT和CUSPARSE_DIAG_TYPE_NON_UNIT。 |
bsrValA | 矩阵A的nnzb(=bsrRowPtrA(mb) - bsrRowPtrA(0))非零块的数组。 |
bsrRowPtrA | mb + 1个元素的整数数组，包含每个块行的开头和最后一个块行的结尾加1。 |
bsrColIndA | 矩阵A的非零块的nnzb(=bsrRowPtrA(mb) - bsrRowPtrA(0))列索引的整数数组。 |
blockDim | 稀疏矩阵A的块的维数，大于0 |
info | 使用cusparseCreateBsrsm2Info初始化的结构 |
policy | 支持的策略为CUSPARSE_SOLVE_POLICY_NO_LEVEL和CUSPARSE_SOLVE_POLICY_USE_LEVEL。 |
pBuffer | 用户分配的缓冲区；大小由bsrsm2_bufferSize（）返回。 |
输出
| 值 | 含义 |
|---|---|
info | 填充了在分析阶段收集的结构信息（应原样传递到求解阶段） |
cusparse<t>bsrsm2_solve()
cusparseStatus_t
cusparse<t>bsrsm2_solve(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transX,
int mb,
int n,
int nnzb,
const <t>* alpha,
const cusparseMatDescr_t descrA,
const <t>* bsrSortedVal,
const int* bsrSortedRowPtr,
const int* bsrSortedColInd,
int blockDim,
bsrsm2Info_t info,
const <t>* B,
int ldb,
<t>* X,
int ldx,
cusparseSolvePolicy_t policy,
void* pBuffer)
此函数执行稀疏三角线性系统的解的求解阶段：
op(A) * op(X) = α * op(B)
A是一个（mb * blockDim）x（mb * blockDim）稀疏矩阵，由三个数组bsrValA，bsrRowPtrA和bsrColIndA以BSR存储格式定义； B和X是右侧和解矩阵；α是标量；
o p ( A ) = { A i f t r a n s A = = C U S P A R S E O P E R A T I O N N O N T R A N S P O S E A T i f t r a n s A = = C U S P A R S E O P E R A T I O N T R A N S P O S E A H i f t r a n s A = = C U S P A R S E O P E R A T I O N C O N J U G A T E T R A N S P O S E op(A)=\left\{ \begin{array}{rcl} A& {if transA == CUSPARSE_OPERATION_NON_TRANSPOSE}\\ A^T& {if transA == CUSPARSE_OPERATION_TRANSPOSE}\\ A^H& {if transA == CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right. op(A)=⎩⎨⎧AATAHiftransA==CUSPARSEOPERATIONNONTRANSPOSEiftransA==CUSPARSEOPERATIONTRANSPOSEiftransA==CUSPARSEOPERATIONCONJUGATETRANSPOSE
o p ( A ) = { X i f t r a n s X = = C U S P A R S E O P E R A T I O N N O N T R A N S P O S E X T i f t r a n s X = = C U S P A R S E O P E R A T I O N T R A N S P O S E X H n o t s u p p o r t e d op(A)=\left\{ \begin{array}{rcl} X& {if transX == CUSPARSE_OPERATION_NON_TRANSPOSE}\\ X^T& {if transX == CUSPARSE_OPERATION_TRANSPOSE}\\ X^H& {not supported} \end{array} \right. op(A)=⎩⎨⎧XXTXHiftransX==CUSPARSEOPERATIONNONTRANSPOSEiftransX==CUSPARSEOPERATIONTRANSPOSEnotsupported
只有op(A) = A 是支持的
op(B)和op(X)必须以相同的方式执行。换句话说，如果op(B)= B，则op(X)= X。
BSR格式的块大小为blockDim * blockDim，存储在由参数dirA确定的列为主或行为主的，该参数为CUSPARSE_DIRECTION_ROW或CUSPARSE_DIRECTION_COLUMN。矩阵类型必须为CUSPARSE_MATRIX_TYPE_GENERAL，并且填充模式和对角线类型将被忽略。函数bsrsm02_solve()可以支持任意的blockDim。
预期对于给定的矩阵和特定的操作类型，此函数可以会执行多次。
此函数需要bsrsm2_bufferSize（）返回的缓冲区大小。 pBuffer的地址必须是128个字节的倍数。如果不是，则返回CUSPARSE_STATUS_INVALID_VALUE。
尽管bsrsm2_solve（）可以在没有级别信息的情况下完成，但用户仍然需要注意一致性。如果使用策略CUSPARSE_SOLVE_POLICY_USE_LEVEL调用bsrsm2_analysis（），则bsrsm2_solve（）可以有或没有级别运行。另一方面，如果使用CUSPARSE_SOLVE_POLICY_NO_LEVEL调用bsrsm2_analysis（），则bsrsm2_solve（）只能接受CUSPARSE_SOLVE_POLICY_NO_LEVEL；否则，将返回CUSPARSE_STATUS_INVALID_VALUE。
函数bsrsm02_solve（）与bsrsv02_solve（）具有相同的行为，报告了第一个数字零，包括结构零。用户必须调用cusparseXbsrsm2_query_zero_pivot（）才能知道数字零在哪里。
transpose（X）的动机是改善矩阵X的内存访问。具有矩阵X的列优先顺序的transpose（X）的计算模式等效于具有矩阵X的行优先顺序的X。
支持原地修改，要求B和X指向同一内存块，并且ldb = ldx。
如果pBuffer！= NULL，该函数支持以下属性：
- 例程不需要额外的存储空间
- 例程支持异步执行
- 例程支持CUDA图形捕获
输入
| 值 | 含义 |
|---|---|
handle | 处理cuSparse库的上下文句柄 |
dirA | 块的存储格式，CUSPARSE_DIRECTION_ROW或CUSPARSE_DIRECTION_COLUMN。 |
transA | 操作op(A) |
transX | 操作op(B)和op(X) |
mb | 矩阵A的块行数 |
n | 矩阵op(B)和op(X)的列数 |
nnzb | 稀疏矩阵A的非零块数。 |
alpha | 用于乘法的标量 |
descrA | 矩阵A的描述符。支持的矩阵类型为CUSPARSE_MATRIX_TYPE_GENERAL。支持的对角线类型为CUSPARSE_DIAG_TYPE_UNIT和CUSPARSE_DIAG_TYPE_NON_UNIT。 |
bsrValA | 矩阵A的nnzb(=bsrRowPtrA(mb) - bsrRowPtrA(0))非零块的数组。 |
bsrRowPtrA | mb + 1个元素的整数数组，包含每个块行的开头和最后一个块行的结尾加1。 |
bsrColIndA | 矩阵A的非零块的nnzb(=bsrRowPtrA(mb) - bsrRowPtrA(0))列索引的整数数组。 |
blockDim | 稀疏矩阵A的块的维数，大于0 |
info | cusparse<t>bsrsm2_analysis()的输出info |
B | 右侧数组 |
ldb | 如果op（B）= B，则ldb> =（mb * blockDim）;否则ldb> = n。 |
ldx | 如果op（X）= X，则ldx> =（mb * blockDim）;否则ldx> = n。 |
policy | 支持的策略为CUSPARSE_SOLVE_POLICY_NO_LEVEL和CUSPARSE_SOLVE_POLICY_USE_LEVEL。 |
pBuffer | 用户分配的缓冲区；大小由bsrsm2_bufferSize（）返回。 |
输出
| 值 | 含义 |
|---|---|
| X | 结果 |
扫一扫
4449
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
