cuSPARSELt 函数#

库管理函数#

`cusparseLtInit`#

cusparseStatus_t
cusparseLtInit(cusparseLtHandle_t* handle)

The function initializes the cuSPARSELt library handle (cusparseLtHandle_t) which holds the cuSPARSELt library context. It allocates light hardware resources on the host, and must be called prior to making any other cuSPARSELt library calls. Calling any cusparseLt function which uses cusparseLtHandle_t without a previous call of cusparseLtInit() will return an error.

cuSPARSELt库上下文与当前CUDA设备绑定。要在多个设备上使用该库，应为每个设备创建一个cuSPARSELt句柄。

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

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtDestroy`#

cusparseStatus_t
cusparseLtDestroy(const cusparseLtHandle_t* handle)

该函数释放由cuSPARSELt库使用的硬件资源。此函数是针对特定cuSPARSELt库句柄的最后一次调用。

Calling any cusparseLt function which uses cusparseLtHandle_t after cusparseLtDestroy() will return an error.

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

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtGetVersion`#

cusparseStatus_t
cusparseLtGetVersion(const cusparseLtHandle_t* handle,
                     int*                      version)

该函数返回cuSPARSELt库的版本号。

参数	内存	输入/输出	描述
`handle`	主机	IN	cuSPARSELt 库句柄
`version`	主机	输出	库的版本号

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtGetProperty`#

cusparseStatus_t
cusparseLtGetProperty(libraryPropertyType propertyType,
                      int*                value)

The function returns the value of the requested property. Refer to libraryPropertyType for supported types.

参数	内存	输入/输出	描述
`propertyType`	主机	IN	请求的属性
`value`	主机	输出	请求属性的值

libraryPropertyType (定义于 library_types.h):

值	含义
`MAJOR_VERSION`	用于查询主版本的枚举器
`MINOR_VERSION`	用于查询次要版本的枚举器
`PATCH_LEVEL`	用于标识补丁级别的编号

有关返回状态的描述，请参见cusparseStatus_t。

矩阵描述符函数#

`cusparseLtDenseDescriptorInit`#

cusparseStatus_t
cusparseLtDenseDescriptorInit(const cusparseLtHandle_t*  handle,
                              cusparseLtMatDescriptor_t* matDescr,
                              int64_t                    rows,
                              int64_t                    cols,
                              int64_t                    ld,
                              uint32_t                   alignment,
                              cudaDataType               valueType,
                              cusparseOrder_t            order)

该函数初始化一个密集矩阵的描述符。

参数	内存	输入/输出	描述	可选值
`handle`	主机	IN	cuSPARSELt 库句柄
`matDescr`	主机	输出	密集矩阵描述
`rows`	主机	IN	行数
`cols`	主机	IN	列数
`ld`	主机	IN	前导维度	≥ 行（如果是列优先存储），≥ 列（如果是行优先存储）
`alignment`	主机	IN	内存对齐（以字节为单位）	16的倍数
`valueType`	主机	IN	矩阵的数据类型	`CUDA_R_32F`, `CUDA_R_16F`, `CUDA_R_16BF`, `CUDA_R_8I`, `CUDA_R_8F_E4M3`, `CUDA_R_8F_E5M2`, `CUDA_R_4F_E2M1`
`order`	主机	IN	内存布局	`CUSPARSE_ORDER_COL`, `CUSPARSE_ORDER_ROW`

约束条件:

rows, cols, 和 ld 必须是

16 如果 valueType 是 CUDA_R_8I, CUDA_R_8F_E4M3, CUDA_R_8F_E5M2, 或 CUDA_R_4F_E2M1

8 如果 valueType 是 CUDA_R_16F 或 CUDA_R_16BF

4 如果 valueType 是 CUDA_R_32F

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtStructuredDescriptorInit`#

cusparseStatus_t
cusparseLtStructuredDescriptorInit(const cusparseLtHandle_t*  handle,
                                   cusparseLtMatDescriptor_t* matDescr,
                                   int64_t                    rows,
                                   int64_t                    cols,
                                   int64_t                    ld,
                                   uint32_t                   alignment,
                                   cudaDataType               valueType,
                                   cusparseOrder_t            order,
                                   cusparseLtSparsity_t       sparsity)

该函数初始化一个结构化矩阵的描述符。

参数	内存	输入/输出	描述	可选值
`handle`	主机	IN	cuSPARSELt 库句柄
`matDescr`	主机	输出	稀疏矩阵描述
`rows`	主机	IN	行数
`cols`	主机	IN	列数
`ld`	主机	IN	前导维度	≥ 行（如果是列优先存储），≥ 列（如果是行优先存储）
`alignment`	主机	IN	内存对齐（以字节为单位）	16的倍数
`valueType`	主机	IN	矩阵的数据类型	`CUDA_R_32F`, `CUDA_R_16F`, `CUDA_R_16BF`, `CUDA_R_8I`, `CUDA_R_8F_E4M3`, `CUDA_R_8F_E5M2`, `CUDA_R_4F_E2M1`
`order`	主机	IN	内存布局	`CUSPARSE_ORDER_COL`, `CUSPARSE_ORDER_ROW`
`稀疏度`	主机	IN	矩阵稀疏比率	`CUSPARSELT_SPARSITY_50_PERCENT`

约束条件:

rows、cols和ld必须是

32 如果 valueType 是 CUDA_R_8I, CUDA_R_8F_E4M3, CUDA_R_8F_E5M2, 或 CUDA_R_4F_E2M1

16 如果 valueType 是 CUDA_R_16F 或 CUDA_R_16BF

8 如果 valueType 是 CUDA_R_32F

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtMatDescriptorDestroy`#

cusparseStatus_t
cusparseLtMatDescriptorDestroy(const cusparseLtMatDescriptor_t* matDescr)

该函数释放矩阵描述符实例所使用的资源。调用此函数后，矩阵描述符、矩阵乘法描述符及计划将不再可用。

参数	内存	输入/输出	描述
`matDescr`	主机	IN	矩阵描述符

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtMatDescSetAttribute`#

cusparseStatus_t
cusparseLtMatDescSetAttribute(const cusparseLtHandle_t*    handle,
                              cusparseLtMatDescriptor_t*   matmulDescr,
                              cusparseLtMatDescAttribute_t matAttribute,
                              const void*                  data,
                              size_t                       dataSize)

该函数设置矩阵描述符的指定属性值，例如批次数及其步长。

参数	内存	输入/输出	描述	可选值
`handle`	主机	IN	cuSPARSELt 库句柄
`matmulDescr`	主机	输出	矩阵描述符
`matAttribute`	主机	IN	要设置的属性	`CUSPARSELT_MAT_NUM_BATCHES`, `CUSPARSELT_MAT_BATCH_STRIDE`
`data`	主机	IN	指向将设置指定属性的值的指针
`dataSize`	主机	IN	用于验证的属性值大小（以字节为单位）

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtMatDescGetAttribute`#

cusparseStatus_t
cusparseLtMatDescGetAttribute(const cusparseLtHandle_t*        handle,
                              const cusparseLtMatDescriptor_t* matmulDescr,
                              cusparseLtMatDescAttribute_t     matAttribute,
                              void*                            data,
                              size_t                           dataSize)

该函数获取矩阵描述符的指定属性值，例如批次数及其步长。

参数	内存	输入/输出	描述	可选值
`handle`	主机	IN	cuSPARSELt 库句柄
`matmulDescr`	主机	IN	矩阵描述符
`matAttribute`	主机	IN	要检索的属性	`CUSPARSELT_MAT_NUM_BATCHES`, `CUSPARSELT_MAT_BATCH_STRIDE`
`data`	主机	输出	包含此函数检索到的属性值的内存地址
`dataSize`	主机	IN	用于验证的属性值大小（以字节为单位）

有关返回状态的描述，请参见cusparseStatus_t。

矩阵乘法描述符函数#

`cusparseLtMatmulDescriptorInit`#

cusparseStatus_t
cusparseLtMatmulDescriptorInit(const cusparseLtHandle_t*        handle,
                               cusparseLtMatmulDescriptor_t*    matmulDescr,
                               cusparseOperation_t              opA,
                               cusparseOperation_t              opB,
                               const cusparseLtMatDescriptor_t* matA,
                               const cusparseLtMatDescriptor_t* matB,
                               const cusparseLtMatDescriptor_t* matC,
                               const cusparseLtMatDescriptor_t* matD,
                               cusparseComputeType              computeType)

该函数初始化矩阵乘法描述符。

参数	内存	输入/输出	描述	可选值
`handle`	主机	IN	cuSPARSELt 库句柄
`matmulDescr`	主机	输出	矩阵乘法描述符
`opA`	主机	IN	应用于矩阵 `A` 的操作	`CUSPARSE_OPERATION_NON_TRANSPOSE`, `CUSPARSE_OPERATION_TRANSPOSE`
`opB`	主机	IN	应用于矩阵 `B` 的操作	`CUSPARSE_OPERATION_NON_TRANSPOSE`, `CUSPARSE_OPERATION_TRANSPOSE`
`matA`	主机	IN	结构化或密集矩阵描述符 `A`
`matB`	主机	IN	结构化或密集矩阵描述符 `B`
`matC`	主机	IN	稠密矩阵描述符 `C`
`matD`	主机	IN	稠密矩阵描述符 `D`
`computeType`	主机	IN	计算精度	`CUSPARSE_COMPUTE_32I`, `CUSPARSE_COMPUTE_32F`, `CUSPARSE_COMPUTE_16F`

结构化矩阵描述符可用于matA或matB，但不能同时用于两者。

约束条件:

查看 cusparseLtMatmul() 了解支持的数据类型。

CUDA_R_8I, CUDA_R_8F_E4M3,`CUDA_R_8F_E5M2` 和 CUDA_R_4F_E2M1 数据类型仅支持（如果 B 是结构化类型则相反）：

opA/opB = TN 如果矩阵顺序是 orderA/orderB = Col/Col

opA/opB = NT 如果矩阵顺序是 orderA/orderB = Row/Row

opA/opB = NN 如果矩阵顺序是 orderA/orderB = Row/Col

opA/opB = TT 当矩阵顺序为 orderA/orderB = Col/Row 时

C 和 D 必须具有相同的前导维度和内存布局（关于不同内存布局请参阅 cusparseOrder_t）。

矩阵 C 和 D 每个维度(行和列)的最大元素数量限制为2097120。

如果输入A/B=`E4M3`，输出D=`E4M3`，缩放比例=`VEC64_UE8M0`，则矩阵C和D连续维度上的最小元素数量为64。

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtMatmulDescSetAttribute`#

cusparseStatus_t
cusparseLtMatmulDescSetAttribute(const cusparseLtHandle_t*       handle,
                                 cusparseLtMatmulDescriptor_t*   matmulDescr,
                                 cusparseLtMatmulDescAttribute_t matmulAttribute,
                                 const void*                     data,
                                 size_t                          dataSize)

该函数设置矩阵描述符的指定属性值，例如激活函数和偏置。

参数	内存	输入/输出	描述
`handle`	主机	IN	cuSPARSELt 库句柄
`matmulDescr`	主机	输出	矩阵描述符
`matmulAttribute`	主机	IN	要设置的属性	`CUSPARSELT_MATMUL_ACTIVATION_RELU`, `CUSPARSELT_MATMUL_ACTIVATION_RELU_UPPERBOUND`, `CUSPARSELT_MATMUL_ACTIVATION_RELU_THRESHOLD`, `CUSPARSELT_MATMUL_ACTIVATION_GELU`, `CUSPARSELT_MATMUL_ACTIVATION_GELU_SCALING`, `CUSPARSELT_MATMUL_ALPHA_VECTOR_SCALING`, `CUSPARSELT_MATMUL_BETA_VECTOR_SCALING`, `CUSPARSELT_MATMUL_BIAS_POINTER`, `CUSPARSELT_MATMUL_BIAS_STRIDE`
`data`	主机	IN	指向将设置指定属性的值的指针
`dataSize`	主机	IN	用于验证的属性值大小（以字节为单位）

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtMatmulDescGetAttribute`#

cusparseStatus_t
cusparseLtMatmulDescGetAttribute(const cusparseLtHandle_t*           handle,
                                 const cusparseLtMatmulDescriptor_t* matmulDescr,
                                 cusparseLtMatmulDescAttribute_t     matmulAttribute,
                                 void*                               data,
                                 size_t                              dataSize)

该函数获取矩阵描述符（如激活函数和偏置）中指定属性的值。

参数	内存	输入/输出	描述
`handle`	主机	IN	cuSPARSELt 库句柄
`matmulDescr`	主机	输出	矩阵描述符
`matmulAttribute`	主机	IN	要检索的属性	`CUSPARSELT_MATMUL_ACTIVATION_RELU`, `CUSPARSELT_MATMUL_ACTIVATION_RELU_UPPERBOUND`, `CUSPARSELT_MATMUL_ACTIVATION_RELU_THRESHOLD`, `CUSPARSELT_MATMUL_ACTIVATION_GELU`, `CUSPARSELT_MATMUL_ACTIVATION_GELU_SCALING`, `CUSPARSELT_MATMUL_ALPHA_VECTOR_SCALING`, `CUSPARSELT_MATMUL_BETA_VECTOR_SCALING`, `CUSPARSELT_MATMUL_BIAS_POINTER`, `CUSPARSELT_MATMUL_BIAS_STRIDE`
`data`	主机	输出	包含此函数检索到的属性值的内存地址
`dataSize`	主机	IN	用于验证的属性值大小（以字节为单位）

有关返回状态的描述，请参见cusparseStatus_t。

矩阵乘法算法函数#

`cusparseLtMatmulAlgSelectionInit`#

cusparseStatus_t
cusparseLtMatmulAlgSelectionInit(const cusparseLtHandle_t*           handle,
                                 cusparseLtMatmulAlgSelection_t*     algSelection,
                                 const cusparseLtMatmulDescriptor_t* matmulDescr,
                                 cusparseLtMatmulAlg_t               alg)

该函数初始化算法选择描述符。

参数	内存	输入/输出	描述	可选值
`handle`	主机	IN	cuSPARSELt 库句柄
`algSelection`	主机	输出	算法选择描述符
`matmulDescr`	主机	IN	矩阵乘法描述符
`alg`	主机	IN	算法模式	`CUSPARSELT_MATMUL_ALG_DEFAULT`

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtMatmulAlgSetAttribute`#

cusparseStatus_t
cusparseLtMatmulAlgSetAttribute(const cusparseLtHandle_t*       handle,
                                cusparseLtMatmulAlgSelection_t* algSelection,
                                cusparseLtMatmulAlgAttribute_t  attribute,
                                const void*                     data,
                                size_t                          dataSize)

该函数用于设置算法选择描述符中指定属性的值。

参数	内存	输入/输出	描述	可选值
`handle`	主机	IN	cuSPARSELt 库句柄
`algSelection`	主机	输出	算法选择描述符
`attribute`	主机	IN	要设置的属性	`CUSPARSELT_MATMUL_ALG_CONFIG_ID`, `CUSPARSELT_MATMUL_SEARCH_ITERATIONS`, `CUSPARSELT_MATMUL_SPLIT_K`, `CUSPARSELT_MATMUL_SPLIT_K_MODE`, `CUSPARSELT_MATMUL_SPLIT_K_BUFFERS`
`data`	主机	IN	指向将设置指定属性的值的指针
`dataSize`	主机	IN	用于验证的属性值大小（以字节为单位）

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtMatmulAlgGetAttribute`#

cusparseStatus_t
cusparseLtMatmulAlgGetAttribute(const cusparseLtHandle_t*             handle,
                                const cusparseLtMatmulAlgSelection_t* algSelection,
                                cusparseLtMatmulAlgAttribute_t        attribute,
                                void*                                 data,
                                size_t                                dataSize)

该函数返回属于算法选择描述符的查询属性的值。

参数	内存	输入/输出	描述	可选值
`handle`	主机	IN	cuSPARSELt 库句柄
`algSelection`	主机	IN	算法选择描述符
`attribute`	主机	IN	该函数将要获取的属性	`CUSPARSELT_MATMUL_ALG_CONFIG_ID`, `CUSPARSELT_MATMUL_ALG_CONFIG_MAX_ID`, `CUSPARSELT_MATMUL_SEARCH_ITERATIONS`, `CUSPARSELT_MATMUL_SPLIT_K`, `CUSPARSELT_MATMUL_SPLIT_K_MODE`, `CUSPARSELT_MATMUL_SPLIT_K_BUFFERS`
`data`	主机	输出	包含此函数检索到的属性值的内存地址
`dataSize`	主机	IN	用于验证的属性值大小（以字节为单位）

有关返回状态的描述，请参见cusparseStatus_t。

矩阵乘法函数#

`cusparseLtMatmulGetWorkspace`#

cusparseStatus_t
cusparseLtMatmulGetWorkspace(const cusparseLtHandle_t*     handle,
                             const cusparseLtMatmulPlan_t* plan,
                             size_t*                       workspaceSize)

该函数确定与所选算法关联所需的工作空间大小。

参数	内存	输入/输出	描述
`handle`	主机	IN	cuSPARSELt 库句柄
`plan`	主机	IN	矩阵乘法计划
`workspaceSize`	主机	输出	工作区大小（字节）

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtMatmulPlanInit`#

cusparseStatus_t
cusparseLtMatmulPlanInit(const cusparseLtHandle_t*             handle,
                         cusparseLtMatmulPlan_t*               plan,
                         const cusparseLtMatmulDescriptor_t*   matmulDescr,
                         const cusparseLtMatmulAlgSelection_t* algSelection)

参数	内存	输入/输出	描述
`handle`	主机	IN	cuSPARSELt 库句柄
`plan`	主机	输出	矩阵乘法计划
`matmulDescr`	主机	IN	矩阵乘法描述符
`algSelection`	主机	IN	算法选择描述符

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtMatmulPlanDestroy`#

cusparseStatus_t
cusparseLtMatmulPlanDestroy(const cusparseLtMatmulPlan_t* plan)

该函数释放矩阵乘法计划实例所使用的资源。此函数是对特定计划实例的最后一次调用。

Calling any cusparseLt function which uses cusparseLtMatmulPlan_t after cusparseLtMatmulPlanDestroy() will return an error.

参数	内存	输入/输出	描述
`plan`	主机	IN	矩阵乘法计划

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtMatmul`#

cusparseStatus_t
cusparseLtMatmul(const cusparseLtHandle_t*     handle,
                 const cusparseLtMatmulPlan_t* plan,
                 const void*                   alpha,
                 const void*                   d_A,
                 const void*                   d_B,
                 const void*                   beta,
                 const void*                   d_C,
                 void*                         d_D,
                 void*                         workspace,
                 cudaStream_t*                 streams,
                 int32_t                       numStreams)

该函数计算矩阵A和B的矩阵乘法，根据以下运算生成输出矩阵D：

$D = Activation(\alpha op(A) \cdot op(B) + \beta op(C) + bias)$

where A, B, and C are input matrices, and $\alpha$ and $\beta$ are input scalars or vectors of scalars (device-side pointers).

As described by cusparseLtMatmulDescriptorInit(), one and only one input matrix A or B should have structured sparsity, and respective d_A or d_B structured sparse matrix pointer should be output of cusparseLtSpMMACompress() or cusparseLtSpMMACompress2().

Note: The function currently only supports the case where D has the same shape of C

参数	内存	输入/输出	描述
`handle`	主机	IN	cuSPARSELt 库句柄
`plan`	主机	IN	矩阵乘法计划
`alpha`	主机/设备	IN	$\alpha$ 用于乘法的标量或标量向量（`float` 数据类型）。如果alpha是标量 - 应指向主机内存的指针，否则 - 指向设备内存的指针
`d_A`	设备	IN	指向结构化或稠密矩阵 `A` 的指针
`d_B`	设备	IN	指向结构化或密集矩阵 `B` 的指针
`beta`	主机/设备	IN	$\beta$ 用于乘法的标量/标量向量（`float`数据类型）。仅当设置了`CUSPARSELT_MATMUL_ALPHA_VECTOR_SCALING`而未设置`CUSPARSELT_MATMUL_BETA_VECTOR_SCALING`时，该值可为`NULL`。若beta为标量——应指向主机内存，否则指向设备内存
`d_C`	设备	IN	指向稠密矩阵 `C` 的指针
`d_D`	设备	输出	指向稠密矩阵 `D` 的指针
`workspace`	设备	IN	指向工作区的指针
`streams`	主机	IN	指向用于计算的CUDA流数组的指针
`numStreams`	主机	IN	`streams`中的CUDA流数量

支持的数据类型：

输入A/B	输入C	输出D	计算
`CUDA_R_32F`	`CUDA_R_32F`		`CUSPARSE_COMPUTE_32F`
`CUDA_R_16F`	`CUDA_R_16F`		`CUSPARSE_COMPUTE_32F`
`CUDA_R_16F`	`CUDA_R_16F`		`CUSPARSE_COMPUTE_16F`
`CUDA_R_16BF`	`CUDA_R_16BF`		`CUSPARSE_COMPUTE_32F`
`CUDA_R_8I`	`CUDA_R_8I`		`CUSPARSE_COMPUTE_32I`
	`CUDA_R_32I`
	`CUDA_R_16F`
	`CUDA_R_16BF`
`CUDA_R_8F_E4M3` [1]	`CUDA_R_16F`	`CUDA_R_8F_E4M3` [1]	`CUSPARSE_COMPUTE_32F`
	`CUDA_R_16BF`	`CUDA_R_8F_E4M3` [1]
	`CUDA_R_16F`
	`CUDA_R_16BF`
	`CUDA_R_32F`
`CUDA_R_8F_E5M2`	`CUDA_R_16F`	`CUDA_R_8F_E5M2`	`CUSPARSE_COMPUTE_32F`
	`CUDA_R_16BF`	`CUDA_R_8F_E5M2`
	`CUDA_R_16F`
	`CUDA_R_16BF`
	`CUDA_R_32F`
`CUDA_R_4F_E2M1` [2]	`CUDA_R_16F`	`CUDA_R_4F_E2M1` [2]	`CUSPARSE_COMPUTE_32F`
	`CUDA_R_16BF`	`CUDA_R_4F_E2M1` [2]
	`CUDA_R_16F`
	`CUDA_R_16BF`
	`CUDA_R_32F`

有关GPU计算能力支持哪些数据类型组合的详细列表，请参阅Key Features

约束条件：

所有指针必须对齐到16字节

属性

该例程不需要额外的存储空间

该例程支持相对于streams[0]的异步执行

每次运行提供确定性（逐位）结果

cusparseLtMatmul 支持以下优化：

CUDA图捕获

硬件内存压缩

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtMatmulSearch`#

cusparseStatus_t
cusparseLtMatmulSearch(const cusparseLtHandle_t* handle,
                       cusparseLtMatmulPlan_t*   plan,
                       const void*               alpha,
                       const void*               d_A,
                       const void*               d_B,
                       const void*               beta,
                       const void*               d_C,
                       void*                     d_D,
                       void*                     workspace,
                       cudaStream_t*             streams,
                       int32_t                   numStreams)

The function evaluates all available algorithms for the matrix multiplication described by plan and automatically updates the cusparseLtMatmulAlgSelection_t used to initialize the plan by selecting the fastest one. The functionality is intended to be used for auto-tuning purposes when the same operation is repeated multiple times over different inputs.

The function behaves similarly to cusparseLtMatmul(), with the difference that d_D values may accumulate if the operation is performed in-place (d_C=d_D).

该函数相对于streams[0]是非异步的（阻塞调用）

可以通过使用cusparseLtMatmulAlgSetAttribute()函数并设置CUSPARSELT_MATMUL_SEARCH_ITERATIONS参数来配置评估的迭代次数。

所选算法ID可以通过使用cusparseLtMatmulAlgGetAttribute()函数并指定CUSPARSELT_MATMUL_ALG_CONFIG_ID参数来获取。

该函数还会搜索Split-K参数的最佳组合。所选值可以通过使用cusparseLtMatmulAlgGetAttribute()来获取。

参数	内存	输入/输出	描述
`handle`	主机	IN	cuSPARSELt 库句柄
`plan`	主机	输出	矩阵乘法计划
`alpha`	主机	IN	$\alpha$ 用于乘法的标量或标量向量（`float` 数据类型）
`d_A`	设备	IN	指向结构化或稠密矩阵 `A` 的指针
`d_B`	设备	IN	指向结构化或密集矩阵 `B` 的指针
`beta`	主机	IN	$\beta$ 用于乘法的标量/标量向量（`float` 数据类型）。仅当设置了`CUSPARSELT_MATMUL_ALPHA_VECTOR_SCALING`而未设置`CUSPARSELT_MATMUL_BETA_VECTOR_SCALING`时，该参数可以为`NULL`值。
`d_C`	设备	IN	指向稠密矩阵 `C` 的指针
`d_D`	设备	输出	指向稠密矩阵 `D` 的指针
`workspace`	设备	IN	指向工作区的指针
`streams`	主机	IN	指向用于计算的CUDA流数组的指针
`numStreams`	主机	IN	`streams`中的CUDA流数量

辅助函数#

`cusparseLtSpMMAPrune`#

cusparseStatus_t
cusparseLtSpMMAPrune(const cusparseLtHandle_t*           handle,
                     const cusparseLtMatmulDescriptor_t* matmulDescr,
                     const void*                         d_in,
                     void*                               d_out,
                     cusparseLtPruneAlg_t                pruneAlg,
                     cudaStream_t                        stream)

该函数根据指定的算法pruneAlg对稠密矩阵d_in进行剪枝。

参数	内存	输入/输出	描述	可选值
`handle`	主机	IN	cuSPARSELt 库句柄
`matmulDescr`	主机	IN	矩阵乘法描述符
`d_in`	设备	IN	指向稠密矩阵的指针
`d_out`	设备	输出	指向修剪后矩阵的指针
`pruneAlg`	设备	IN	剪枝算法	`CUSPARSELT_PRUNE_SPMMA_TILE`, `CUSPARSELT_PRUNE_SPMMA_STRIP`
`stream`	主机	IN	用于计算的CUDA流

属性

该例程不需要额外的存储空间

该例程支持相对于stream的异步执行

每次运行提供确定性（逐位）结果

cusparseLtSpMMAPrune() 支持以下优化：

CUDA图捕获

硬件内存压缩

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtSpMMAPrune2 [已弃用]`#

cusparseStatus_t
cusparseLtSpMMAPrune2(const cusparseLtHandle_t*        handle,
                      const cusparseLtMatDescriptor_t* sparseMatDescr,
                      int                              isSparseA,
                      cusparseOperation_t              op,
                      const void*                      d_in,
                      void*                            d_out,
                      cusparseLtPruneAlg_t             pruneAlg,
                      cudaStream_t                     stream);

该函数根据指定的算法 pruneAlg 对稠密矩阵 d_in 进行剪枝。

参数	内存	输入/输出	描述	可选值
`handle`	主机	IN	cuSPARSELt 库句柄
`sparseMatDescr`	主机	IN	结构化（稀疏）矩阵描述符
`isSparseA`	主机	IN	指定结构化(稀疏)矩阵是否位于第一个位置(`matA` 或 `matB`)	`0` 如果为 false，否则为 true
`op`	主机	IN	将在乘法运算中应用于结构化（稀疏）矩阵的操作	`CUSPARSE_OPERATION_NON_TRANSPOSE`, `CUSPARSE_OPERATION_TRANSPOSE`
`d_in`	设备	IN	指向稠密矩阵的指针
`d_out`	设备	输出	指向修剪后矩阵的指针
`pruneAlg`	设备	IN	剪枝算法	`CUSPARSELT_PRUNE_SPMMA_TILE`, `CUSPARSELT_PRUNE_SPMMA_STRIP`
`stream`	主机	IN	用于计算的CUDA流

如果使用CUSPARSELT_PRUNE_SPMMA_TILE，则isSparseA和op不相关。

该函数具有与cusparseLtSpMMAPrune()相同的属性

`cusparseLtSpMMAPruneCheck`#

cusparseStatus_t
cusparseLtSpMMAPruneCheck(const cusparseLtHandle_t*           handle,
                          const cusparseLtMatmulDescriptor_t* matmulDescr,
                          const void*                         d_in,
                          int*                                d_valid,
                          cudaStream_t                        stream)

该函数用于检查给定矩阵的剪枝结构是否正确。使用cusparseLtSpMMAPrune()进行剪枝的数据保证是正确的，因此可以跳过此函数。

参数	内存	输入/输出	描述
`handle`	主机	IN	cuSPARSELt 库句柄
`matmulDescr`	主机	IN	矩阵乘法描述符
`d_in`	设备	IN	指向待检查矩阵的指针
`d_valid`	设备	输出	验证结果 (`0` 正确, `1` 错误)
`stream`	主机	IN	用于计算的CUDA流

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtSpMMAPruneCheck2 [已弃用]`#

cusparseStatus_t
cusparseLtSpMMAPruneCheck2(const cusparseLtHandle_t*        handle,
                           const cusparseLtMatDescriptor_t* sparseMatDescr,
                           int                              isSparseA,
                           cusparseOperation_t              op,
                           const void*                      d_in,
                           int*                             d_valid,
                           cudaStream_t                     stream)

该函数检查给定矩阵的剪枝结构是否正确。

参数	内存	输入/输出	描述	可选值
`handle`	主机	IN	cuSPARSELt 库句柄
`sparseMatDescr`	主机	IN	结构化（稀疏）矩阵描述符
`isSparseA`	主机	IN	指定结构化(稀疏)矩阵是否位于第一个位置(`matA` 或 `matB`)	`0`: false, `!= 0`: true
`op`	主机	IN	将在乘法运算中应用于结构化（稀疏）矩阵的操作	`CUSPARSE_OPERATION_NON_TRANSPOSE`, `CUSPARSE_OPERATION_TRANSPOSE`
`d_in`	设备	IN	指向待检查矩阵的指针
`d_valid`	设备	输出	验证结果 (`0` 正确, `1` 错误)
`stream`	主机	IN	用于计算的CUDA流

该函数具有与cusparseLtSpMMAPruneCheck()相同的属性

`cusparseLtSpMMACompressedSize`#

cusparseStatus_t
cusparseLtSpMMACompressedSize(const cusparseLtHandle_t*     handle,
                              const cusparseLtMatmulPlan_t* plan,
                              size_t*                       compressedSize,
                              size_t*                       compressBufferSize)

该函数提供在调用cusparseLtSpMMACompress()之前需要分配的压缩矩阵的大小。

参数	内存	输入/输出	描述
`handle`	主机	IN	cuSPARSELt 库句柄
`plan`	主机	IN	矩阵计划描述符
`compressedSize`	主机	输出	压缩矩阵的字节大小
`compressBufferSize`	主机	输出	矩阵压缩所需缓冲区的字节大小

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtSpMMACompressedSize2 [已弃用]`#

cusparseStatus_t
cusparseLtSpMMACompressedSize2(const cusparseLtHandle_t*        handle,
                               const cusparseLtMatDescriptor_t* sparseMatDescr,
                               size_t*                          compressedSize,
                               size_t*                          compressBufferSize)

该函数提供在调用cusparseLtSpMMACompress2()之前需要分配的压缩矩阵大小。必须在cusparseLtMatmulPlanInit之后调用。

参数	内存	输入/输出	描述
`handle`	主机	IN	cuSPARSELt 库句柄
`sparseMatDescr`	主机	IN	结构化（稀疏）矩阵描述符
`compressedSize`	主机	输出	压缩矩阵的字节大小
`compressBufferSize`	主机	输出	矩阵压缩所需缓冲区的字节大小

该函数具有与cusparseLtSpMMACompressedSize()相同的属性

`cusparseLtSpMMACompress`#

cusparseStatus_t
cusparseLtSpMMACompress(const cusparseLtHandle_t*     handle,
                        const cusparseLtMatmulPlan_t* plan,
                        const void*                   d_dense,
                        void*                         d_compressed,
                        void*                         d_compressed_buffer,
                        cudaStream_t                  stream)

该函数用于压缩一个稠密矩阵d_dense。经过压缩的矩阵将作为第一个/第二个操作数A/B，用于cusparseLtMatmul()或cusparseLtMatmulSearch()函数。

输入矩阵 d_dense 在传递给此函数前必须经过剪枝处理，剪枝可通过 cusparseLtSpMMAPrune() 或自定义函数完成。剪枝后的数据需满足以下约束条件，具体取决于该矩阵在 cusparseLtMatmul() 中参与运算的类型（由 cusparseLtMatmulDescriptorInit() 创建的 cusparseLtMatmulDescriptor_t 定义）：

对于 op = CUSPARSE_NON_TRANSPOSE
- CUDA_R_4F_E2M1 每行在每八个元素中必须至少包含4对非零值
- CUDA_R_16F, CUDA_R_16BF, CUDA_R_8I, CUDA_R_8F_E4M3, CUDA_R_8F_E5M2 每四个元素中必须至少有两个非零值
- CUDA_R_32F 每行中每两个元素必须至少有一个非零值
当 op = CUSPARSE_TRANSPOSE 时
- CUDA_R_4F_E2M1 每列在每八个元素中必须至少包含4对非零值
- CUDA_R_16F, CUDA_R_16BF, CUDA_R_8I, CUDA_R_8F_E4M3, CUDA_R_8F_E5M2 每列中每四个元素必须至少包含两个非零值
- CUDA_R_32F 每列中每两个元素必须至少有一个非零值

int8, e4m3 和 e5m2 内核应在高SM时钟频率下运行以获得最佳性能。

修剪结果的正确性（矩阵A/B）可以通过函数cusparseLtSpMMAPruneCheck()进行检查。请注意，使用cusparseLtSpMMAPrune() 进行修剪可以保证结果是正确的。

参数	内存	输入/输出	描述
`handle`	主机	IN	cuSPARSELt 库句柄
`plan`	主机	IN	矩阵乘法计划
`d_dense`	设备	IN	指向稠密矩阵的指针
`d_compressed`	设备	输出	指向压缩矩阵的指针
`d_compressed_buffer`	设备	输出	指向压缩临时缓冲区的指针
`stream`	主机	IN	用于计算的CUDA流

属性

该例程支持相对于stream的异步执行

每次运行提供确定性（逐位）结果

cusparseLtSpMMACompress() has to be called each time after the algorithm ID is updated with cusparseLtMatmulAlgGetAttribute().

cusparseLtSpMMACompress() supports the following 优化:

CUDA图捕获

硬件内存压缩

有关返回状态的描述，请参见cusparseStatus_t。

`cusparseLtSpMMACompress2 [已弃用]`#

cusparseStatus_t
cusparseLtSpMMACompress2(const cusparseLtHandle_t*        handle,
                         const cusparseLtMatDescriptor_t* sparseMatDescr,
                         int                              isSparseA,
                         cusparseOperation_t              op,
                         const void*                      d_dense,
                         void*                            d_compressed,
                         void*                            d_compressed_buffer,
                         cudaStream_t                     stream)

参数	内存	输入/输出	描述	可选值
`handle`	主机	IN	cuSPARSELt 库句柄
`sparseMatDescr`	主机	IN	结构化（稀疏）矩阵描述符
`isSparseA`	主机	IN	指定结构化(稀疏)矩阵是否位于第一个位置(`matA` 或 `matB`)	`0` 如果为 false，否则为 true
`op`	主机	IN	将在乘法运算中应用于结构化（稀疏）矩阵的操作	`CUSPARSE_OPERATION_NON_TRANSPOSE`, `CUSPARSE_OPERATION_TRANSPOSE`
`d_dense`	设备	IN	指向稠密矩阵的指针
`d_compressed`	设备	输出	指向压缩矩阵的指针
`d_compressed_buffer`	设备	输出	指向用于压缩的临时缓冲区的指针
`stream`	主机	IN	用于计算的CUDA流

该函数具有与cusparseLtSpMMACompress()相同的属性

cuSPARSELt 函数#

库管理函数#

cusparseLtInit#

cusparseLtDestroy#

cusparseLtGetVersion#

cusparseLtGetProperty#

矩阵描述符函数#

cusparseLtDenseDescriptorInit#

cusparseLtStructuredDescriptorInit#

cusparseLtMatDescriptorDestroy#

cusparseLtMatDescSetAttribute#

cusparseLtMatDescGetAttribute#

矩阵乘法描述符函数#

cusparseLtMatmulDescriptorInit#

cusparseLtMatmulDescSetAttribute#

cusparseLtMatmulDescGetAttribute#

矩阵乘法算法函数#

cusparseLtMatmulAlgSelectionInit#

cusparseLtMatmulAlgSetAttribute#

cusparseLtMatmulAlgGetAttribute#

矩阵乘法函数#

cusparseLtMatmulGetWorkspace#

cusparseLtMatmulPlanInit#

cusparseLtMatmulPlanDestroy#

cusparseLtMatmul#

cusparseLtMatmulSearch#

辅助函数#

cusparseLtSpMMAPrune#

cusparseLtSpMMAPrune2 [已弃用]#

cusparseLtSpMMAPruneCheck#

cusparseLtSpMMAPruneCheck2 [已弃用]#

cusparseLtSpMMACompressedSize#

cusparseLtSpMMACompressedSize2 [已弃用]#

cusparseLtSpMMACompress#

cusparseLtSpMMACompress2 [已弃用]#

`cusparseLtInit`#

`cusparseLtDestroy`#

`cusparseLtGetVersion`#

`cusparseLtGetProperty`#

`cusparseLtDenseDescriptorInit`#

`cusparseLtStructuredDescriptorInit`#

`cusparseLtMatDescriptorDestroy`#

`cusparseLtMatDescSetAttribute`#

`cusparseLtMatDescGetAttribute`#

`cusparseLtMatmulDescriptorInit`#

`cusparseLtMatmulDescSetAttribute`#

`cusparseLtMatmulDescGetAttribute`#

`cusparseLtMatmulAlgSelectionInit`#

`cusparseLtMatmulAlgSetAttribute`#

`cusparseLtMatmulAlgGetAttribute`#

`cusparseLtMatmulGetWorkspace`#

`cusparseLtMatmulPlanInit`#

`cusparseLtMatmulPlanDestroy`#

`cusparseLtMatmul`#

`cusparseLtMatmulSearch`#

`cusparseLtSpMMAPrune`#

`cusparseLtSpMMAPrune2 [已弃用]`#

`cusparseLtSpMMAPruneCheck`#

`cusparseLtSpMMAPruneCheck2 [已弃用]`#

`cusparseLtSpMMACompressedSize`#

`cusparseLtSpMMACompressedSize2 [已弃用]`#

`cusparseLtSpMMACompress`#

`cusparseLtSpMMACompress2 [已弃用]`#