13. mcSPARSE 格式转换参考
本章介绍了不同稀疏和稠密存储格式之间的转换程序。
13.1. mcsparse<t>csr2gebsr()
mcsparseStatus_t
mcsparseScsr2gebsr_bufferSize(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
int rowBlockDim,
int colBlockDim,
int* pBufferSize)
mcsparseStatus_t
mcsparseDcsr2gebsr_bufferSize(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
int rowBlockDim,
int colBlockDim,
int* pBufferSize)
mcsparseStatus_t
mcsparseCcsr2gebsr_bufferSize(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
int rowBlockDim,
int colBlockDim,
int* pBufferSize)
mcsparseStatus_t
mcsparseZcsr2gebsr_bufferSize(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
int rowBlockDim,
int colBlockDim,
int* pBufferSize)
mcsparseStatus_t
mcsparseXcsr2gebsrNnz(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const int* csrRowPtrA,
const int* csrColIndA,
const mcsparseMatDescr_t descrC,
int* bsrRowPtrC,
int rowBlockDim,
int colBlockDim,
int* nnzTotalDevHostPtr,
void* pBuffer)
mcsparseStatus_t
mcsparseScsr2gebsr(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
const mcsparseMatDescr_t descrC,
float* bsrValC,
int* bsrRowPtrC,
int* bsrColIndC,
int rowBlockDim,
int colBlockDim,
void* pBuffer)
mcsparseStatus_t
mcsparseDcsr2gebsr(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
const mcsparseMatDescr_t descrC,
double* bsrValC,
int* bsrRowPtrC,
int* bsrColIndC,
int rowBlockDim,
int colBlockDim,
void* pBuffer)
mcsparseStatus_t
mcsparseCcsr2gebsr(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
const mcsparseMatDescr_t descrC,
mcComplex* bsrValC,
int* bsrRowPtrC,
int* bsrColIndC,
int rowBlockDim,
int colBlockDim,
void* pBuffer)
mcsparseStatus_t
mcsparseZcsr2gebsr(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
const mcsparseMatDescr_t descrC,
mcDoubleComplex* bsrValC,
int* bsrRowPtrC,
int* bsrColIndC,
int rowBlockDim,
int colBlockDim,
void* pBuffer)
此函数将以CSR格式(由数组 csrValA、 csrRowPtrA 和 csrColIndA 定义)的稀疏矩阵 A 转换为以一般BSR格式定义的稀疏矩阵 C (由三个数组 bsrValC、 bsrRowPtrC 和 bsrColIndC 定义)。
矩阵A是一个大小为 m*n 的稀疏矩阵，矩阵 C 是一个大小为 (mb*rowBlockDim)*(nb*colBlockDim) 的稀疏矩阵，其中 mb(=(m+rowBlockDim-1)/rowBlockDim) 是 C 的块行数， nb(=(n+colBlockDim-1)/colBlockDim) 是 C 的块列数。
矩阵 C 的块大小为 rowBlockDim*colBlockDim。
如果 m 不是 rowBlockDim 的倍数或者 n 不是 colBlockDim 的倍数，将填充零值。
该实现通过以下操作进行转换：
首先，用户分配了大小为 mb+1 的 bsrRowPtrC 数组，并使用函数 mcsparseXcsr2gebsrNnz() 来确定每个块行中的非零块列数。
其次，用户从 nnzb=*nnzTotalDevHostPtr 或者 nnzb=bsrRowPtrC[mb]-bsrRowPtrC[0] 中获取了 nnzb ( 矩阵 C 的非零块列数)，并分配了大小为 nnzb*rowBlockDim*colBlockDim 的 bsrValC 数组和大小为 nnzb 的整数数组 bsrColIndC。
最后，调用函数 mcsparse[S|D|C|Z]csr2gebsr() 完成转换。
用户必须通过调用 csr2gebsr_bufferSize() 来获取 csr2gebsr() 所需的缓冲区大小，然后分配缓冲区，并将缓冲区指针传递给 csr2gebsr()。
一般程序如下所示：
// 给定CSR格式(csrRowPtrA、csrColIndA、csrValA)和 // BSR格式的块以列优先顺序存储。 mcsparseDirection_t dir = MCSPARSE_DIRECTION_COLUMN; int base, nnzb; int mb = (m + rowBlockDim-1)/rowBlockDim; int nb = (n + colBlockDim-1)/colBlockDim; int bufferSize; void *pBuffer; mcsparseScsr2gebsr_bufferSize(handle, dir, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, rowBlockDim, colBlockDim, &bufferSize); mcMalloc((void**)&pBuffer, bufferSize); mcMalloc((void**)&bsrRowPtrC, sizeof(int) *(mb+1)); // nnzTotalDevHostPtr 指向主机内存 int *nnzTotalDevHostPtr = &nnzb; mcsparseXcsr2gebsrNnz(handle, dir, m, n, descrA, csrRowPtrA, csrColIndA, descrC, bsrRowPtrC, rowBlockDim, colBlockDim, nnzTotalDevHostPtr, pBuffer); if (NULL != nnzTotalDevHostPtr){ nnzb = *nnzTotalDevHostPtr; }else{ mcMemcpy(&nnzb, bsrRowPtrC+mb, sizeof(int), mcMemcpyDeviceToHost); mcMemcpy(&base, bsrRowPtrC, sizeof(int), mcMemcpyDeviceToHost); nnzb -= base; } mcMalloc((void**)&bsrColIndC, sizeof(int)*nnzb); mcMalloc((void**)&bsrValC, sizeof(float)*(rowBlockDim*colBlockDim)*nnzb); mcsparseScsr2gebsr(handle, dir, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, descrC, bsrValC, bsrRowPtrC, bsrColIndC, rowBlockDim, colBlockDim, pBuffer);
函数
mcsparseXcsr2gebsrNnz()具有以下特点：此函数需要内部分配的临时额外存储空间。
如果流式有序内存分配器可用，则该例程支持异步执行。
如果
pBuffer != NULL，函数mcsparse<t>csr2gebsr()具有以下特点：
该程序支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
dir块的存储格式，可以是
MCSPARSE_DIRECTION_ROW或MCSPARSE_DIRECTION_COLUMN
m稀疏矩阵
A的行数。
n稀疏矩阵
A的列数。
descrA矩阵
A的描述符。 支持的矩阵类型为MCSPARSE_MATRIX_TYPE_GENERAL。 此外，支持的索引基数为MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。
csrValA<type> 矩阵A中
nnz个非零元素的数组。
csrRowPtrA包含m+1个元素，中每个元素表示每一行的起始位置和其 最后一行的结束位置加一。
csrColIndA整数数组，包含矩阵
A中nnz个非零元素的 列索引
descrC矩阵
C的描述符。 支持的矩阵类型是MCSPARSE_MATRIX_TYPE_GENERAL。 此外，支持的索引基数为MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。
rowBlockDim稀疏矩阵
C的行数。
colBlockDim稀疏矩阵
C的列数。
pBuffer由用户分配的缓冲区，在
csr2gebsr_bufferSize()中返回其大小。输出
bsrValC<type> 矩阵
C的nnzb*rowBlockDim*colBlockDim个非零元素 的数组。
bsrRowPtrC一个包含 mb+1 个元素的整数数组，其中包含 矩阵 C 的每个块行的起始位置，以及最后一个 块行的结束位置加一。
bsrColIndC整数数组包含矩阵
C的nnzb个非零块 的列索引。
nnzTotalDevHostPtr矩阵
C的非零块总数。 指针nnzTotalDevHostPtr可以指向 设备内存或主机内存。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.2. mcsparse<t>coo2csr()
mcsparseStatus_t
mcsparseXcoo2csr(mcsparseHandle_t handle,
const int* cooRowInd,
int nnz,
int m,
int* csrRowPtr,
mcsparseIndexBase_t idxBase)
此函数将包含未压缩的行索引数组(对应COO格式)转换为包含压缩的行指针数组(对应CSR格式)。
它还可以用于将包含未压缩列索引数组(对应COO格式)转换为包含列指针的数组(对应CSC格式)。
该例程不需要额外的存储空间。
该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
cooRowInd整型数组，包含
nnz个未压缩的行索引。nnz稀疏矩阵的非零个数(也就是数组
cooRowInd的长度)m矩阵
A的行数。idxBaseMCSPARSE_INDEX_BASE_ZERO或MCSPARSE_INDEX_BASE_ONE。输出
csrRowPtr由
m+1个元素组成的整型数组，包含每行的起 始位置和最后一行的结束位置加一。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.3. mcsparse<t>csc2dense()
mcsparseStatus_t
mcsparseScsc2dense(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const float* cscValA,
const int* cscRowIndA,
const int* cscColPtrA,
float* A,
int lda)
mcsparseStatus_t
mcsparseDcsc2dense(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const double* cscValA,
const int* cscRowIndA,
const int* cscColPtrA,
double* A,
int lda)
mcsparseStatus_t
mcsparseCcsc2dense(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcComplex* cscValA,
const int* cscRowIndA,
const int* cscColPtrA,
mcComplex* A,
int lda)
mcsparseStatus_t
mcsparseZcsc2dense(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* cscValA,
const int* cscRowIndA,
const int* cscColPtrA,
mcDoubleComplex* A,
int lda)
此函数将CSC格式的稀疏矩阵转换为稠密格式的矩阵 A，其中CSC格式通过 cscValA， cscColPtrA 和 cscRowIndA 三个数组定义。
稠密矩阵 A 用稀疏矩阵的值填充，其余地方用零填充。
该例程不需要额外的存储空间。
该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
m矩阵
A的行数。n矩阵
A的列数。descrA矩阵
A的描述符。 支持的矩阵类型为MCSPARSE_MATRIX_TYPE_GENERAL。 同时，支持的索引基数是MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。cscValA<type>数组，包含矩阵
A中nnz个非零元素。cscRowIndA整型数组，包含矩阵
A中nnz个非零元素的行索引。cscColPtrA由
n+1个元素组成的整型数组， 包含每行的起始位置和最后一列的结 束位置加一。lda稠密数组
A的主维度。输出
A维度为
(lda, n)的数组，其中填充了稀疏矩阵的值。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.4. mcsparse<t>csr2bsr()
mcsparseStatus_t
mcsparseXcsr2bsrNnz(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const int* csrRowPtrA,
const int* csrColIndA,
int blockDim,
const mcsparseMatDescr_t descrC,
int* bsrRowPtrC,
int* nnzTotalDevHostPtr)
mcsparseStatus_t
mcsparseScsr2bsr(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
int blockDim,
const mcsparseMatDescr_t descrC,
float* bsrValC,
int* bsrRowPtrC,
int* bsrColIndC)
mcsparseStatus_t
mcsparseDcsr2bsr(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
int blockDim,
const mcsparseMatDescr_t descrC,
double* bsrValC,
int* bsrRowPtrC,
int* bsrColIndC)
mcsparseStatus_t
mcsparseCcsr2bsr(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
int blockDim,
const mcsparseMatDescr_t descrC,
mcComplex* bsrValC,
int* bsrRowPtrC,
int* bsrColIndC)
mcsparseStatus_t
mcsparseZcsr2bsr(mcsparseHandle_t handle,
mcsparseDirection_t dir,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
int blockDim,
const mcsparseMatDescr_t descrC,
mcDoubleComplex* bsrValC,
int* bsrRowPtrC,
int* bsrColIndC)
此函数将CSR格式的稀疏矩阵转换为BSR格式的稀疏矩阵，其中CSR格式通过三个数组 csrValA， csrRowPtrA 和 csrColIndA 定义， BSR格式通过数组 bsrValC， bsrRowPtrC，和 bsrColIndC 定义。
A 是一个 m*n 稀疏矩阵。
A 的BSR格式具有 mb 块行， nb 块列和 nnzb 非零块，其中 mb=((m+blockDim-1)/blockDim) 和 nb=(n+blockDim-1)/blockDim。
如果 m 或 n 不是 blockDim 的倍数，则填充零。
mcSPARSE中的转换通过以下操作实现。
首先，用户分配 mb+1 元素的 bsrRowPtrC，并使用函数 mcsparseXcsr2bsrNnz() 来确定每个块行的非零块列的数量。
其次，用户从 (nnzb=*nnzTotalDevHostPtr) 或 (nnzb=bsrRowPtrC[mb]-bsrRowPtrC[0]) 中收集 nnzb (矩阵 C 的非零块列数)并分配 nnzb*blockDim*blockDim 个 bsrValC 元素和 nnzb 个 bsrColIndC 元素。
最后调用函数 mcsparse[S|D|C|Z]csr2bsr90 来完成转换。
一般程序如下：
// 给定CSR格式(csrRowPtrA, csrcolIndA, csrValA)和 // BSR格式的块按列主序的顺序存储。 mcsparseDirection_t dir = MCSPARSE_DIRECTION_COLUMN; int base, nnzb; int mb = (m + blockDim-1)/blockDim; mcMalloc((void**)&bsrRowPtrC, sizeof(int) *(mb+1)); // nnzTotalDevHostPtr指向主机内存 int *nnzTotalDevHostPtr = &nnzb; mcsparseXcsr2bsrNnz(handle, dir, m, n, descrA, csrRowPtrA, csrColIndA, blockDim, descrC, bsrRowPtrC, nnzTotalDevHostPtr); if (NULL != nnzTotalDevHostPtr){ nnzb = *nnzTotalDevHostPtr; }else{ mcMemcpy(&nnzb, bsrRowPtrC+mb, sizeof(int), mcMemcpyDeviceToHost); mcMemcpy(&base, bsrRowPtrC, sizeof(int), mcMemcpyDeviceToHost); nnzb -= base; } mcMalloc((void**)&bsrColIndC, sizeof(int)*nnzb); mcMalloc((void**)&bsrValC, sizeof(float)*(blockDim*blockDim)*nnzb); mcsparseScsr2bsr(handle, dir, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, blockDim, descrC, bsrValC, bsrRowPtrC, bsrColIndC);
例程 mcsparse<t>csr2bsr() 具有以下特性：
如果
blockDim > 16，此函数需要在内部分配临时的额外存储空间。如果
blockDim != 1并且流式有序内存分配器可用，则例程支持异步执行
例程 mcsparseXcsr2bsrNnz() 具有以下特性：
此函数需要内部分配的临时额外存储空间。
如果流式有序内存分配器可用，则该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
dir块的存储格式
MCSPARSE_DIRECTION_ROW或MCSPARSE_DIRECTION_COLUMN。m稀疏矩阵
A的行数。n稀疏矩阵
A的列数。descrA矩阵
A的描述符。csrValA<type> 数组，包含
nnz(=csrRowPtrA[m]-csrRowPtr[0])个矩阵A的非零元素。csrRowPtrA由
m+1个元素组成的整型数组，包含每行的起 始位置和最后一行的结束位置加一。csrColIndAcsrColIndA整型数组，包含矩阵
A中nnz个非零元素的 列索引。blockDim稀疏矩阵
A的块维度。blockDim的取值范围 在1到min(m,n)之间。descrC矩阵
C的描述符。输出
bsrValC<type> 数组，包含
nnzb*blockDim*blockDim个矩阵C的 非零元素。bsrRowPtrC由
mb+1个元素组成的整型数组，包含 每行的起始位置和最后一行的结束位置加一。bsrColIndC整型数组，包含矩阵
C中nnzb个 非零块的列索引。nnzTotalDevHostPtr设备或主机内存中非零元素的总数。它等于
(bsrRowPtrC[mb]-bsrRowPtrC[0])。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.5. mcsparse<t>csr2coo()
mcsparseStatus_t
mcsparseXcsr2coo(mcsparseHandle_t handle,
const int* csrRowPtr,
int nnz,
int m,
int* cooRowInd,
mcsparseIndexBase_t idxBase)
此函数将包含压缩的行指针数组(对应CSR格式)转换为未压缩的行索引数组(对应COO格式)。
此函数还可以用于将包含压缩的列索引数组(对应CSC格式)转换为包含未压缩列索引的数组(对应COO格式)。
该例程不需要额外的存储空间。
该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
csrRowPtr由
m+1个元素组成的整型数组，包含每行的起始位 置和最后一行的结束位置加一。nnz稀疏矩阵的非零个数(也是数组
cooRowInd的长度)。m矩阵
A的列数。idxBaseMCSPARSE_INDEX_BASE_ZERO或MCSPARSE_INDEX_BASE_ONE。输出
cooRowInd整型数组，包含
nnz个未压缩的行索引。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.6. mcsparse<t>csr2dense()
mcsparseStatus_t
mcsparseScsr2dense(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
float* A,
int lda)
mcsparseStatus_t
mcsparseDcsr2dense(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
double* A,
int lda)
mcsparseStatus_t
mcsparseCcsr2dense(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
mcComplex* A,
int lda)
mcsparseStatus_t
mcsparseZcsr2dense(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
mcDoubleComplex* A,
int lda)
此函数将CSR格式的稀疏矩阵转换为稠密格式的矩阵 A，其中CSR格式通过三个数组 csrValA，csrRowPtrA 和 csrColIndA 定义。
稠密矩阵 A 用稀疏矩阵的值填充，其余地方用零填充。
该例程不需要额外的存储空间。
该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
m矩阵的行数。
n矩阵的列数。
descrA矩阵的描述符。 支持的矩阵大小为
MCSPARSE_MATRIX_TYPE_GENERAL同时也支持索引基数为MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。csrValA<type>数组，包含 矩阵中
nnz个的非零元素。csrRowPtrA由
m+1个元素组成的整型数组， 包含每行起始位置和最后一行的 结束位置加一。csrColIndA整型数组，包含矩阵中
nnz个 非零元素的列索引。lda数组矩阵
A主维度输出
A维度为
(lda,n)的数组。用稀疏矩阵的值填充。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.7. mcsparse<t>csr2csr_compress()
mcsparseStatus_t
mcsparseScsr2csr_compress(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrColIndA,
const int* csrRowPtrA,
int nnzA,
const int* nnzPerRow,
float* csrValC,
int* csrColIndC,
int* csrRowPtrC,
float tol)
mcsparseStatus_t
mcsparseDcsr2csr_compress(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrColIndA,
const int* csrRowPtrA,
int nnzA,
const int* nnzPerRow,
double* csrValC,
int* csrColIndC,
int* csrRowPtrC,
double tol)
mcsparseStatus_t
mcsparseCcsr2csr_compress(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcComplex* csrValA,
const int* csrColIndA,
const int* csrRowPtrA,
int nnzA,
const int* nnzPerRow,
mcComplex* csrValC,
int* csrColIndC,
int* csrRowPtrC,
mcComplex tol)
mcsparseStatus_t
mcsparseZcsr2csr_compress(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* csrValA,
const int* csrColIndA,
const int* csrRowPtrA,
int nnzA,
const int* nnzPerRow,
mcDoubleComplex* csrValC,
int* csrColIndC,
int* csrRowPtrC,
mcDoubleComplex tol)
此函数将CSR格式的稀疏矩阵压缩成压缩的CSR格式。 给定一个稀疏矩阵A和一个非负阈值，此函数返回一个稀疏矩阵C。
该实现通过以下操作进行转换：
首先，用户分配m+1个元素的csrRowPtrC，并使用函数 mcsparse<t>nnz_compress() 确定nnzPerRow（每行非零列的数量）和nnzC（非零总数）。
其次，用户分配nnzC个元素的csrValC和nnzC个整型的csrColIndC。
最后调用函数 mcsparse<t>csr2csr_compress() 来完成转换。
此函数需要内部分配的临时额外存储空间。
如果流式有序内存分配器可用，则该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
m矩阵的行数。
n矩阵的列数。
descrA矩阵的描述符。 支持的矩阵大小为
MCSPARSE_MATRIX_TYPE_GENERAL同时也支持索引基数为MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。csrValA<type>数组，包含矩阵中
nnz个元素。csrColIndA整型数组，包含矩阵中
nnz个 元素的列索引。csrRowPtrA由
m+1个元素组成的整型数组， 其中包含每行的起始位置和最后一行的 结束位置加一。nnzA矩阵的非零元素数。
nnzPerRow该数组包含按行存储压缩矩阵中的元素 数量。
tol
在输入时，它包含用于压缩的非负容差 值。在压缩过程中。矩阵A中小于或等 于该值的任何值都将被丢弃。
输出
csrValC在输出时，该数组包含存储在压缩矩阵中的元素的类型值 Size =nnzC。
csrColIndC在输出时，该整型数组包含存储在压缩矩阵中元素的列索 引。 Size = nnzC。
csrRowPtrC在输出时，该整型数组包含存储在压缩矩阵中的元素的行 指针。Size = m+1。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
下面代码段演示如何使用此API。
#include <stdio.h> #include <sys/time.h> #include <mcsparse.h> #define ERR_NE(X,Y) do { if ((X) != (Y)) { \ fprintf(stderr,"Error in %s at %s:%d\n",__func__,__FILE__,__LINE__);\ exit(-1);}} while(0) #define MACA_CALL(X) ERR_NE((X),macaSuccess) #define MCSPARSE_CALL(X) ERR_NE((X),MCSPARSE_STATUS_SUCCESS) int main(){ int m = 6, n = 5; mcsparseHandle_t handle; MCSPARSE_CALL( mcsparseCreate(&handle) ); mcsparseMatDescr_t descrX; MCSPARSE_CALL(mcsparseCreateMatDescr(&descrX)); // 初始化稀疏矩阵 float *X; MACA_CALL(mcMallocManaged( &X, sizeof(float) * m * n )); memset( X, 0, sizeof(float) * m * n ); X[0 + 0*m] = 1.0; X[0 + 1*m] = 3.0; X[1 + 1*m] = -4.0; X[1 + 2*m] = 5.0; X[2 + 0*m] = 2.0; X[2 + 3*m] = 7.0; X[2 + 4*m] = 8.0; X[3 + 2*m] = 6.0; X[3 + 4*m] = 9.0; X[4 + 3*m] = 3.5; X[4 + 4*m] = 5.5; X[5 + 0*m] = 6.5; X[5 + 2*m] = -9.9; // 为了mcsparseSdense2csr()，初始化total_nnz和nzPerRowX int total_nnz = 13; int *nnzPerRowX; MACA_CALL( mcMallocManaged( &nnzPerRowX, sizeof(int) * m )); nnzPerRowX[0] = 2; nnzPerRowX[1] = 2; nnzPerRowX[2] = 3; nnzPerRowX[3] = 2; nnzPerRowX[4] = 2; nnzPerRowX[5] = 2; float *csrValX; int *csrRowPtrX; int *csrColIndX; MACA_CALL( mcMallocManaged( &csrValX, sizeof(float) * total_nnz) ); MACA_CALL( mcMallocManaged( &csrRowPtrX, sizeof(int) * (m+1))) ; MACA_CALL( mcMallocManaged( &csrColIndX, sizeof(int) * total_nnz)) ;
在调用此API之前，请调用两个API来准备输入。
/** 调用mcsparseSdense2csr来生成CSR格式，作为 mcsparseScsr2csr_compress的输入 **/ MCSPARSE_CALL( mcsparseSdense2csr( handle, m, n, descrX, X, m, nnzPerRowX, csrValX, csrRowPtrX, csrColIndX )) ; float tol = 3.5; int *nnzPerRowY; int *testNNZTotal; MACA_CALL (mcMallocManaged( &nnzPerRowY, sizeof(int) * m )); MACA_CALL (mcMallocManaged( &testNNZTotal, sizeof(int))); memset( nnzPerRowY, 0, sizeof(int) * m ); // mcsparseSnnz_compress生成nnzPerRowY和testNNZTotal MCSPARSE_CALL( mcsparseSnnz_compress(handle, m, descrX, csrValX, csrRowPtrX, nnzPerRowY, testNNZTotal, tol)); float *csrValY; int *csrRowPtrY; int *csrColIndY; MACA_CALL( mcMallocManaged( &csrValY, sizeof(float) * (*testNNZTotal))); MACA_CALL( mcMallocManaged( &csrRowPtrY, sizeof(int) * (m+1))); MACA_CALL( mcMallocManaged( &csrColIndY, sizeof(int) * (*testNNZTotal))); MCSPARSE_CALL( mcsparseScsr2csr_compress( handle, m, n, descrX, csrValX, csrColIndX, csrRowPtrX, total_nnz, nnzPerRowY, csrValY, csrColIndY, csrRowPtrY, tol)); /* 期望结果 nnzPerRowY: 0 2 2 2 1 2 csrValY: -4 5 7 8 6 9 5.5 6.5 -9.9 csrColIndY: 1 2 3 4 2 4 4 0 2 csrRowPtrY: 0 0 2 4 6 7 9 */ mcFree(X); mcsparseDestroy(handle); mcFree(nnzPerRowX); mcFree(csrValX); mcFree(csrRowPtrX); mcFree(csrColIndX); mcFree(csrValY); mcFree(nnzPerRowY); mcFree(testNNZTotal); mcFree(csrRowPtrY); mcFree(csrColIndY); return 0; }
13.8. mcsparse<t>dense2csc()
mcsparseStatus_t
mcsparseSdense2csc(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const float* A,
int lda,
const int* nnzPerCol,
float* cscValA,
int* cscRowIndA,
int* cscColPtrA)
mcsparseStatus_t
mcsparseDdense2csc(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const double* A,
int lda,
const int* nnzPerCol,
double* cscValA,
int* cscRowIndA,
int* cscColPtrA)
mcsparseStatus_t
mcsparseCdense2csc(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcComplex* A,
int lda,
const int* nnzPerCol,
mcComplex* cscValA,
int* cscRowIndA,
int* cscColPtrA)
mcsparseStatus_t
mcsparseZdense2csc(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* A,
int lda,
const int* nnzPerCol,
mcDoubleComplex* cscValA,
int* cscRowIndA,
int* cscColPtrA)
此函数将稠密格式的矩阵 A 转换为CSC格式的稀疏矩阵。
所有参数都假定是由用户预先分配，并且数组是基于 nnzPerCol 来填充的，可以使用 mcsparse<t>nnz() 来进行预处理计算。
此函数需要内部分配的临时额外存储空间。
如果流式有序内存分配器可用，则该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
m矩阵
A的行数。n矩阵
A的列数。descrA矩阵
A的描述符。 支持的矩阵大小为MCSPARSE_MATRIX_TYPE_GENERAL。 同时也支持索引基数为MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。A维度为
(lda, n)的数组。lda稠密数组
A的主维度。nnzPerCol大小为
n的数组，包含每列非零元素的数量。输出
cscValA<type>数组，包含矩阵
A中nnz个的非零元素 。 只有当copyValues设置为MCSPARSE_ACTION_NUMERIC时， 它才会被填写。cscRowIndA整型数组，包含矩阵
A中nnz个非零元素的行索引。cscColPtrA由
n+1个元素组成的整型数组， 包含每一列的起始位置和最后一列 的结束位置加一。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.9. mcsparse<t>dense2csr()
mcsparseStatus_t
mcsparseSdense2csr(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const float* A,
int lda,
const int* nnzPerRow,
float* csrValA,
int* csrRowPtrA,
int* csrColIndA)
mcsparseStatus_t
mcsparseDdense2csr(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const double* A,
int lda,
const int* nnzPerRow,
double* csrValA,
int* csrRowPtrA,
int* csrColIndA)
mcsparseStatus_t
mcsparseCdense2csr(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcComplex* A,
int lda,
const int* nnzPerRow,
mcComplex* csrValA,
int* csrRowPtrA,
int* csrColIndA)
mcsparseStatus_t
mcsparseZdense2csr(mcsparseHandle_t handle,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* A,
int lda,
const int* nnzPerRow,
mcDoubleComplex* csrValA,
int* csrRowPtrA,
int* csrColIndA)
此函数将稠密格式的矩阵 A 转换为CSR格式的稀疏矩阵。
假设用户预先分配了所有参数，并且数组是根据 nnzPerRow 填充的，这个值可以通过 mcsparse<t>nnz() 进行预先计算。
此函数不需要额外的存储空间。 它在与主机异步执行，可能在结果准备好之前将控制权返回给主机上的应用程序。
此函数需要内部分配的临时额外存储空间
如果流式有序内存分配器可用，则该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
m矩阵
A的行数。n矩阵
A的列数。descrA矩阵
A的描述符。支持的矩阵类型是MCSPARSE_MATRIX_TYPE_GENERAL。 同时，支持的 基准索引是MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。A大小为
(lda, n)的数组。lda稠密数组
A的主维度。nnzPerRow大小为
n的数组，包含每行非零元素的数量。输出
csrValA<type>数组，包含矩阵
A中nnz个非零元素。csrRowPtrA整型数组， 包含
m+1个元素， 其中每个元素表示每一行的起始位置 和最后一行的结束位置加一。csrColIndA整数数组，包含矩阵
A中nnz个非零元素的列索引。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.10. mcsparse<t>nnz()
mcsparseStatus_t
mcsparseSnnz(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
int m,
int n,
const mcsparseMatDescr_t descrA,
const float* A,
int lda,
int* nnzPerRowColumn,
int* nnzTotalDevHostPtr)
mcsparseStatus_t
mcsparseDnnz(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
int m,
int n,
const mcsparseMatDescr_t descrA,
const double* A,
int lda,
int* nnzPerRowColumn,
int* nnzTotalDevHostPtr)
mcsparseStatus_t
mcsparseCnnz(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcComplex* A,
int lda,
int* nnzPerRowColumn,
int* nnzTotalDevHostPtr)
mcsparseStatus_t
mcsparseZnnz(mcsparseHandle_t handle,
mcsparseDirection_t dirA,
int m,
int n,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* A,
int lda,
int* nnzPerRowColumn,
int* nnzTotalDevHostPtr)
此函数计算稠密矩阵中每行或每列的非零元素数量，以及稠密矩阵中总的非零元素数量。
此函数需要内部分配的临时额外存储空间
如果流式有序内存分配器可用，则该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
dirA方向参数，指定是按
MCSPARSE_DIRECTION_ROW还是按MCSPARSE_DIRECTION_COLUMN计算非零元素数量。m矩阵
A的行数。n矩阵
A的列数。descrA矩阵
A的描述符。支持的矩阵类型是MCSPARSE_MATRIX_TYPE_GENERAL。 同时，支持的 基准索引是MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。A大小为
(lda, n)的数组。lda稠密数组
A的主维度。输出
nnzPerRowColumn大小为
m或n的数组， 分别包含每行或每列的非零元素数量。nnzTotalDevHostPtr非零元素的总数，存储在设备或主机内存中。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.11. mcsparseCreateIdentityPermutation()
mcsparseStatus_t
mcsparseCreateIdentityPermutation(mcsparseHandle_t handle,
int n,
int* p);
此函数创建一个单位映射。
输出参数 p 通过 p = 0:1:(n-1) 表示这样的映射。
此函数通常与 coosort、 csrsort 和 cscsort 一起使用。
该例程不需要额外的存储空间
该例程支持异步执行
输入
参数设备或主机含义handle主机处理mcSPARSE库上下文的句柄。
n主机映射的大小。
输出
参数设备或主机含义p设备整数数组，大小为
n。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.12. mcsparseXcoosort()
mcsparseStatus_t
mcsparseXcoosort_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
int nnz,
const int* cooRows,
const int* cooCols,
size_t* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseXcoosortByRow(mcsparseHandle_t handle,
int m,
int n,
int nnz,
int* cooRows,
int* cooCols,
int* P,
void* pBuffer)
mcsparseStatus_t
mcsparseXcoosortByColumn(mcsparseHandle_t handle,
int m,
int n,
int nnz,
int* cooRows,
int* cooCols,
int* P,
void* pBuffer);
此函数对COO格式进行排序。
排序是原地进行的。
用户可以按行或按列对矩阵进行排序。
A 是一个大小为 m×n 的稀疏矩阵，由三个数组 cooVals 、 cooRows 和 cooCols 以COO存储格式定义。
对于矩阵的基准索引没有假设。
coosort 在有符号整数上使用稳定排序，因此 cooRows 或 cooCols 的值可以是负数。
此函数 coosort() 需要通过 coosort_bufferSizeExt() 返回缓冲区大小。
pBuffer 的地址必须是128字节的倍数。如果不是，则返回 MCSPARSE_STATUS_INVALID_VALUE。
参数 P 同时用作输入和输出。
如果用户想要计算排序后的 cooVal，则必须在 coosort() 之前将 P 设置为0:1:(nnz-1)，然后在 coosort() 之后，新的排序值数组满足 cooVal_sorted = cooVal(P)。
备注
维度 m 和 n 没有使用。如果用户不知道 m 或 n 的值，只需传递一个正数值。这种情况通常发生在用户首先只读取一个COO数组，随后需要决定维数 m 或 n 时。
如果
pBuffer != NULL，该例程不需要额外的存储空间如果流式有序内存分配器可用，则该例程支持异步执行
输入
参数设备或主机含义handle主机处理mcSPARSE库上下文的句柄。
m主机矩阵
A的行数。n主机矩阵
A的列数。nnz主机矩阵
A中非零元素的数量。cooRows设备整数数组，包含
nnz个 未排序的A的行索引。cooCols设备整数数组，包含
nnz个 未排序的A的列索引。P设备整数数组，包含
nnz个未排 序元素的映射索引。为构建csrVal，用户需要设置P=0:1:(nnz-1)。pBuffer设备用户分配的缓冲区；缓冲区的大小 由
coosort_bufferSizeExt()返回。输出
参数设备或主机含义cooRows设备整数数组，包含
nnz个排序后的A的行索引。cooCols设备整数数组，包含
nnz个排序后的A的列索引。P设备整数数组，包含
nnz个排序后的映射索引。pBufferSizeInBytes主机缓冲区的字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.13. mcsparseXcsrsort()
mcsparseStatus_t
mcsparseXcsrsort_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
int nnz,
const int* csrRowPtr,
const int* csrColInd,
size_t* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseXcsrsort(mcsparseHandle_t handle,
int m,
int n,
int nnz,
const mcsparseMatDescr_t descrA,
const int* csrRowPtr,
int* csrColInd,
int* P,
void* pBuffer)
此函数用于对 CSR 格式的稀疏矩阵进行排序。 排序是在原地进行的，并且是稳定的。
矩阵类型被隐式地视为 MCSPARSE_MATRIX_TYPE_GENERAL。
即，任何对称性质都会被忽略。
此函数 csrsort() 需要通过 csrsort_bufferSizeExt() 返回缓冲区大小。缓冲区的地址必须是 128 字节的倍数。
如果不是，将返回 MCSPARSE_STATUS_INVALID_VALUE。
参数 P 既是输入参数又是输出参数。
如果用户想要计算排序后的 csrVal，则在调用 csrsort() 之前，必须将 P 设置为 0:1:(nnz-1)，并且在调用 csrsort() 完成后，新的排序值数组将满足 csrVal_sorted = csrVal(P)。
总体步骤如下：
// A是3x3稀疏矩阵，基为0 // | 1 2 3 | // A = | 4 5 6 | // | 7 8 9 | const int m = 3; const int n = 3; const int nnz = 9; csrRowPtr[m+1] = { 0, 3, 6, 9}; // 在设备上 csrColInd[nnz] = { 2, 1, 0, 0, 2,1, 1, 2, 0}; // 在设备上 csrVal[nnz] = { 3, 2, 1, 4, 6, 5, 8, 9, 7}; // 在设备上 size_t pBufferSizeInBytes = 0; void *pBuffer = NULL; int *P = NULL; // 步骤1：分配缓冲区 mcsparseXcsrsort_bufferSizeExt(handle, m, n, nnz, csrRowPtr, csrColInd, &pBufferSizeInBytes); mcMalloc( &pBuffer, sizeof(char)* pBufferSizeInBytes); // 步骤2：设置置换向量P为单位映射 mcMalloc( (void**)&P, sizeof(int)*nnz); mcsparseCreateIdentityPermutation(handle, nnz, P); // 步骤3：对CSR格式进行排序 mcsparseXcsrsort(handle, m, n, nnz, descrA, csrRowPtr, csrColInd, P, pBuffer); // 步骤4：收集排序后的csrVal mcsparseDgthr(handle, nnz, csrVal, csrVal_sorted, P, MCSPARSE_INDEX_BASE_ZERO);
如果
pBuffer != NULL，该例程不需要额外的存储空间如果流式有序内存分配器可用，则该例程支持异步执行
输入
参数设备或主机含义handle主机处理mcSPARSE库上下文的句柄。
m主机矩阵
A的行数。n主机矩阵
A的列数。nnz主机矩阵
A中非零元素的数量。csrRowsPtr设备整数数组，包含
m+1个元 素，其中每个元素表示每一行的 起始位置和最后一行的结束位置 加一。csrColInd设备整数数组，包含矩阵
A中nnz个的未排序列索引。P设备整数数组，包含
nnz个未排 序元素的映射索引。为构建csrVal，用户需要设置P=0:1:(nnz-1)。pBuffer设备用户分配的缓冲区；缓冲区的大小 由
coosort_bufferSizeExt()返回。输出
参数设备或主机含义csrColInd设备整数数组，包含矩阵
A中nnz个 已排序的列索引。P设备整数数组，包含
nnz个已排序的映射索引。pBufferSizeInBytes主机缓冲区的字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.14. mcsparseXcscsort()
mcsparseStatus_t
mcsparseXcscsort_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
int nnz,
const int* cscColPtr,
const int* cscRowInd,
size_t* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseXcscsort(mcsparseHandle_t handle,
int m,
int n,
int nnz,
const mcsparseMatDescr_t descrA,
const int* cscColPtr,
int* cscRowInd,
int* P,
void* pBuffer)
此函数对CSC格式进行排序。 排序是在原地进行的，并且是稳定的。
矩阵类型被隐式地视为 MCSPARSE_MATRIX_TYPE_GENERAL。
即，任何对称性质都会被忽略。
此函数 csrsort() 需要通过 csrsort_bufferSizeExt() 返回缓冲区大小。缓冲区的地址必须是 128 字节的倍数。
如果不是，将返回 MCSPARSE_STATUS_INVALID_VALUE。
参数 P 既是输入参数又是输出参数。
如果用户想要计算排序后的 csrVal，则在调用 csrsort() 之前，必须将 P 设置为 0:1:(nnz-1)，并且在调用 csrsort() 完成后，新的排序值数组将满足 csrVal_sorted = csrVal(P)。
总体步骤如下：
// A是3x3稀疏矩阵，基为0 // | 1 2 | // A = | 4 0 | // | 0 8 | const int m = 3; const int n = 2; const int nnz = 4; cscColPtr[n+1] = { 0, 2, 4}; // 在设备上 cscRowInd[nnz] = { 1, 0, 2, 0}; // 在设备上 cscVal[nnz] = { 4.0, 1.0, 8.0, 2.0 }; // 在设备上 size_t pBufferSizeInBytes = 0; void *pBuffer = NULL; int *P = NULL; // 步骤1：分配缓冲区 mcsparseXcscsort_bufferSizeExt(handle, m, n, nnz, cscColPtr, cscRowInd, &pBufferSizeInBytes); mcMalloc( &pBuffer, sizeof(char)* pBufferSizeInBytes); // 步骤2：设置置换向量P为单位映射 mcMalloc( (void**)&P, sizeof(int)*nnz); mcsparseCreateIdentityPermutation(handle, nnz, P); // 步骤3：对CSC格式进行排序 mcsparseXcscsort(handle, m, n, nnz, descrA, cscColPtr, cscRowInd, P, pBuffer); // 步骤4：收集排序后的cscVal mcsparseDgthr(handle, nnz, cscVal, cscVal_sorted, P, MCSPARSE_INDEX_BASE_ZERO);
如果
pBuffer != NULL，该例程不需要额外的存储空间如果流式有序内存分配器可用，则该例程支持异步执行
输入
参数设备或主机含义handle主机处理mcSPARSE库上下文的句柄。
m主机矩阵
A的行数。n主机矩阵
A的列数。nnz主机矩阵
A中非零元素的数量。cscColPtr设备整数数组，包含
m+1个元 素，其中每个元素表示每一行的 起始位置和最后一行的结束位置 加一。cscRowInd设备整数数组，包含矩阵
A中nnz个的未排序列索引。P设备整数数组，包含
nnz个未排 序元素的映射索引。为构建csrVal，用户需要设置P=0:1:(nnz-1)。pBuffer设备用户分配的缓冲区；缓冲区的大小 由
coosort_bufferSizeExt()返回。输出
参数设备或主机含义cscRowInd设备整数数组，包含矩阵
A中nnz个 已排序的列索引。P设备整数数组，包含
nnz个已排序的映射索引。pBufferSizeInBytes主机缓冲区的字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.15. mcsparseXcsru2csr()
mcsparseStatus_t
mcsparseCreateCsru2csrInfo(csru2csrInfo_t *info);
mcsparseStatus_t
mcsparseDestroyCsru2csrInfo(csru2csrInfo_t info);
mcsparseStatus_t
mcsparseScsru2csr_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
int nnz,
float* csrVal,
const int* csrRowPtr,
int* csrColInd,
csru2csrInfo_t info,
size_t* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseDcsru2csr_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
int nnz,
double* csrVal,
const int* csrRowPtr,
int* csrColInd,
csru2csrInfo_t info,
size_t* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseCcsru2csr_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
int nnz,
mcComplex* csrVal,
const int* csrRowPtr,
int* csrColInd,
csru2csrInfo_t info,
size_t* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseZcsru2csr_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
int nnz,
mcDoubleComplex* csrVal,
const int* csrRowPtr,
int* csrColInd,
csru2csrInfo_t info,
size_t* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseScsru2csr(mcsparseHandle_t handle,
int m,
int n,
int nnz,
const mcsparseMatDescr_t descrA,
float* csrVal,
const int* csrRowPtr,
int* csrColInd,
csru2csrInfo_t info,
void* pBuffer)
mcsparseStatus_t
mcsparseDcsru2csr(mcsparseHandle_t handle,
int m,
int n,
int nnz,
const mcsparseMatDescr_t descrA,
double* csrVal,
const int* csrRowPtr,
int* csrColInd,
csru2csrInfo_t info,
void* pBuffer)
mcsparseStatus_t
mcsparseCcsru2csr(mcsparseHandle_t handle,
int m,
int n,
int nnz,
const mcsparseMatDescr_t descrA,
mcComplex* csrVal,
const int* csrRowPtr,
int* csrColInd,
csru2csrInfo_t info,
void* pBuffer)
mcsparseStatus_t
mcsparseZcsru2csr(mcsparseHandle_t handle,
int m,
int n,
int nnz,
const mcsparseMatDescr_t descrA,
mcDoubleComplex* csrVal,
const int* csrRowPtr,
int* csrColInd,
csru2csrInfo_t info,
void* pBuffer)
mcsparseStatus_t
mcsparseScsr2csru(mcsparseHandle_t handle,
int m,
int n,
int nnz,
const mcsparseMatDescr_t descrA,
float* csrVal,
const int* csrRowPtr,
int* csrColInd,
csru2csrInfo_t info,
void* pBuffer)
mcsparseStatus_t
mcsparseDcsr2csru(mcsparseHandle_t handle,
int m,
int n,
int nnz,
const mcsparseMatDescr_t descrA,
double* csrVal,
const int* csrRowPtr,
int* csrColInd,
csru2csrInfo_t info,
void* pBuffer)
mcsparseStatus_t
mcsparseCcsr2csru(mcsparseHandle_t handle,
int m,
int n,
int nnz,
const mcsparseMatDescr_t descrA,
mcComplex* csrVal,
const int* csrRowPtr,
int* csrColInd,
csru2csrInfo_t info,
void* pBuffer)
mcsparseStatus_t
mcsparseZcsr2csru(mcsparseHandle_t handle,
int m,
int n,
int nnz,
const mcsparseMatDescr_t descrA,
mcDoubleComplex* csrVal,
const int* csrRowPtr,
int* csrColInd,
csru2csrInfo_t info,
void* pBuffer)
此函数将未排序的CSR格式转化为CSR格式，反之亦然。 该操作是原地变换。
此函数是 csrsort 和 gthr 的封装器。
我们需要名为 csru2csrInfo 的不透明结构体来保持排序向量的不可见性。
函数(mcsparseCreateCsru2csrInfo， mcsparseDestroyCsru2csrInfo) 分别用来初始化和销毁不透明结构体。
mcsparse[S|D|C|Z]csru2csr_bufferSizeExt 函数返回缓冲区大小。 在 csru2csrInfo 中分配了排列向量 p 的内存。
排序向量的生命周期和 csru2csrInfo 的生命周期相同。
mcsparse[S|D|C|Z]csru2csr 函数执行从未排序CSR格式到已排序CSR格式的正向转换。
首先调用csrsort生成排序向量 P，随后调用 P 执行转换。
mcsparse[S|D|C|Z]csr2csru 函数执行从已排序CSR格式到未排序CSR格式的反向转换。
P 被用于还原回未排序的格式。
如果 pBuffer != NULL，例程 mcsparse<t>csru2csr() 有以下特性：
如果流式有序内存分配器可用，则该例程支持异步执行
如果 pBuffer != NULL，例程 mcsparse<t>csr2csru() 有以下特性：
该例程不需要额外的存储空间
该例程支持异步执行
下面表格描述了 csr2csru_bufferSizeExt 和 csr2csru 的参数。
输入
参数
设备或主机
含义
handle
主机处理mcSPARSE库上下文的句柄。
m
主机矩阵
A的行数。
n
主机矩阵
A的列数。
nnz
主机矩阵
A的非零元素个数。
descrA
主机矩阵
A的描述符。 支持的矩阵类型是MCSPARSE_ MATRIX_TYPE_GENERAL， 此外，支持的索引基数是MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。
csrVal
设备<type> 数组，包含矩阵
A中nnz个未排序非零元素。
csrRowsPtr
设备由
m+1个元素组成的整型 数组。数组包含了每行的起始位 置和最后一行的末尾位置加一。
csrColInd
设备整数数组，包含矩阵
A中 nnz个未排序的列索引。
info
主机不透明结构体，由
mcsparse CreateCsru2csrInfo()初始化。
pBuffer
设备用户分配的缓冲区；大小由
csru2csr_bufferSizeExt()返回。输出
参数
设备或主机
含义
csrVal
设备<type> 数组，存储矩阵
A中nnz个已排序的 元素。
csrColInd
设备整数数组，存储矩阵
A中nnz个 已排序的列索引。
pBufferSizeInBytes
主机缓冲区的字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.16. mcsparseXpruneDense2csr()
mcsparseStatus_t
mcsparseSpruneDense2csr_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
const float* A,
int lda,
const float* threshold,
const mcsparseMatDescr_t descrC,
const float* csrValC,
const int* csrRowPtrC,
const int* csrColIndC,
size_t* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseDpruneDense2csr_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
const double* A,
int lda,
const double* threshold,
const mcsparseMatDescr_t descrC,
const double* csrValC,
const int* csrRowPtrC,
const int* csrColIndC,
size_t* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseSpruneDense2csrNnz(mcsparseHandle_t handle,
int m,
int n,
const float* A,
int lda,
const float* threshold,
const mcsparseMatDescr_t descrC,
int* csrRowPtrC,
int* nnzTotalDevHostPtr,
void* pBuffer)
mcsparseStatus_t
mcsparseDpruneDense2csrNnz(mcsparseHandle_t handle,
int m,
int n,
const double* A,
int lda,
const double* threshold,
const mcsparseMatDescr_t descrC,
int* csrRowPtrC,
int* nnzTotalDevHostPtr,
void* pBuffer)
mcsparseStatus_t
mcsparseSpruneDense2csr(mcsparseHandle_t handle,
int m,
int n,
const float* A,
int lda,
const float* threshold,
const mcsparseMatDescr_t descrC,
float* csrValC,
const int* csrRowPtrC,
int* csrColIndC,
void* pBuffer)
mcsparseStatus_t
mcsparseDpruneDense2csr(mcsparseHandle_t handle,
int m,
int n,
const double* A,
int lda,
const double* threshold,
const mcsparseMatDescr_t descrC,
double* csrValC,
const int* csrRowPtrC,
int* csrColIndC,
void* pBuffer)
此函数将稠密矩阵精简并转换为CSR格式的稀疏矩阵。
此函数通过给定的稠密矩阵 A 和非负值 threshold 返回稀疏矩阵 C。
该实现通过以下操作进行转换：
首先，用户需要分配 m+1 个元素的 csrRowPtrC 数组，并且使用 pruneDense2csrNnz 函数来确定每行非零列的数量。
其次，用户通过 (nnzC=*nnzTotalDevHostPtr) 函数或 (nnzC=csrRowPtrC[m]-csrRowPtrC[0]) 函数来收集 nnzC (矩阵 C 的非零元素个数)，以及分配 nnzC 个元素的 csrValC 数组和 nnzC 个元素的 csrColIndC 数组。
最后，调用 pruneDense2csr() 函数完成转换。
用户必须调用 pruneDense2csr_bufferSizeExt() 来获取 pruneDense2csr() 所需的缓冲区大小，分配缓冲区，并将缓冲区指针传递给 pruneDense2csr()。
例程 mcsparse<t>pruneDense2csrNnz() 有以下特性：
此函数需要内部分配的临时额外存储空间
如果流式有序内存分配器可用，则该例程支持异步执行
例程 mcsparse<t>DpruneDense2csr() 有以下特性：
该例程不需要额外的存储空间
该例程支持异步执行
输入
参数设备或主机含义handle主机处理mcSPARSE库上下文的句柄。
m主机矩阵
A的行数。n主机矩阵
A的列数。A设备维度为(lda，n)的数组。
lda设备矩阵
A的主维度。 主维度至少是max(1，m)。threshold设备或主机用于丢弃矩阵
A中元素的 阈值threshold能够指向设 备内存或主机内存。descrC主机矩阵
C的描述符。 支持的矩阵类型是MC SPARSE_MATRIX_TYPE_GENERAL， 此外，支持的索引基数是MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。pBuffer设备由用户分配的缓冲区： 大小由
prun eDense2csr_bufferSizeExt()返回。输出
参数设备或主机含义nnzTotalDevHostPtr设备或主机矩阵
C中非零元素 的总数。nnzTotalDevHostPtr指向设备内存或主机内存。csrValC设备<type>数组，包括矩阵
C中nnzC个 中的非零元素。csrRowsPtrC设备由
m+1个元素组成的 整型数组，含有m+1个元素。数组包含每行 每行的起始位置和最后 一行的末尾位置加一。csrColIndC设备整数数组，存储矩阵
C中的nnzC个列索引。pBufferSizeInBytes主机缓冲区的字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.17. mcsparseXpruneCsr2csr()
mcsparseStatus_t
mcsparseSpruneCsr2csr_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
int nnzA,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
const float* threshold,
const mcsparseMatDescr_t descrC,
const float* csrValC,
const int* csrRowPtrC,
const int* csrColIndC,
size_t* BufferSize)
mcsparseStatus_t
mcsparseDpruneCsr2csr_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
int nnzA,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
const double* threshold,
const mcsparseMatDescr_t descrC,
const double* csrValC,
const int* csrRowPtrC,
const int* csrColIndC,
size_t* BufferSize)
mcsparseStatus_t
mcsparseSpruneCsr2csrNnz(mcsparseHandle_t handle,
int m,
int n,
int nnzA,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
const float* threshold,
const mcsparseMatDescr_t descrC,
int* csrRowPtrC,
int* nnzTotalDevHostPtr,
void* pBuffer)
mcsparseStatus_t
mcsparseDpruneCsr2csrNnz(mcsparseHandle_t handle,
int m,
int n,
int nnzA,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
const double* threshold,
const mcsparseMatDescr_t descrC,
int* csrRowPtrC,
int* nnzTotalDevHostPtr,
void* pBuffer)
mcsparseStatus_t
mcsparseSpruneCsr2csr(mcsparseHandle_t handle,
int m,
int n,
int nnzA,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
const float* threshold,
const mcsparseMatDescr_t descrC,
float* csrValC,
const int* csrRowPtrC,
int* csrColIndC,
void* pBuffer)
mcsparseStatus_t
mcsparseDpruneCsr2csr(mcsparseHandle_t handle,
int m,
int n,
int nnzA,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
const double* threshold,
const mcsparseMatDescr_t descrC,
double* csrValC,
const int* csrRowPtrC,
int* csrColIndC,
void* pBuffer)
此函数将稠密矩阵精简并转换为CSR格式的稀疏矩阵。
该实现通过以下操作进行转换：
首先，用户需要分配 m+1 个元素的 csrRowPtrC 数组，并且使用 pruneCsr2csrNnz() 函数来确定每行非零列的数量。
其次，用户通过 (nnzC=*nnzTotalDevHostPtr) 函数或 (nnzC=csrRowPtrC[m]-csrRowPtrC[0]) 函数来收集 nnzC (矩阵 C 的非零元素个数)，并分配 nnzC 个元素的 csrValC 数组和 nnzC 个元素的 csrColIndC 数组。
最后，调用 pruneDense2csr() 函数完成转换。
用户必须调用 pruneCsr2csr_bufferSizeExt() 来获取 pruneCsr2csr() 需求的缓冲区大小，然后分配缓冲区并将缓冲指针传递给 pruneCsr2csr()。
例程 mcsparse<t>pruneCsr2csrNnz() 有以下特性：
函数需要额外分配内部临时存储
如果流序内存分配器可用，则例程支持异步执行
例程 mcsparse<t>pruneCsr2csr() 有以下特性：
例程不需要额外存储
例程支持异步执行
输入
参数设备或主机含义handle主机处理mcSPARSE库上下文的句柄。
m主机矩阵
A的行数。n主机矩阵
A的列数。nnzA主机矩阵
A中非零元素的个数。descrA主机矩阵
A的描述符。 支持的矩阵类型是MCSPARSE_ MATRIX_TYPE_GENERAL， 此外，支持的索引基数是MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。csrValA设备<type>数组，存储矩阵
A中 非零元素的个数。csrRowsPtrA设备整数数组，含有
m+1个元素 数组包含了每行的起始位置和 最后一行的末尾位置加一。csrColIndA设备整数数组，存储矩阵
A中nnzA个列索引。threshold设备或主机用于丢弃矩阵
A中元素的 阈值。threshold指向 设备内存或主机内存。descrC主机矩阵
C的描述符。 支持的矩阵类型是MCSPARSE_ MATRIX_TYPE_GENERAL， 此外，支持的索引基数是MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。pBuffer设备用户分配的缓冲区；大小由
prun eCsr2csr_bufferSizeExt()返回。输出
参数设备或主机含义nnzTotalDevHostPtr设备或主机矩阵
C中非零元素的 个数。nnzTotalDevHostPtr指向设备内存或主机 内存。csrValC设备<type>数组，存储nnC个 矩阵
C中的非零元素 个数。csrRowsPtrC设备整数数组，含有
m+1个元素。数组包含了每 行的起始位置和最后一 行的末尾位置加一。csrColIndC设备整数数组，存储矩阵
C中nnzC个的列索引。BufferSize主机缓冲区的字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.18. mcsparseXpruneDense2csrPercentage()
mcsparseStatus_t
mcsparseSpruneDense2csrByPercentage_bufferSizeExt
(mcsparseHandle_t handle,
int m,
int n,
const float* A,
int lda,
float percentage,
const mcsparseMatDescr_t descrC,
const float* csrValC,
const int* csrRowPtrC,
const int* csrColIndC,
pruneInfo_t info,
size_t* BufferSize)
mcsparseStatus_t
mcsparseDpruneDense2csrByPercentage_bufferSizeExt
(mcsparseHandle_t handle,
int m,
int n,
const double* A,
int lda,
float percentage,
const mcsparseMatDescr_t descrC,
const double* csrValC,
const int* csrRowPtrC,
const int* csrColIndC,
pruneInfo_t info,
size_t* BufferSize)
mcsparseStatus_t
mcsparseSpruneDense2csrNnzByPercentage(mcsparseHandle_t handle,
int m,
int n,
const float* A,
int lda,
float percentage,
const mcsparseMatDescr_t descrC,
int* csrRowPtrC,
int* nnzTotalDevHostPtr,
pruneInfo_t info,
void* pBuffer)
mcsparseStatus_t
mcsparseDpruneDense2csrNnzByPercentage(mcsparseHandle_t handle,
int m,
int n,
const double* A,
int lda,
float percentage,
const mcsparseMatDescr_t descrC,
int* csrRowPtrC,
int* nnzTotalDevHostPtr,
pruneInfo_t info,
void* pBuffer)
mcsparseStatus_t
mcsparseSpruneDense2csrByPercentage(mcsparseHandle_t handle,
int m,
int n,
const float* A,
int lda,
float percentage,
const mcsparseMatDescr_t descrC,
float* csrValC,
const int* csrRowPtrC,
int* csrColIndC,
pruneInfo_t info,
void* pBuffer)
mcsparseStatus_t
mcsparseDpruneDense2csrByPercentage(mcsparseHandle_t handle,
int m,
int n,
const double* A,
int lda,
float percentage,
const mcsparseMatDescr_t descrC,
double* csrValC,
const int* csrRowPtrC,
int* csrColIndC,
pruneInfo_t info,
void* pBuffer)
此函数通过百分比将稠密矩阵精简为稀疏矩阵。
给定的稠密矩阵 A 和非负值 threshold，此函数通过以下三个步骤计算稀疏矩阵 C ：
步骤 1：按照绝对值对矩阵 A 进行升序排序。
步骤 2：根据参数 percentage 选择阈值
步骤 3：使用参数 threshold 调用 pruneDense2csr()。
该实现通过以下操作进行转换：
首先，用户需要分配 m+1 个元素的 csrRowPtrC 数组，并且使用 pruneDense2csrNnzByPercentage() 函数来确定每行非零列的数量。
其次，用户通过 (nnzC=*nnzTotalDevHostPtr) 函数或 (nnzC=csrRowPtrC[m]-csrRowPtrC[0]) 函数来收集 nnzC (矩阵 C 的非零元素个数)，并分配 nnzC 个元素的 csrValC 数组和 nnzC 个整数元素的 csrColIndC 数组。
最后，调用 pruneDense2csrByPercentage() 函数完成转换。
用户必须通过调用 pruneDense2csrByPercentage_bufferSizeExt() 来获取 pruneDense2csrByPercentage() 需求的缓冲区大小，然后分配缓冲区，并将缓冲指针传递给 pruneDense2csrByPercentage()。
备注
percentage值必须不大于100。否则，将返回MCSPARSE_STATUS_INVALID_VALUE。和
pruneCsr2csrByPercentage()函数不同的地方在于矩阵A中的零元素不会被忽略，包括零在内的所有元素都参与排序。
例程 mcsparse<t>pruneDense2csrNnzByPercentage() 有以下特性：
函数需要额外分配内部临时存储
如果流序内存分配器可用，则例程支持异步执行
例程 mcsparse<t>pruneDense2csrByPercentage() 有以下特性：
例程无需额外存储
例程支持异步执行
输出
参数设备或主机含义handle主机处理mcSPARSE库上下文的句柄。
m主机矩阵
A的行数。n主机矩阵
A的列数。A设备维度为(lda，n)的数组。
lda设备矩阵
A的主维度。 主维度至少是max(1，m)。percentage主机percentage <=100 和 percentage >= 0
descrC主机矩阵
C的描述符。 支持的矩阵类型是MCSPARSE_ MATRIX_TYPE_GENERAL， 此外，支持的索引基数是MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。pBuffer设备由用户分配的缓冲区； 大小由
pruneDense2csrByP ercentage_bufferSizeExt()返回。输出
参数设备或主机含义nnzTotalDevHostPtr设备或主机矩阵
C中非零元素 的个数。nnzTotalDevHostPtr指向设备内存或主机内存csrValC设备<type>数组，存储矩阵
C中的nnzC个非零 元素。csrRowsPtrC设备整数数组，含有
m+1个元素。数组包含了每行 的起始位置和最后一行 的末尾位置加一。csrColIndC设备整数数组，包含矩阵
C中nnzC个 中的列索引BufferSize主机缓冲区的字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.19. mcsparseXpruneCsr2csrByPercentage()
mcsparseStatus_t
mcsparseSpruneCsr2csrByPercentage_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
int nnzA,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
float percentage,
const mcsparseMatDescr_t descrC,
const float* csrValC,
const int* csrRowPtrC,
const int* csrColIndC,
pruneInfo_t info,
size_t* BufferSize)
mcsparseStatus_t
mcsparseDpruneCsr2csrByPercentage_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
int nnzA,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
float percentage,
const mcsparseMatDescr_t descrC,
const double* csrValC,
const int* csrRowPtrC,
const int* csrColIndC,
pruneInfo_t info,
size_t* BufferSize)
mcsparseStatus_t
mcsparseSpruneCsr2csrNnzByPercentage(mcsparseHandle_t handle,
int m,
int n,
int nnzA,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
float percentage,
const mcsparseMatDescr_t descrC,
int* csrRowPtrC,
int* nnzTotalDevHostPtr,
pruneInfo_t info,
void* pBuffer)
mcsparseStatus_t
mcsparseDpruneCsr2csrNnzByPercentage(mcsparseHandle_t handle,
int m,
int n,
int nnzA,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
float percentage,
const mcsparseMatDescr_t descrC,
int* csrRowPtrC,
int* nnzTotalDevHostPtr,
pruneInfo_t info,
void* pBuffer)
mcsparseStatus_t
mcsparseSpruneCsr2csrByPercentage(mcsparseHandle_t handle,
int m,
int n,
int nnzA,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
float percentage,
const mcsparseMatDescr_t descrC,
float* csrValC,
const int* csrRowPtrC,
int* csrColIndC,
pruneInfo_t info,
void* pBuffer)
mcsparseStatus_t
mcsparseDpruneCsr2csrByPercentage(mcsparseHandle_t handle,
int m,
int n,
int nnzA,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
float percentage,
const mcsparseMatDescr_t descrC,
double* csrValC,
const int* csrRowPtrC,
int* csrColIndC,
pruneInfo_t info,
void* pBuffer)
此函数通过百分比将稠密矩阵精简为稀疏矩阵。
给定的稠密矩阵 A 和非负值 percentage，此函数通过以下三个步骤计算稀疏矩阵 C：
步骤 1：按照绝对值对矩阵 A 进行升序排序。
步骤 2：根据参数 percentage 选择阈值(threshold)。
步骤 3：使用参数 threshold 调用 pruneCsr2csr()。
该实现通过以下操作进行转换：
首先，用户需要分配 m+1 个元素的 csrRowPtrC 数组，并且使用 pruneCsr2csrNnzByPercentage() 函数来确定每行非零列的数量。
其次，用户通过 (nnzC=*nnzTotalDevHostPtr) 函数或 (nnzC=csrRowPtrC[m]-csrRowPtrC[0]) 函数来收集 nnzC (矩阵 C 的非零元素个数)，以及分配 nnzC 个元素的 csrValC 数组和 nnzC 个整数元素的 csrColIndC 数组
最后，调用 pruneCsr2csrByPercentage() 函数完成转换。
用户必须调用 pruneCsr2csrByPercentage_bufferSizeExt() 来获取 pruneCsr2csrByPercentage() 所需的缓冲区大小，分配缓冲区，并将缓冲区指针传递给 pruneCsr2csrByPercentage()。
备注
percentage 值必须不大于100。否则，将返回 MCSPARSE_STATUS_INVALID_VALUE。
例程 mcsparse<t>pruneCsr2csrNnzByPercentage() 有以下特性：
函数需要额外分配内部临时存储
如果流序内存分配器可用，例程支持异步执行
例程 mcsparse<t>pruneCsr2csrByPercentage() 有以下特性：
例程不需要额外存储
例程支持异步执行
输入
参数设备或主机含义handle主机处理mcSPARSE库上下文的句柄。
m主机矩阵
A的行数。n主机矩阵
A的列数。nnzA主机矩阵
A的非零数。descrA主机矩阵
A的描述符。 支持的矩阵类型为MCSPARSE_ MATRIX_TYPE_GENERAL， 同时，支持的索引基也有MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONEcsrValA设备类型为<type>的数组，包含矩阵
A中nnzA个非零 元素。csrRowsPtrA设备由
m+1个元素组成的整型 数组，其中包含每一行的起始位 置和最后一行的结束位置加1。csrColIndA设备整型数组包含矩阵
A中nnzA个的列索引。percentage主机percentage <=100 和 percentage >= 0
descrC主机矩阵
C的描述符。 支持的矩阵类型为MCSPARSE_ MATRIX_TYPE_GENERAL，同时，支持的索引基也有MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONEpBuffer设备用户分配的缓冲区； 其大小由
pruneCsr2csrByPe rcentage_bufferSizeExt()返回。输出
parameter设备或主机含义nnzTotalDevHostPtr设备或主机矩阵
C的非零元素 总数。nnzTotalDevHostPtr可以指向设备内存或主机 内存。csrValC设备类型为<type>的数组，包 含矩阵
C中nnzC个非零元素。csrRowsPtrC设备由
m+1个元素组成 的整型数组，其中包含每 一行的起始位置和最后一 行 的结束位置加1。csrColIndC设备整型数组包含矩阵
C中nnzC个列索引BufferSize主机缓冲区的字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
13.20. mcsparse<t>nnz_compress()
mcsparseStatus_t
mcsparseSnnz_compress(mcsparseHandle_t handle,
int m,
const mcsparseMatDescr_t descr,
const float* csrValA,
const int* csrRowPtrA,
int* nnzPerRow,
int* nnzC,
float tol)
mcsparseStatus_t
mcsparseDnnz_compress(mcsparseHandle_t handle,
int m,
const mcsparseMatDescr_t descr,
const double* csrValA,
const int* csrRowPtrA,
int* nnzPerRow,
int* nnzC,
double tol)
mcsparseStatus_t
mcsparseCnnz_compress(mcsparseHandle_t handle,
int m,
const mcsparseMatDescr_t descr,
const mcComplex* csrValA,
const int* csrRowPtrA,
int* nnzPerRow,
int* nnzC,
mcComplex tol)
mcsparseStatus_t
mcsparseZnnz_compress(mcsparseHandle_t handle,
int m,
const mcsparseMatDescr_t descr,
const mcDoubleComplex* csrValA,
const int* csrRowPtrA,
int* nnzPerRow,
int* nnzC,
mcDoubleComplex tol)
此函数是从CSR格式转换为压缩CSR格式的第一步。
对于 mcComplex 和 mcDoubleComplex 情况的一个关键假设是，容差是以实部形式给出的。
例如， tol = 1e-8 + 0*i，我们提取实部，也就是这个结构体的x分量。
此函数需要临时的额外内部存储空间。
如果存在流式有序内存分配器，此例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄
m矩阵
A的行数。descrA矩阵
A的描述符。支持的矩阵类型是MCSPARSE_MATRIX_TYPE_GENERAL。同时，支持的 基准索引是MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。csrValACSR非压缩值数组
csrRowPtrA相应的输入非压缩行指针。
tol非负容差，用于确定一个数是否小于等于它。
输出
nnzPerRow这个数组包含每行绝对值大于tol的元素数量
nnzC总共有多少个绝对值大于tol的元素的主机/设备指针。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。