aclnnCompressor

产品支持情况

  • Ascend 950PR&950DT系列产品:支持
  • Atlas A3系列产品:支持
  • Atlas A2系列产品:支持
  • Atlas 200I/500 A2推理产品:不支持
  • Atlas推理系列产品:不支持
  • Atlas训练系列产品:不支持

功能说明

  • 接口功能:Compressor是推理场景下SMLA和QLI的前处理算子,用于将每4或128个token的KV cache压缩成一个,然后每个token与这些压缩的KV cache进行DSA计算。在长序列的情况下,Compressor可以有效地减少计算开销。主要计算过程为:

    1. 将输入XX与WKVW^{KV}做Matmul运算得到kv_statekv\_state,将输入XX与WGateW^{Gate}做Matmul运算后再与ApeApe做Add运算得到score_statescore\_state,kv_statekv\_state与score_statescore\_state根据输入的start_pos及cu_seqlens完成更新。
    2. 在coff为2的情况下对kv_statekv\_state和score_statescore\_state进行数据重排。
    3. 对score_statescore\_state进行softmax运算将softmax结果与kv_statekv\_state做Mul计算,后进行ReduceSum运算。
  • 计算公式:

    1. 计算矩阵乘法:

      C4A:[kv_statea,score_statea]=X@[WaKV,WaGate],[kv_stateb,score_stateb]=X@[WbKV,WbGate];C4A:\left[kv\_state^a, score\_state^a\right] = X @ \left[W^{aKV}, W^{aGate}\right], \left[kv\_state^b, score\_state^b\right] = X @ \left[W^{bKV}, W^{bGate}\right];

      C128A:[kv_state,score_state]=X@[WKV,WGate]C128A:\left[kv\_state, score\_state\right] = X @ \left[W^{KV}, W^{Gate}\right]

    2. 计算分组加法:

      C4A:score_statei′=[score_state[4(i−1)+1:4i,:]a;score_state[4i+1:4(i+1),:]b]+Ape, i=1,2,⋯ ,s4;C4A:score\_state_i^\prime = \left[score\_state_{\left[4(i-1)+1:4i,:\right]}^a; score\_state_{\left[4i+1:4(i+1),:\right]}^b\right] + Ape,~i=1,2,\cdots, \frac{s}{4};

      C128A:score_statei′=score_state[128(i−1)+1:128i,:]+Ape, i=1,2,⋯ ,s128;C128A:score\_state_i^\prime = score\_state_{\left[128(i-1)+1:128i,:\right]} + Ape,~i=1,2,\cdots, \frac{s}{128};

    3. 计算分组Softmax:

      C4A:Si′=softmax(score_statei′), i=1,2,⋯ ,s4;C4A:S_i^\prime = softmax(score\_state_i^\prime),~i=1,2,\cdots, \frac{s}{4};

      C128A:Si′=softmax(score_statei′), i=1,2,⋯ ,s128;C128A:S_i^\prime = softmax(score\_state_i^\prime),~i=1,2,\cdots, \frac{s}{128};

    4. 计算Hadamard乘积:

      C4A:(SH)i=Si′⊙[kv_state[4(i−1)+1:4i,:]a;kv_state[4i+1:4(i+1),:]b], i=1,2,⋯ ,s4;C4A:(S_H)_i = S_i^\prime \odot \left[kv\_state^a_{\left[4(i-1)+1:4i,:\right]} ;kv\_state^b_{\left[4i+1:4(i+1),:\right]}\right],~i=1,2,\cdots, \frac{s}{4};

      C128A:SH=Si′⊙kv_state;C128A:S_H = S_i^\prime \odot kv\_state;

    5. 沿着压缩轴分组求和:

      C4A:CiComp=[1]1×8@(SH)i, i=1,2,⋯ ,s4;C4A:C_{i}^{\text{Comp}} = \left[1\right]_{1\times8} @ (S_H)_i, ~i=1,2,\cdots, \frac{s}{4};

      C128A:CiComp=[1]1×128@(SH)i, i=1,2,⋯ ,s128;C128A:C_{i}^{\text{Comp}} = \left[1\right]_{1\times128} @ (S_H)_i, ~i=1,2,\cdots, \frac{s}{128};

函数原型

每个算子分为两段式接口,必须先调用“aclnnCompressorGetWorkspaceSize”接口获取计算所需workspace大小以及包含了算子计算流程的执行器,再调用“aclnnCompressor”接口执行计算。

aclnnStatus aclnnCompressorGetWorkspaceSize(
    const aclTensor *x,
    const aclTensor *wkv,
    const aclTensor *wgate,
    aclTensor       *stateCacheRef,
    const aclTensor *ape,
    const aclTensor *stateBlockTableOptional,
    const aclTensor *cuSeqlensOptional,
    const aclTensor *sequsedOptional,
    const aclTensor *startPosOptional,
    int64_t          cmpRatio,
    int64_t          coff,
    int64_t          cacheMode,
    int64_t          stateCacheStrideDim0,
    bool             gradEnabled,
    const aclTensor *cmpKvOut,
    const aclTensor *softmaxScoreOut,
    const aclTensor *kvOut,
    uint64_t        *workspaceSize,
    aclOpExecutor   **executor)
aclnnStatus aclnnCompressor(
    void           *workspace,
    uint64_t        workspaceSize,
    aclOpExecutor  *executor,
    aclrtStream     stream)

aclnnCompressorGetWorkspaceSize

  • 参数说明

    参数名 输入/输出 描述 使用说明 数据类型 数据格式 维度(shape) 非连续Tensor
    x(const aclTensor*) 输入 公式中的X,表示原始不经压缩的数据。
    • 支持B=0、S=0、T=0的空Tensor。
    • B(Batch Size)表示输入样本批量大小、S(Sequence Length)表示输入样本序列长度、H(Head Size)表示hidden层的大小、T表示所有Batch输入样本序列长度的累加和。
    FLOAT16、BFLOAT16 ND BS合轴:[T,H]
    BS非合轴:[B,S,H]
    ×
    wkv(const aclTensor*) 输入 公式中的WKV,表示kv压缩权重。 不支持空Tensor。 FLOAT16、BFLOAT16 ND [coff* D,H] ×
    wgate(const aclTensor*) 输入 公式中的WGate,表示gate压缩权重。 不支持空Tensor。 FLOAT16、BFLOAT16 ND [coff* D,H] ×
    stateCacheRef(aclTensor*) 输入/输出 公式中的[kv_state, score_state],表示kv_state和score_state的历史数据。计算后 kv_state 和 score_state 会原位更新到此 Tensor 不支持空Tensor。 FLOAT ND [block_num,block_size,2* coff* D],要求block_num>0;cacheMode=2时,需满足block_size >= coff* cmp_ratio + S - 1。 支持0轴非连续
    ape(const aclTensor*) 输入 公式中的Ape,表示positional biases。 不支持空Tensor。 FLOAT ND [cmp_ratio,coff* D] ×
    stateBlockTableOptional(const aclTensor*) 可选输入 表示state_cache存储使用的block映射表。
    • cacheMode=1时,shape为[B, ceil(Smax/block_size)],Smax为每个Batch中最大的Sequence Length。当x的shape为[B,S,H]时,Smax=max(start_pos)+S;当x的shape为[T,H]时,Smax=max(start_pos)+max(cuSeqlensOptional[n+1] - cuSeqlensOptional[n])。
    • cacheMode=2时,shape为[B]。
    INT32 ND cacheMode=1时:[B, ceil(Smax/block_size)]
    cacheMode=2时:[B]
    ×
    cuSeqlensOptional(const aclTensor*) 可选输入 表示不同Batch中的有效token数。该参数中每个元素的值表示当前batch与之前所有batch的token数总和,即前缀和,因此后一个元素的值必须大于等于前一个元素的值,且第一位必须为0。
    • 支持B=0、S=0、T=0的空Tensor。
    • 当x的shape为[B,S,H]时,该参数必须传入空指针。
    INT32 ND 当x的shape为[T,H]时,输入shape为[B+1,] ×
    sequsedOptional(const aclTensor*) 可选输入 表示不同Batch中实际参与压缩的token数。传入空指针时,表示与每个Batch上的Sequence Length长度相同。
    • 支持B=0的空Tensor。
    • 当x的shape为[B,S,H]时,要求0 ≤ sequsedOptional[n] ≤ S。
    • 当x的shape为[T,H]时,要求0 ≤ sequsedOptional[n] ≤ cuSeqlensOptional[n+1] - cuSeqlensOptional[n]。
    INT32 ND [B,] ×
    startPosOptional(const aclTensor*) 可选输入 表示计算起始位置。
    • 支持B=0、T=0的空Tensor。
    • 传入空指针时,表示从0开始进行计算。
    INT32 ND [B,] ×
    cmpRatio(int64_t) 输入 用于稀疏计算,表示数据压缩率。 取值范围为[2, 128]内的整数。 INT64 - - -
    coff(int64_t) 输入 表示是否进行overlap数据重排。 取值范围为{1, 2}。coff=1时,无需进行overlap数据重排;coff=2时,需要进行overlap数据重排。 INT64 - - -
    cacheMode(int64_t) 输入 表示state_cache的存储模式。 取值范围为{1, 2}。1表示连续buffer,2表示循环buffer。 INT64 - - -
    stateCacheStrideDim0(int64_t) 输入 表示state_cache的0轴stride。 由框架根据state_cache的实际stride传入。 INT64 - - -
    gradEnabled(bool) 输入 表示是否导出softmax_score/kv中间结果。 取值范围为true/false,默认false。当值为true时,算子输出softmax_score与kv中间结果(供反向传播使用);值为false时softmax_score与kv输出内容无效。 BOOL - - -
    cmpKvOut(aclTensor*) 输出 表示压缩后的数据,对应公式中的CiComp。
    • 支持B=0、S=0、T=0的空Tensor。
    • BS合轴场景下输出shape为[min(T, T/cmp_ratio+B), D]。
    • BS非合轴场景下输出shape为[B, ceil(S/cmp_ratio), D]。
    FLOAT16、BFLOAT16 ND BS合轴:[min(T, T/cmp_ratio+B), D]
    BS非合轴:[B, ceil(S/cmp_ratio), D]
    ×
    softmaxScoreOut(aclTensor*) 输出 公式中的S′,表示分组softmax结果。 仅在gradEnabled为true时输出有效;支持B=0、S=0、T=0的空Tensor。 FLOAT ND BS合轴:[min(T, T/cmp_ratio+B), coff*cmp_ratio, D]
    BS非合轴:[B, ceil(S/cmp_ratio), coff*cmp_ratio, D]
    ×
    kvOut(aclTensor*) 输出 压缩块原始KV中间结果,对应公式中的kv_state。 仅在gradEnabled为true时输出有效;支持B=0、S=0、T=0的空Tensor。 FLOAT ND 同softmaxScoreOut ×
    workspaceSize(uint64_t*) 输出 返回需要在Device侧申请的workspace大小。 - - - - -
    executor(aclOpExecutor**) 输出 返回op执行器,包含了算子计算流程。 - - - - -
    • D(Head Dim)表示hidden层的最小单元大小,D取值由wkv的第一维大小除以coff得到。
    • Atlas A3系列产品、Atlas A2系列产品 :
      • cmpRatio仅支持2/4/8/16/32/64/128。
  • 返回值

    aclnnStatus:返回状态码,具体参见aclnn返回码。

    第一段接口完成入参校验,出现以下场景时报错:

    返回值 错误码 描述
    ACLNN_ERR_PARAM_NULLPTR 161001 x、wkv、wgate、stateCacheRef、ape、cmpKvOut等必选参数中存在空指针。
    ACLNN_ERR_PARAM_INVALID 161002 x、wkv、wgate、stateCacheRef、ape、cmpKvOut的数据类型不在支持的范围之内。
    x、wkv、wgate、stateCacheRef、ape的shape维度不在支持的范围之内。
    cuSeqlensOptional、sequsedOptional、startPosOptional与x的shape组合不满足约束。
    ACLNN_ERR_INNER_TILING_ERROR 561002 tiling发生异常,入参的dtype类型或者shape错误,或cmpRatio、coff、cacheMode的取值不在支持的范围之内。
    ACLNN_ERR_RUNTIME_ERROR 361001 API内部调用NPU Runtime接口时发生异常(如Runtime服务未启动、内存申请失败等)。

aclnnCompressor

  • 参数说明

    参数名 输入/输出 描述
    workspace 输入 在Device侧申请的workspace内存地址。
    workspaceSize 输入 在Device侧申请的workspace大小,由第一段接口aclnnCompressorGetWorkspaceSize获取。
    executor 输入 op执行器,包含了算子计算流程。
    stream 输入 指定执行任务的Stream。
  • 返回值

    aclnnStatus:返回状态码,具体参见aclnn返回码。

约束说明

  • 确定性计算:
    • aclnnCompressor默认确定性实现。
    • Ascend 950PR&950DT系列产品:batch一致性:通过aclrtSetSysParamOpt()配置ACL_OPT_DETERMINISTIC为3来开启batch一致性,开启后可以满足计算结果和所在批次大小、位置无关。
  • Atlas A3系列产品、Atlas A2系列产品:batch一致性:通过aclrtSetSysParamOpt()配置ACL_OPT_DETERMINISTIC为3来开启batch一致性,开启后可以满足计算结果和所在批次大小、位置无关。
  • x参数维度含义:B(Batch Size)表示输入样本批量大小、S(Sequence Length)表示输入样本序列长度、H(Head Size)表示hidden层的大小、D(Head Dim)表示hidden层的最小单元大小、T表示所有Batch输入样本序列长度的累加和。
  • 输入shape限制:
    • stateCacheRef支持输入shape为[block_num, block_size, 2*coff*D],要求block_num>0;cacheMode=2时,需满足block_size >= coff * cmp_ratio + S - 1。
    • 当x采用BS合轴,即x的输入shape为[T,H]时:
      • cuSeqlensOptional输入shape必须为[B+1,],且该参数为前缀和数组,后一个元素的值必须大于等于前一个元素的值,第一位必须为0,最后一位必须为T。
      • sequsedOptional支持输入shape为[B,],要求0 ≤ sequsedOptional[n] ≤ cuSeqlensOptional[n+1] - cuSeqlensOptional[n]。
      • cacheMode=1时,stateBlockTableOptional支持输入shape为[B, ceil(Smax/block_size)],Smax=max(start_pos)+max(cuSeqlensOptional[n+1] - cuSeqlensOptional[n]);cacheMode=2时,支持输入shape为[B]。
      • cmpKvOut输出shape为[min(T, T/cmp_ratio+B), D]。
    • 当x不采用BS合轴,即x的输入shape为[B,S,H]时:
      • cuSeqlensOptional必须传入空指针。
      • sequsedOptional支持输入shape为[B,],要求0 ≤ sequsedOptional[n] ≤ S。
      • cacheMode=1时,stateBlockTableOptional支持输入shape为[B, ceil(Smax/block_size)],Smax=max(start_pos)+S;cacheMode=2时,支持输入shape为[B]。
      • cmpKvOut输出shape为[B, ceil(S/cmp_ratio), D]。
  • 输入值域限制:
    • 该接口支持B、S泛化,且存在如下场景限制:
      • 部分长序列场景下,如果计算量过大可能会导致出现超过NPU内存的报错,注:这里计算量会受x输入shape的影响,值越大计算量越大。典型的长序列(即B、S的乘积或T较大)场景包括但不限于:

        B S H
        100655254096
        252611204096
        1001310724096
        1002611204096
    • 该接口支持B、S、T取0,即shape与B、S、T值相关的入参允许传入空tensor,其余入参不支持传入空tensor。该场景下stateCacheRef不做更新,输出cmpKvOut为空tensor。
    • stateBlockTableOptional元素取值范围为[0, block_num),block_num为stateCacheRef第0维大小。元素值直接用作state_cache的block索引,越界会导致内存非法访问。元素值为0时:cacheMode=1(连续buffer)下写state_cache操作跳过该位置;cacheMode=2(循环buffer)下读写操作均不跳过。算子不做重复校验,需由调用方保证元素值唯一性:cacheMode=1下元素值0为"未分配"哨兵值可重复出现,非0值须全局唯一;cacheMode=2下0为有效物理块号,所有元素值须全局唯一。重复会导致多个逻辑块/batch写同一物理块区域,造成state_cache数据踩踏覆盖。
  • 输入属性限制:
    • 支持D为128/512。
    • 支持H为1K~10K,512对齐。
    • 支持blockSize为1~1024。
    • 支持如下三种典型组合场景:
      • C4A:D=512,coff=2,cmp_ratio=4。
      • C4Li:D=128,coff=2,cmp_ratio=4。
      • C128A:D=512,coff=1,cmp_ratio=128。

调用示例

示例代码如下,仅供参考,具体编译和执行过程请参考编译与运行样例。

/**
 * Copyright (c) 2026 Huawei Technologies Co., Ltd.
 * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
 * CANN Open Software License Agreement Version 2.0 (the "License").
 * Please refer to the License for details. You may not use this file except in compliance with the License.
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
 * See LICENSE in the root of the software repository for the full text of the License.
 */

/*!
 * \file test_aclnn_compressor.cpp
 * \brief Compressor 算子 aclnn 调用示例(A5 / ascend950)
 *        场景:C4A(D=512, coff=2, cmp_ratio=4, cache_mode=1, BSH layout, BF16)
 *        A5 版本,B=1,S=4 时 tokenSize=4 <= 256,会触发 FULL_LOAD 高性能模板。
 */

#include <algorithm>
#include <cmath>
#include <cstdint>
#include <iostream>
#include <numeric>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_compressor.h"
#include "opdev/bfloat16.h"

#define CHECK_RET(cond, return_expr) \
    do { \
        if (!(cond)) { \
            return_expr; \
        } \
    } while (0)

#define LOG_PRINT(message, ...) \
    do { \
        printf(message, ##__VA_ARGS__); \
    } while (0)

namespace {

using op::bfloat16;

int64_t GetShapeSize(const std::vector<int64_t> &shape)
{
    int64_t shapeSize = 1;
    for (auto i : shape) {
        shapeSize *= i;
    }
    return shapeSize;
}

int Init(int32_t deviceId, aclrtContext *context, aclrtStream *stream)
{
    auto ret = aclInit(nullptr);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret);
    ret = aclrtSetDevice(deviceId);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); return ret);
    ret = aclrtCreateContext(context, deviceId);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret);
    ret = aclrtSetCurrentContext(*context);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext failed. ERROR: %d\n", ret); return ret);
    ret = aclrtCreateStream(stream);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret);
    return 0;
}

template <typename T>
int CreateAclTensor(const std::vector<T> &hostData, const std::vector<int64_t> &shape, void **deviceAddr,
                    aclDataType dataType, aclTensor **tensor)
{
    auto size = GetShapeSize(shape) * sizeof(T);
    if (size > 0) {
        auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST);
        CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret);
        ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE);
        CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret);
    } else {
        *deviceAddr = nullptr;
    }

    std::vector<int64_t> strides(shape.size(), 1);
    for (int64_t i = static_cast<int64_t>(shape.size()) - 2; i >= 0; i--) {
        strides[i] = shape[i + 1] * strides[i + 1];
    }

    *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND,
                              shape.data(), shape.size(), *deviceAddr);
    return 0;
}

void PrintBf16Result(const std::vector<int64_t> &shape, void **deviceAddr)
{
    auto size = GetShapeSize(shape);
    std::vector<bfloat16> resultData(size, bfloat16(0.0f));
    auto ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), *deviceAddr,
                           size * sizeof(resultData[0]), ACL_MEMCPY_DEVICE_TO_HOST);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return);
    for (int64_t i = 0; i < size && i < 10; i++) { // 10: max print
        LOG_PRINT("cmp_kv[%ld] is: %f\n", i, static_cast<float>(resultData[i]));
    }
}

} // namespace

int main()
{
    // 1. device/stream 初始化
    int32_t deviceId = 0;
    aclrtContext context = nullptr;
    aclrtStream stream = nullptr;
    auto ret = Init(deviceId, &context, &stream);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

    // 场景参数: C4A (D=512, coff=2, cmp_ratio=4, cache_mode=1, BSH layout, BF16)
    int64_t B = 1;
    int64_t S = 4;
    int64_t hiddenSize = 4096;
    int64_t headDim = 512;
    int64_t coff = 2;
    int64_t cmpRatio = 4;
    int64_t cacheMode = 1; // 1: 连续buffer (LINEAR_BUFFER)
    int64_t blockSize = 128;

    int64_t Smax = S;
    int64_t maxBlockNumPerBatch = (Smax + blockSize - 1) / blockSize;
    int64_t blockNum = B * maxBlockNumPerBatch;
    int64_t coffD = coff * headDim;
    int64_t stateCacheStrideDim0 = blockSize * 2 * coffD; // state_cache 0轴 stride = dim1 * dim2

    // 2. 构造输入与输出 shape
    std::vector<int64_t> xShape = {B, S, hiddenSize};
    std::vector<int64_t> wkvShape = {coffD, hiddenSize};
    std::vector<int64_t> wgateShape = {coffD, hiddenSize};
    std::vector<int64_t> stateCacheShape = {blockNum, blockSize, 2 * coffD};
    std::vector<int64_t> apeShape = {cmpRatio, coffD};
    std::vector<int64_t> stateBlockTableShape = {B, maxBlockNumPerBatch};
    std::vector<int64_t> startPosShape = {B};
    int64_t Sr = (S + cmpRatio - 1) / cmpRatio;
    std::vector<int64_t> cmpKvShape = {B, Sr, headDim};
    std::vector<int64_t> softmaxScoreShape = {B, Sr, coff * cmpRatio, headDim};
    std::vector<int64_t> kvShape = {B, Sr, coff * cmpRatio, headDim};

    // 3. 构造 host 数据
    int64_t xSize = GetShapeSize(xShape);
    int64_t wkvSize = GetShapeSize(wkvShape);
    int64_t wgateSize = GetShapeSize(wgateShape);
    int64_t stateCacheSize = GetShapeSize(stateCacheShape);
    int64_t apeSize = GetShapeSize(apeShape);
    int64_t cmpKvSize = GetShapeSize(cmpKvShape);

    std::vector<bfloat16> xHostData(xSize, bfloat16(0.1f));
    std::vector<bfloat16> wkvHostData(wkvSize, bfloat16(0.1f));
    std::vector<bfloat16> wgateHostData(wgateSize, bfloat16(0.1f));
    std::vector<float_t> stateCacheHostData(stateCacheSize, 0.1f);
    std::vector<float_t> apeHostData(apeSize, 0.1f);
    std::vector<int32_t> stateBlockTableHostData;
    for (int64_t i = 0; i < B * maxBlockNumPerBatch; i++) {
        stateBlockTableHostData.push_back(static_cast<int32_t>(i + 1));
    }
    std::vector<int32_t> startPosHostData(B, 0);
    std::vector<bfloat16> cmpKvHostData(cmpKvSize, bfloat16(0.0f));
    int64_t softmaxScoreSize = GetShapeSize(softmaxScoreShape);
    int64_t kvSize = GetShapeSize(kvShape);
    std::vector<float_t> softmaxScoreHostData(softmaxScoreSize, 0.0f);
    std::vector<float_t> kvHostData(kvSize, 0.0f);

    // 4. 创建 aclTensor
    void *xDeviceAddr = nullptr;
    void *wkvDeviceAddr = nullptr;
    void *wgateDeviceAddr = nullptr;
    void *stateCacheDeviceAddr = nullptr;
    void *apeDeviceAddr = nullptr;
    void *stateBlockTableDeviceAddr = nullptr;
    void *startPosDeviceAddr = nullptr;
    void *cmpKvDeviceAddr = nullptr;
    void *softmaxScoreDeviceAddr = nullptr;
    void *kvDeviceAddr = nullptr;

    aclTensor *x = nullptr;
    aclTensor *wkv = nullptr;
    aclTensor *wgate = nullptr;
    aclTensor *stateCacheRef = nullptr;
    aclTensor *ape = nullptr;
    aclTensor *stateBlockTable = nullptr;
    aclTensor *startPos = nullptr;
    aclTensor *cmpKvOut = nullptr;
    aclTensor *softmaxScoreOut = nullptr;
    aclTensor *kvOut = nullptr;

    ret = CreateAclTensor(xHostData, xShape, &xDeviceAddr, aclDataType::ACL_BF16, &x);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    ret = CreateAclTensor(wkvHostData, wkvShape, &wkvDeviceAddr, aclDataType::ACL_BF16, &wkv);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    ret = CreateAclTensor(wgateHostData, wgateShape, &wgateDeviceAddr, aclDataType::ACL_BF16, &wgate);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    ret = CreateAclTensor(stateCacheHostData, stateCacheShape, &stateCacheDeviceAddr, aclDataType::ACL_FLOAT,
                          &stateCacheRef);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    ret = CreateAclTensor(apeHostData, apeShape, &apeDeviceAddr, aclDataType::ACL_FLOAT, &ape);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    ret = CreateAclTensor(stateBlockTableHostData, stateBlockTableShape, &stateBlockTableDeviceAddr,
                          aclDataType::ACL_INT32, &stateBlockTable);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    ret = CreateAclTensor(startPosHostData, startPosShape, &startPosDeviceAddr, aclDataType::ACL_INT32, &startPos);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    ret = CreateAclTensor(cmpKvHostData, cmpKvShape, &cmpKvDeviceAddr, aclDataType::ACL_BF16, &cmpKvOut);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    ret = CreateAclTensor(softmaxScoreHostData, softmaxScoreShape, &softmaxScoreDeviceAddr, aclDataType::ACL_FLOAT,
                          &softmaxScoreOut);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    ret = CreateAclTensor(kvHostData, kvShape, &kvDeviceAddr, aclDataType::ACL_FLOAT, &kvOut);
    CHECK_RET(ret == ACL_SUCCESS, return ret);

    // 5. 调用 aclnnCompressorGetWorkspaceSize
    uint64_t workspaceSize = 0;
    aclOpExecutor *executor = nullptr;

    bool gradEnabled = false;

    ret = aclnnCompressorGetWorkspaceSize(x, wkv, wgate, stateCacheRef, ape, stateBlockTable, nullptr, nullptr,
                                          startPos, cmpRatio, coff, cacheMode, stateCacheStrideDim0, gradEnabled,
                                          cmpKvOut, softmaxScoreOut, kvOut, &workspaceSize, &executor);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnCompressorGetWorkspaceSize failed. ERROR: %d\n", ret);
              return ret);

    // 6. 申请 workspace
    void *workspaceAddr = nullptr;
    if (workspaceSize > 0) {
        ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
        CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret);
    }

    // 7. 调用 aclnnCompressor
    ret = aclnnCompressor(workspaceAddr, workspaceSize, executor, stream);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnCompressor failed. ERROR: %d\n", ret); return ret);

    // 8. 同步等待
    ret = aclrtSynchronizeStream(stream);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);

    // 9. 获取输出
    LOG_PRINT("Compressor execution succeeded.\n");
    PrintBf16Result(cmpKvShape, &cmpKvDeviceAddr);

    // 10. 释放资源
    aclDestroyTensor(x);
    aclDestroyTensor(wkv);
    aclDestroyTensor(wgate);
    aclDestroyTensor(stateCacheRef);
    aclDestroyTensor(ape);
    aclDestroyTensor(stateBlockTable);
    aclDestroyTensor(startPos);
    aclDestroyTensor(cmpKvOut);
    aclDestroyTensor(softmaxScoreOut);
    aclDestroyTensor(kvOut);

    aclrtFree(xDeviceAddr);
    aclrtFree(wkvDeviceAddr);
    aclrtFree(wgateDeviceAddr);
    aclrtFree(stateCacheDeviceAddr);
    aclrtFree(apeDeviceAddr);
    aclrtFree(stateBlockTableDeviceAddr);
    aclrtFree(startPosDeviceAddr);
    aclrtFree(cmpKvDeviceAddr);
    aclrtFree(softmaxScoreDeviceAddr);
    aclrtFree(kvDeviceAddr);
    if (workspaceSize > 0) {
        aclrtFree(workspaceAddr);
    }
    aclrtDestroyStream(stream);
    aclrtDestroyContext(context);
    aclrtResetDevice(deviceId);
    aclFinalize();

    return 0;
}