前言

级别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`

看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*nconst int m = mb*blockSize;const int k = kb*blockSize;const int ldb_B = k; // leading dimension of Bconst int ldc   = m; // leading dimension of C
// perform C:=alpha*A*B + beta*CcusparseSetMatType(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 BtcudaMalloc((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*CcusparseDbsrmm(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 ) = { 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。

预期对于给定的矩阵和特定的操作类型，此函数可以会执行多次。

此函数需要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	结果

`cusparseXbsrsm2_zeroPivot()`

`cusparse<t>csrsm2_bufferSizeExt()`

`cusparse<t>csrsm2_analysis()`

`cusparse<t>csrsm2_solve()`

`cusparseXcsrsm2_zeroPivot()`

`cusparsegemmi() [DEPRECATED]`

cuSPARSE库官方文档部分翻译相关推荐

python pymssql - pymssql模块官方文档的翻译
译者注:译者博客(http://blog.csdn.net/lin_strong),转载请保留这条.此为pymssql模块version2.1.4官方文档的翻译,仅供学习交流使用,请勿用于商业用途. ...
【开源项目推荐】Android Jetpack 官方文档中文翻译
Jetpack 是 Android 软件组件的集合,使您可以更轻松地开发出色的 Android 应用.这些组件可帮助您遵循最佳做法.让您摆脱编写样板代码的工作并简化复杂任务,以便您将精力集中放在所需的 ...
python的pymssql模块的报错_python pymssql - pymssql模块官方文档的翻译
译者注:译者博客(http://blog.csdn.net/lin_strong),转载请保留这条.此为pymssql模块version2.1.4官方文档的翻译,仅供学习交流使用,请勿用于商业用途. ...
CUDA10.0官方文档的翻译与学习之编程接口
目录背景用nvcc编译编译工作流二进制适配性 ptx适配性应用适配性 C/C++适配性 64位适配性 cuda c运行时初始化设备内存共享内存页锁主机内存可移植内存写合并内存映 ...
Pytorch官方文档英语翻译
深度学习Pytorch-Pytorch官方文档英语翻译 1. a-e 1.1 span 跨度 1.2 blended 混合的 1.3 criterion 标准 1.4 deprecated 弃用的 1 ...
Spring官方文档中文翻译
准备做个Spring官方文档全翻译专栏以下是大目录, 本翻译是基于Spring5 Core Technologies
ElasticSearch Java High level Rest Client 官方文档中文翻译(一)
ElasticSearch Java High level Rest Client 官方文档中文翻译一纯粹记录自己在看官网的es rest high level api 时的翻译笔记,可以对照着官 ...
AsyncDisplayKit官方文档个人翻译
迁移老文章到掘金文档比较老了,不适用最新的2.0 AsyncDisplayKit 官方文档最近在拆解学习AsyncDisplayKit这个很知名的轮子,发现这个轮子内容还是非常庞大的,想要分解学习 ...
iOS 9官方文档（翻译）
iOS9已经发布一段时间了,我也在最近升级了Xcdoe 7.0正式版,升级后才发现又有了很多奇妙的变化,于是查看官方文档的一些解释,顺便做了一些翻译,和大家分享一下(转载请注明出处). iPad多任务 ...

cuSPARSE库官方文档部分翻译

前言

cuSparse管理函数

1. cusparseCreate()

2.cusparseDestroy()

3. cusparseGetErrorString()

4.cusparseGetProperty()

5.cusparseGetVersion()

6.cusparseGetPointerMode()

7.cusparseSetPointerMode()

8.cusparseGetStream()

9. cusparseSetStream()

cuSparse帮助函数

1.cusparseCreate/DestroyColorInfo()

2. cusparseCreate/DestroyMatDescr()

3. cusparseSet/GetMatDiagType()

cusparseDiagType_t

4. cusparseSet/GetMatFillMode()

cusparseFillMode_t

5. cusparseSet/GetMatIndexBase()

cusparseIndexBase_t

6. cusparseSet/GetMatType()

cusparseMatrixType_t

7. cusparseCreate/DestroyCsrsv2Info()

8. cusparseCreate/DestroyCsrsm2Info()

9. cusparseCreate/DestroyCsric02Info()

10. cusparseCreate/DestroyCsrilu02Info()

11. cusparseCreate/DestroyBsrsv2Info()

12. cusparseCreate/DestroyBsrsm2Info()

13. cusparseCreate/DestroyBsric02Info()

14. cusparseCreate/DestroyBsrilu02Info()

15. cusparseCreate/DestroyCsrgemm2Info()

16. cusparseCreate/DestroyPruneInfo()

cuSparse库三级功能参考

cusparse<t>bsrmm()

输入

输出

cusparse<t>bsrsm2_bufferSize()

输入

cusparse<t>bsrsm2_analysis()

输入

输出

cusparse<t>bsrsm2_solve()

输入

输出

cusparseXbsrsm2_zeroPivot()

cusparse<t>csrsm2_bufferSizeExt()

cusparse<t>csrsm2_analysis()

cusparse<t>csrsm2_solve()

cusparseXcsrsm2_zeroPivot()

cusparsegemmi() [DEPRECATED]