cuSPARSELt 函数#

库管理函数#

`cusparseLtInit`#

cusparseStatus_t
cusparseLtInit(cusparseLtHandle_t* handle)

此函数初始化 cuSPARSELt 库句柄 (cusparseLtHandle_t)，它保存 cuSPARSELt 库上下文。它在主机上分配轻量级硬件资源，并且必须在进行任何其他 cuSPARSELt 库调用之前调用。在未事先调用 cusparseLtInit() 的情况下调用任何使用 cusparseLtHandle_t 的 cusparseLt 函数将返回错误。

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

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

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

`cusparseLtDestroy`#

cusparseStatus_t
cusparseLtDestroy(const cusparseLtHandle_t* handle)

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

在 cusparseLtDestroy() 之后调用任何使用 cusparseLtHandle_t 的 cusparseLt 函数将返回错误。

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

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

`cusparseLtGetVersion`#

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

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

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

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

`cusparseLtGetProperty`#

cusparseStatus_t
cusparseLtGetProperty(libraryPropertyType propertyType,
                      int*                value)

此函数返回请求属性的值。有关支持的类型，请参阅 libraryPropertyType。

参数	内存	输入/输出	描述
`propertyType`	主机	输入	请求的属性
`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`	主机	输入	cuSPARSELt 库句柄
`matDescr`	主机	输出	稠密矩阵描述
`rows`	主机	输入	行数
`cols`	主机	输入	列数
`ld`	主机	输入	主导维度	≥ 如果为列优先，则为行数，≥ 如果为行优先，则为列数
`alignment`	主机	输入	内存对齐（字节）	16 的倍数
`valueType`	主机	输入	矩阵的数据类型	`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`	主机	输入	内存布局	`CUSPARSE_ORDER_COL`, `CUSPARSE_ORDER_ROW`

约束:

如果 valueType 是 CUDA_R_8I, CUDA_R_8F_E4M3, CUDA_R_8F_E5M2, 或 CUDA_R_4F_E2M1，则 rows, cols, 和 ld 必须是

16 的倍数

如果 valueType 是 CUDA_R_16F 或 CUDA_R_16BF

8 的倍数

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

如果 `valueType` 是 `CUDA_R_32F`

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)

4 的倍数

参数	内存	输入/输出	描述	可能的值
`handle`	主机	输入	cuSPARSELt 库句柄
`matDescr`	主机	输出	`cusparseLtStructuredDescriptorInit`#
`rows`	主机	输入	行数
`cols`	主机	输入	列数
`ld`	主机	输入	主导维度	≥ 如果为列优先，则为行数，≥ 如果为行优先，则为列数
`alignment`	主机	输入	内存对齐（字节）	16 的倍数
`valueType`	主机	输入	矩阵的数据类型	`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`	主机	输入	内存布局	`CUSPARSE_ORDER_COL`, `CUSPARSE_ORDER_ROW`
`此函数初始化结构化矩阵的描述符。`	主机	输入	稀疏矩阵描述	`sparsity`

约束:

如果 valueType 是 CUDA_R_8I, CUDA_R_8F_E4M3, CUDA_R_8F_E5M2, 或 CUDA_R_4F_E2M1，则 rows, cols, 和 ld 必须是

矩阵稀疏度比率

CUSPARSELT_SPARSITY_50_PERCENT

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

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

32 的倍数

cusparseStatus_t
cusparseLtMatDescriptorDestroy(const cusparseLtMatDescriptor_t* matDescr)

如果 valueType 是 CUDA_R_16F, 或 CUDA_R_16BF

参数	内存	输入/输出	描述
`matDescr`	主机	输入	16 的倍数

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

如果 `valueType` 是 `CUDA_R_32F`

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

8 的倍数

参数	内存	输入/输出	描述	可能的值
`handle`	主机	输入	cuSPARSELt 库句柄
`cusparseLtMatDescriptorDestroy#`	主机	输出	16 的倍数
`此函数释放矩阵描述符实例使用的资源。在此调用之后，矩阵描述符、matmul 描述符和 plan 将无法再使用。`	主机	输入	matDescr	矩阵描述符
`cusparseLtMatDescSetAttribute#`	主机	输入	此函数设置属于矩阵描述符的指定属性的值，例如批次数量及其步幅。
`matDescr`	主机	输入	matmulDescr

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

matAttribute

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

要设置的属性

参数	内存	输入/输出	描述	可能的值
`handle`	主机	输入	cuSPARSELt 库句柄
`cusparseLtMatDescriptorDestroy#`	主机	输入	16 的倍数
`此函数释放矩阵描述符实例使用的资源。在此调用之后，矩阵描述符、matmul 描述符和 plan 将无法再使用。`	主机	输入	`CUSPARSELT_MAT_NUM_BATCHES`, `CUSPARSELT_MAT_BATCH_STRIDE`	矩阵描述符
`cusparseLtMatDescSetAttribute#`	主机	输出	data
`matDescr`	主机	输入	matmulDescr

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

指向将要设置的指定属性值的指针

dataSize

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`	主机	输入	cuSPARSELt 库句柄
`cusparseLtMatDescriptorDestroy#`	主机	输出	`cusparseLtMatDescGetAttribute`#
`此函数获取属于矩阵描述符的指定属性的值，例如批次数量及其步幅。`	主机	输入	matDescr	matAttribute
`要检索的属性`	主机	输入	data	matAttribute
`包含此函数检索的属性值的内存地址`	主机	输入	Matmul 描述符函数#
`cusparseLtMatmulDescriptorInit#`	主机	输入	此函数初始化矩阵乘法描述符。
`matmulDescr`	主机	输入	矩阵乘法描述符
`opA`	主机	输入	应用于矩阵 `A` 的运算
`CUSPARSE_OPERATION_NON_TRANSPOSE, CUSPARSE_OPERATION_TRANSPOSE`	主机	输入	opB	应用于矩阵 `B` 的运算

matA

约束:

结构化或稠密矩阵描述符 A

matB

结构化或稠密矩阵描述符 B

matC

稠密矩阵描述符 C

matD

稠密矩阵描述符 D

computeType

计算精度

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

`CUSPARSE_COMPUTE_32I`, `CUSPARSE_COMPUTE_32F`, `CUSPARSE_COMPUTE_16F`

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

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

参数	内存	输入/输出	描述
`handle`	主机	输入	cuSPARSELt 库句柄
`cusparseLtMatDescriptorDestroy#`	主机	输出	16 的倍数
`有关支持的数据类型，请参阅` `cusparseLtMatmul()。`	主机	输入	matDescr	`CUDA_R_8I`, `CUDA_R_8F_E4M3`,`CUDA_R_8F_E5M2` 和 `CUDA_R_4F_E2M1` 数据类型仅支持（如果 `B` 是结构化的，则相反）
`cusparseLtMatDescSetAttribute#`	主机	输入	此函数设置属于矩阵描述符的指定属性的值，例如批次数量及其步幅。
`matDescr`	主机	输入	matmulDescr

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

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

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

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

参数	内存	输入/输出	描述
`handle`	主机	输入	cuSPARSELt 库句柄
`cusparseLtMatDescriptorDestroy#`	主机	输出	16 的倍数
`有关支持的数据类型，请参阅` `cusparseLtMatmul()。`	主机	输入	`CUSPARSELT_MAT_NUM_BATCHES`, `CUSPARSELT_MAT_BATCH_STRIDE`	`CUDA_R_8I`, `CUDA_R_8F_E4M3`,`CUDA_R_8F_E5M2` 和 `CUDA_R_4F_E2M1` 数据类型仅支持（如果 `B` 是结构化的，则相反）
`cusparseLtMatDescSetAttribute#`	主机	输出	data
`matDescr`	主机	输入	matmulDescr

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

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

`opA/opB = TT` 如果矩阵顺序为 `orderA/orderB = Col/Row`

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

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

参数	内存	输入/输出	描述	可能的值
`handle`	主机	输入	cuSPARSELt 库句柄
`矩阵 C 和 D 的每个维度（行和列）的最大元素数量限制为 2097120。`	主机	输出	如果输入 A/B=`E4M3`，输出 D=`E4M3`，缩放=`VEC64_UE8M0`，则矩阵 `C` 和 `D` 的连续维度的最小元素数量为 64。
`cusparseLtMatDescriptorDestroy#`	主机	输入	`cusparseLtMatDescGetAttribute`#
`cusparseLtMatmulDescSetAttribute#`	主机	输入	此函数设置属于矩阵描述符的指定属性的值，例如激活函数和偏置。	`matmulAttribute`

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

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

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

cusparseLtMatmulDescGetAttribute#

参数	内存	输入/输出	描述	可能的值
`handle`	主机	输入	cuSPARSELt 库句柄
`矩阵 C 和 D 的每个维度（行和列）的最大元素数量限制为 2097120。`	主机	输出	如果输入 A/B=`E4M3`，输出 D=`E4M3`，缩放=`VEC64_UE8M0`，则矩阵 `C` 和 `D` 的连续维度的最小元素数量为 64。
`此函数获取属于矩阵描述符的指定属性的值，例如激活函数和偏置。`	主机	输入	matmulDescr	matmulAttribute
`cusparseLtMatDescSetAttribute#`	主机	输入	此函数设置属于矩阵描述符的指定属性的值，例如批次数量及其步幅。
`matDescr`	主机	输入	matmulDescr

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

要检索的属性

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

data

参数	内存	输入/输出	描述	可能的值
`handle`	主机	输入	cuSPARSELt 库句柄
`矩阵 C 和 D 的每个维度（行和列）的最大元素数量限制为 2097120。`	主机	输入	如果输入 A/B=`E4M3`，输出 D=`E4M3`，缩放=`VEC64_UE8M0`，则矩阵 `C` 和 `D` 的连续维度的最小元素数量为 64。
`此函数获取属于矩阵描述符的指定属性的值，例如激活函数和偏置。`	主机	输入	包含此函数检索的属性值的内存地址	Matmul 算法函数#
`cusparseLtMatDescSetAttribute#`	主机	输出	data
`matDescr`	主机	输入	matmulDescr

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

`cusparseLtMatmulAlgSelectionInit`#

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

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

algSelection

参数	内存	输入/输出	描述
`handle`	主机	输入	cuSPARSELt 库句柄
`算法选择描述符`	主机	输入	alg
`算法模式`	主机	输出	CUSPARSELT_MATMUL_ALG_DEFAULT

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

`cusparseLtMatmulAlgSetAttribute`#

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

参数	内存	输入/输出	描述
`handle`	主机	输入	cuSPARSELt 库句柄
`算法选择描述符`	主机	输出	alg
`cusparseLtMatDescriptorDestroy#`	主机	输入	`cusparseLtMatDescGetAttribute`#
`矩阵 C 和 D 的每个维度（行和列）的最大元素数量限制为 2097120。`	主机	输入	如果输入 A/B=`E4M3`，输出 D=`E4M3`，缩放=`VEC64_UE8M0`，则矩阵 `C` 和 `D` 的连续维度的最小元素数量为 64。

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

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

cusparseStatus_t
cusparseLtMatmulPlanDestroy(const cusparseLtMatmulPlan_t* plan)

algSelection

attribute

参数	内存	输入/输出	描述
`算法选择描述符`	主机	输入	alg

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

要设置的属性

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)

CUSPARSELT_MATMUL_ALG_CONFIG_ID, CUSPARSELT_MATMUL_SEARCH_ITERATIONS, CUSPARSELT_MATMUL_SPLIT_K, CUSPARSELT_MATMUL_SPLIT_K_MODE, CUSPARSELT_MATMUL_SPLIT_K_BUFFERS

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

cusparseLtMatmulAlgGetAttribute#

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

algSelection

参数	内存	输入/输出	描述
`handle`	主机	输入	cuSPARSELt 库句柄
`算法选择描述符`	主机	输入	alg
`attribute`	将由此函数检索的属性	输入	`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`
`Matmul 函数#`	`cusparseLtMatmulGetWorkspace`#	输入	此函数确定与所选算法关联的所需工作空间大小。
`plan`	`cusparseLtMatmulGetWorkspace`#	输入	矩阵乘法计划
`workspaceSize`	将由此函数检索的属性	输入	工作空间大小（以字节为单位）
`cusparseLtMatmulPlanInit#`	`cusparseLtMatmulGetWorkspace`#	输入	plan
`matmulPlan`	`cusparseLtMatmulGetWorkspace`#	输出	矩阵乘法计划
`cusparseLtMatmulPlanDestroy#`	`cusparseLtMatmulGetWorkspace`#	输入	此函数释放矩阵乘法计划实例使用的资源。此函数是使用特定计划实例的最后一次调用。
`在 cusparseLtMatmulPlanDestroy() 之后调用任何使用 cusparseLtMatmulPlan_t 的 cusparseLt 函数将返回错误。`	主机	输入	matmulPlan
`plan`	主机	输入	矩阵乘法计划

cusparseLtMatmul#

此函数计算矩阵 `A` 和 `B` 的矩阵乘法，以生成输出矩阵 `D`，根据以下运算	其中 `A`、`B` 和 `C` 是输入矩阵， $\alpha$ 和 $\beta$ 是输入标量或标量向量（设备端指针）。	如 cusparseLtMatmulDescriptorInit() 所述，输入矩阵 A 或 B 中有且仅有一个应具有结构化稀疏性，并且相应的 `d_A` 或 `d_B` 结构化稀疏矩阵指针应为 cusparseLtSpMMACompress() 或 cusparseLtSpMMACompress2() 的输出。	注意：此函数目前仅支持 `D` 具有与 `C` 相同形状的情况
`alpha`	`alpha`		`主机/设备`
`用于乘法的标量/标量向量 (float 数据类型)。如果 alpha 是标量 - 这应该是指向主机内存的指针，否则 - 指向设备内存的指针`	`用于乘法的标量/标量向量 (float 数据类型)。如果 alpha 是标量 - 这应该是指向主机内存的指针，否则 - 指向设备内存的指针`		`主机/设备`
			`d_A`
`设备`	`设备`		`主机/设备`
`指向结构化或稠密矩阵 A 的指针`	`指向结构化或稠密矩阵 A 的指针`		`d_B`
	`指向结构化或稠密矩阵 B 的指针`
	`用于乘法的标量/标量向量 (float 数据类型)。如果 alpha 是标量 - 这应该是指向主机内存的指针，否则 - 指向设备内存的指针`
	`设备`
beta	`用于乘法的标量/标量向量 (float 数据类型)。如果 alpha 是标量 - 这应该是指向主机内存的指针，否则 - 指向设备内存的指针`	$\beta$ 用于乘法的标量/标量向量 (`float` 数据类型)。仅当设置了 `CUSPARSELT_MATMUL_ALPHA_VECTOR_SCALING` 但未设置 `CUSPARSELT_MATMUL_BETA_VECTOR_SCALING` 时，它可以具有 `NULL` 值。如果 beta 是标量 - 这应该是指向主机内存的指针，否则 - 指向设备内存的指针	`主机/设备`
	`设备`	d_C
	`用于乘法的标量/标量向量 (float 数据类型)。如果 alpha 是标量 - 这应该是指向主机内存的指针，否则 - 指向设备内存的指针`
	`设备`
	`alpha`
`指向稠密矩阵 C 的指针`	`用于乘法的标量/标量向量 (float 数据类型)。如果 alpha 是标量 - 这应该是指向主机内存的指针，否则 - 指向设备内存的指针`	`指向稠密矩阵 C 的指针`	`主机/设备`
	`设备`	`指向稠密矩阵 C 的指针`
	`用于乘法的标量/标量向量 (float 数据类型)。如果 alpha 是标量 - 这应该是指向主机内存的指针，否则 - 指向设备内存的指针`
	`设备`
	`alpha`
d_D	`用于乘法的标量/标量向量 (float 数据类型)。如果 alpha 是标量 - 这应该是指向主机内存的指针，否则 - 指向设备内存的指针`	指向稠密矩阵 `D` 的指针	`主机/设备`
	`设备`	workspace
	`用于乘法的标量/标量向量 (float 数据类型)。如果 alpha 是标量 - 这应该是指向主机内存的指针，否则 - 指向设备内存的指针`
	`设备`
	`alpha`

指向用于计算的 CUDA 流数组的指针

约束

numStreams

streams 中的 CUDA 流数量

支持的数据类型

输入 A/B

输入 C

输出 D

计算

CUDA_R_32F

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

CUDA_R_32F

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)

CUDA_R_32F

CUSPARSE_COMPUTE_32F

CUDA_R_16F

CUDA_R_16F

CUDA_R_16F

CUSPARSE_COMPUTE_16F

参数	内存	输入/输出	描述
`handle`	主机	输入	cuSPARSELt 库句柄
`算法选择描述符`	主机	输出	alg
`attribute`	主机	输入	CUDA_R_16BF
`Matmul 函数#`	`cusparseLtMatmulGetWorkspace`#	输入	此函数确定与所选算法关联的所需工作空间大小。
`plan`	`cusparseLtMatmulGetWorkspace`#	输入	矩阵乘法计划
`workspaceSize`	主机	输入	CUDA_R_16BF
`cusparseLtMatmulPlanInit#`	`cusparseLtMatmulGetWorkspace`#	输入	plan
`matmulPlan`	`cusparseLtMatmulGetWorkspace`#	输出	矩阵乘法计划
`cusparseLtMatmulPlanDestroy#`	`cusparseLtMatmulGetWorkspace`#	输入	此函数释放矩阵乘法计划实例使用的资源。此函数是使用特定计划实例的最后一次调用。
`在 cusparseLtMatmulPlanDestroy() 之后调用任何使用 cusparseLtMatmulPlan_t 的 cusparseLt 函数将返回错误。`	主机	输入	matmulPlan
`plan`	主机	输入	矩阵乘法计划

CUDA_R_16BF

CUDA_R_8I

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

CUDA_R_8I

参数	内存	输入/输出	描述	可能的值
`handle`	主机	输入	cuSPARSELt 库句柄
`cusparseLtMatDescriptorDestroy#`	主机	输入	`cusparseLtMatDescGetAttribute`#
`CUDA_R_8I`	`cusparseLtMatmulGetWorkspace`#	输入	CUSPARSE_COMPUTE_32I
`CUDA_R_32I`	`cusparseLtMatmulGetWorkspace`#	输出	CUDA_R_32I
`CUDA_R_32I`	`cusparseLtMatmulGetWorkspace`#	输入	`CUDA_R_8F_E4M3` [1]	`CUDA_R_8F_E4M3` [1]
`CUDA_R_8F_E4M3 [1]`	主机	输入	CUDA_R_8F_E5M2

streams 中的 CUDA 流数量

支持的数据类型

CUDA_R_8F_E5M2

输入 C

CUDA_R_8F_E5M2

计算

CUDA_R_32F

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

`CUDA_R_4F_E2M1` [2]

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);

CUDA_R_8I

参数	内存	输入/输出	描述	可能的值
`handle`	主机	输入	cuSPARSELt 库句柄
`CUDA_R_4F_E2M1` `[2]`	主机	输入	`CUDA_R_4F_E2M1` [2]
`既支持非块缩放也支持块缩放。有关如何设置块缩放模式和因子的信息，请参阅 cusparseLtMatmulMatrixScale_t 和 cusparseLtMatmulDescAttribute_t。`	主机	输入	块缩放。	有关哪些 GPU 计算能力支持哪些数据类型组合的详细列表，请参阅主要特性
`所有指针必须 16 字节对齐`	主机	输入	属性	matAttribute
`CUDA_R_8I`	`cusparseLtMatmulGetWorkspace`#	输入	CUSPARSE_COMPUTE_32I
`CUDA_R_32I`	`cusparseLtMatmulGetWorkspace`#	输出	CUDA_R_32I
`CUDA_R_32I`	`cusparseLtMatmulGetWorkspace`#	输入	`CUDA_R_8F_E4M3` [1]	`CUDA_R_8F_E4M3` [1]
`CUDA_R_8F_E4M3 [1]`	主机	输入	CUDA_R_8F_E5M2

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

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

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

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

cusparseLtMatmul 支持以下优化

参数	内存	输入/输出	描述
`handle`	主机	输入	cuSPARSELt 库句柄
`cusparseLtMatDescriptorDestroy#`	主机	输入	`cusparseLtMatDescGetAttribute`#
`CUDA_R_8I`	`cusparseLtMatmulGetWorkspace`#	输入	CUDA 图捕获
`硬件内存压缩`	`cusparseLtMatmulGetWorkspace`#	输出	`cusparseLtMatmulSearch`#
`CUDA_R_8F_E4M3 [1]`	主机	输入	CUDA_R_8F_E5M2

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

此函数评估由 `plan` 描述的矩阵乘法的所有可用算法，并通过选择最快的算法自动更新用于初始化 `plan` 的 `cusparseLtMatmulAlgSelection_t`。此功能旨在用于自动调优目的，当相同的操作在不同的输入上重复多次时。

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)

此函数行为类似于 cusparseLtMatmul()，不同之处在于如果操作是就地执行 (d_C=d_D)，则 d_D 值可能会累积。

参数	内存	输入/输出	描述	可能的值
`handle`	主机	输入	cuSPARSELt 库句柄
`CUDA_R_4F_E2M1` `[2]`	主机	输入	`CUDA_R_4F_E2M1` [2]
`既支持非块缩放也支持块缩放。有关如何设置块缩放模式和因子的信息，请参阅 cusparseLtMatmulMatrixScale_t 和 cusparseLtMatmulDescAttribute_t。`	主机	输入	块缩放。	此函数相对于 `streams[0]` 不是异步的（阻塞调用）
`所有指针必须 16 字节对齐`	主机	输入	属性	matAttribute
`CUDA_R_8I`	`cusparseLtMatmulGetWorkspace`#	输入	CUDA 图捕获
`硬件内存压缩`	`cusparseLtMatmulGetWorkspace`#	输出	`cusparseLtMatmulSearch`#
`CUDA_R_8F_E4M3 [1]`	主机	输入	CUDA_R_8F_E5M2

评估的迭代次数可以使用 cusparseLtMatmulAlgSetAttribute() 和 CUSPARSELT_MATMUL_SEARCH_ITERATIONS 设置。

可以使用 cusparseLtMatmulAlgGetAttribute() 和 `CUSPARSELT_MATMUL_ALG_CONFIG_ID` 检索所选的算法 ID。

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

此函数还搜索 Split-K 参数的最佳组合。可以使用 cusparseLtMatmulAlgGetAttribute() 检索所选的值。

参数	内存	输入/输出	描述
`handle`	主机	输入	cuSPARSELt 库句柄
`算法选择描述符`	主机	输入	alpha
`用于乘法的标量/标量向量 (float 数据类型)`	主机	输出	d_A
`设备`	主机	输出	指向结构化或稠密矩阵 `A` 的指针

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

d_B

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

指向结构化或稠密矩阵 B 的指针

参数	内存	输入/输出	描述
`handle`	主机	输入	cuSPARSELt 库句柄
`CUDA_R_4F_E2M1` `[2]`	主机	输入	`CUDA_R_4F_E2M1` [2]
`用于乘法的标量/标量向量 (float 数据类型)`	主机	输出	beta
`设备`	主机	输出	指向结构化或稠密矩阵 `A` 的指针

该函数具有与 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。压缩后的矩阵旨在用作 cusparseLtMatmul() 或 cusparseLtMatmulSearch() 函数中的第一个/第二个操作数 A/B。

此函数的输入矩阵 d_dense 必须使用 cusparseLtSpMMAPrune() <cusparseLtSpMMAPrune-label> 或自定义函数进行剪枝。剪枝后的数据应遵守以下约束，具体取决于 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 时钟频率下运行，以最大限度地提高性能。

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

参数	内存	输入/输出	描述
`handle`	主机	输入	cuSPARSELt 库句柄
`算法选择描述符`	主机	输入	alg
`d_dense`	`cusparseLtMatmulGetWorkspace`#	输入	CUSPARSE_COMPUTE_32I
`d_compressed`	`cusparseLtMatmulGetWorkspace`#	输出	指向压缩后的矩阵的指针
`d_compressed_buffer`	`cusparseLtMatmulGetWorkspace`#	输出	指向压缩的临时缓冲区的指针
`CUDA_R_8F_E4M3 [1]`	主机	输入	CUDA_R_8F_E5M2

streams 中的 CUDA 流数量

CUDA_R_8F_E5M2

输入 C

每次使用 cusparseLtMatmulAlgGetAttribute() 更新算法 ID 后，都必须调用 cusparseLtSpMMACompress()。

cusparseLtSpMMACompress() 支持以下优化

计算

CUDA_R_32F

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

`cusparseLtSpMMACompress2 [DEPRECATED]`#

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`	主机	输入	cuSPARSELt 库句柄
`CUDA_R_4F_E2M1` `[2]`	主机	输入	`CUDA_R_4F_E2M1` [2]
`既支持非块缩放也支持块缩放。有关如何设置块缩放模式和因子的信息，请参阅 cusparseLtMatmulMatrixScale_t 和 cusparseLtMatmulDescAttribute_t。`	主机	输入	块缩放。	有关哪些 GPU 计算能力支持哪些数据类型组合的详细列表，请参阅主要特性
`所有指针必须 16 字节对齐`	主机	输入	属性	matAttribute
`d_dense`	`cusparseLtMatmulGetWorkspace`#	输入	CUSPARSE_COMPUTE_32I
`d_compressed`	`cusparseLtMatmulGetWorkspace`#	输出	指向压缩后的矩阵的指针
`d_compressed_buffer`	`cusparseLtMatmulGetWorkspace`#	输出	指向压缩的临时缓冲区的指针
`CUDA_R_8F_E4M3 [1]`	主机	输入	CUDA_R_8F_E5M2

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

cuSPARSELt 函数#

库管理函数#

cusparseLtInit#

cusparseLtDestroy#

cusparseLtGetVersion#

cusparseLtGetProperty#

矩阵描述符函数#

cusparseLtDenseDescriptorInit#

如果 valueType 是 CUDA_R_32F

32 的倍数

如果 valueType 是 CUDA_R_32F

matAttribute

指向将要设置的指定属性值的指针

dataSize

CUSPARSE_COMPUTE_32I, CUSPARSE_COMPUTE_32F, CUSPARSE_COMPUTE_16F

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

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

opA/opB = TT 如果矩阵顺序为 orderA/orderB = Col/Row

要检索的属性

cusparseLtMatmulAlgSelectionInit#

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

cusparseLtMatmulAlgSetAttribute#

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

要设置的属性

CUDA_R_32F

CUDA_R_16BF

CUDA_R_8I

CUDA_R_4F_E2M1 [2]

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

此函数评估由 plan 描述的矩阵乘法的所有可用算法，并通过选择最快的算法自动更新用于初始化 plan 的 cusparseLtMatmulAlgSelection_t。此功能旨在用于自动调优目的，当相同的操作在不同的输入上重复多次时。

可以使用 cusparseLtMatmulAlgGetAttribute() 和 CUSPARSELT_MATMUL_ALG_CONFIG_ID 检索所选的算法 ID。

d_B

cusparseLtSpMMACompress#

cusparseLtSpMMACompress2 [DEPRECATED]#

`cusparseLtInit`#

`cusparseLtDestroy`#

`cusparseLtGetVersion`#

`cusparseLtGetProperty`#

`cusparseLtDenseDescriptorInit`#

如果 `valueType` 是 `CUDA_R_32F`

如果 `valueType` 是 `CUDA_R_32F`

`CUSPARSE_COMPUTE_32I`, `CUSPARSE_COMPUTE_32F`, `CUSPARSE_COMPUTE_16F`

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

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

`opA/opB = TT` 如果矩阵顺序为 `orderA/orderB = Col/Row`

`cusparseLtMatmulAlgSelectionInit`#

`cusparseLtMatmulAlgSetAttribute`#

`CUDA_R_4F_E2M1` [2]

此函数评估由 `plan` 描述的矩阵乘法的所有可用算法，并通过选择最快的算法自动更新用于初始化 `plan` 的 `cusparseLtMatmulAlgSelection_t`。此功能旨在用于自动调优目的，当相同的操作在不同的输入上重复多次时。

可以使用 cusparseLtMatmulAlgGetAttribute() 和 `CUSPARSELT_MATMUL_ALG_CONFIG_ID` 检索所选的算法 ID。

`cusparseLtSpMMACompress`#

`cusparseLtSpMMACompress2 [DEPRECATED]`#