#include <algorithm>
#include <vector>
#include <string>
#include <cstring>
#include <iostream>
#include <unistd.h>
#include <sys/wait.h>
#include "acl/acl.h"
#include "aclnn/aclnn_base.h"
#include "acl/acl_base.h"
#include "acl/acl_rt.h"
#include "sec_common.h"
#include "utils.h"
#include "../fuzzlib/secodeFuzz.h"
#include "aclnnop/aclnn_advance_step.h"
using namespace std;



/* ========== [CONSISTENT] 一致性压测辅助函数（gen_consistent_from_normal 生成） ========== */
static const int CONSISTENT_MAX_RUN_TIMES = 64; /* hash数组上限，防越界 */
static int CONSISTENT_RUN_TIMES = 2; /* 每用例执行次数：默认2次，对比2次输出是否一致；经环境变量 CONSISTENT_RUN_TIMES 覆盖 */

static const char* ConsistentDtypeStr(aclDataType t) {
    switch (t) {
        case ACL_FLOAT: return "FLOAT"; case ACL_FLOAT16: return "FLOAT16";
        case ACL_BF16: return "BFLOAT16"; case ACL_DOUBLE: return "DOUBLE";
        case ACL_INT8: return "INT8"; case ACL_INT16: return "INT16";
        case ACL_INT32: return "INT32"; case ACL_INT64: return "INT64";
        case ACL_UINT8: return "UINT8"; case ACL_UINT16: return "UINT16";
        case ACL_UINT32: return "UINT32"; case ACL_UINT64: return "UINT64";
        case ACL_BOOL: return "BOOL"; case ACL_COMPLEX64: return "COMPLEX64";
        case ACL_COMPLEX128: return "COMPLEX128";
        default: return "UNKNOWN";
    }
}

static const char* ConsistentFormatStr(aclFormat f) {
    switch (f) {
        case ACL_FORMAT_NCHW: return "NCHW"; case ACL_FORMAT_NHWC: return "NHWC";
        case ACL_FORMAT_ND: return "ND"; case ACL_FORMAT_NC1HWC0: return "NC1HWC0";
        case ACL_FORMAT_FRACTAL_Z: return "FRACTAL_Z"; case ACL_FORMAT_HWCN: return "HWCN";
        case ACL_FORMAT_NDHWC: return "NDHWC"; case ACL_FORMAT_FRACTAL_NZ: return "FRACTAL_NZ";
        case ACL_FORMAT_NCDHW: return "NCDHW"; case ACL_FORMAT_NC: return "NC";
        case ACL_FORMAT_NCL: return "NCL";
        default: return "OTHER";
    }
}

static size_t ConsistentSizeOfDtype(aclDataType dataType) {
    switch (dataType) {
        case ACL_FLOAT: return 4; case ACL_FLOAT16: return 2;
        case ACL_INT8: return 1; case ACL_INT32: return 4;
        case ACL_UINT8: return 1; case ACL_INT16: return 2;
        case ACL_UINT16: return 2; case ACL_UINT32: return 4;
        case ACL_INT64: return 8; case ACL_UINT64: return 8;
        case ACL_DOUBLE: return 8; case ACL_BOOL: return 1;
        case ACL_BF16: return 2; case ACL_COMPLEX64: return 8;
        case ACL_COMPLEX128: return 16;
        /* 以下 dtype 的 sizeof(T)=1（vector<int8_t>），必须显式列出，禁止落入 default:4 */
        case ACL_INT4: return 1;
        case ACL_HIFLOAT8: return 1;
        case ACL_FLOAT8_E5M2: return 1;
        case ACL_FLOAT8_E4M3FN: return 1;
        case ACL_FLOAT8_E8M0: return 1;
        case ACL_FLOAT4_E2M1: return 1;
        case ACL_FLOAT4_E1M2: return 1;
        default: return 0; /* 未知 dtype 返回 0，触发 [FUZZ_CONSISTENT_BYTES] 告警 */
    }
}

static void ConsistentPrintShape(const std::vector<int64_t>& shape) {
    printf("[");
    for (size_t k = 0; k < shape.size(); k++) {
        printf("%lld%s", (long long)shape[k], (k + 1 < shape.size()) ? "," : "");
    }
    printf("]");
}

static uint64_t ConsistentHashBuffer(const void* data, size_t len) {
    const uint8_t* p = (const uint8_t*)data;
    uint64_t hash = 1469598103934665603ULL; /* FNV-1a offset basis */
    for (size_t k = 0; k < len; k++) {
        hash ^= (uint64_t)p[k];
        hash *= 1099511628211ULL; /* FNV-1a prime */
    }
    return hash;
}

static uint64_t ConsistentHashDeviceTensor(void* deviceAddr, size_t bytes) {
    if (deviceAddr == nullptr || bytes == 0) return 0;
    void* hostBuf = malloc(bytes);
    if (hostBuf == nullptr) return 0;
    if (aclrtMemcpy(hostBuf, bytes, deviceAddr, bytes, ACL_MEMCPY_DEVICE_TO_HOST) != ACL_SUCCESS) {
        free(hostBuf);
        return 0;
    }
    uint64_t h = ConsistentHashBuffer(hostBuf, bytes);
    free(hostBuf);
    return h;
}

/* ========== [CONSISTENT_RAND] 输入数据随机泛化（M11，禁止全0/全1等常量输入） ========== */
/* 设计要求：
   - 同一条用例内数值完全确定（种子 = fuzzi*1000003 + tensor 名 FNV hash），
     配合快照/恢复保证 N 轮重复执行输入完全一致，不影响一致性判定
   - 不同用例间随机泛化（fuzzi 派生不同种子），提升确定性缺陷检出能力
   - dtype 感知：浮点随机后安全转回目标类型（避开 NaN/Inf/精度截断），整型非负防溢出 */
static uint64_t ConsistentRandSeed(int caseId, const char* tensorName) {
    uint64_t h = 1469598103934665603ULL;
    h ^= (uint64_t)(unsigned int)caseId + 0x9e3779b97f4a7c15ULL;
    h *= 1099511628211ULL;
    for (const char* p = tensorName; p != nullptr && *p != '\0'; p++) {
        h ^= (uint64_t)(unsigned char)*p;
        h *= 1099511628211ULL;
    }
    /* xorshift64* 打散，保证低bit质量 */
    h ^= h >> 12; h ^= h << 25; h ^= h >> 27;
    return h * 2685821657736338717ULL;
}

static inline uint64_t ConsistentRandNext(uint64_t& state) {
    state ^= state >> 12; state ^= state << 25; state ^= state >> 27;
    return state * 2685821657736338717ULL;
}

/* [1,100] 均匀整型（非负，降低 int16/int8 累加溢出风险） */
static inline uint32_t ConsistentRandRange(uint64_t& state, uint32_t lo, uint32_t hi) {
    if (hi <= lo) return lo;
    return lo + (uint32_t)(ConsistentRandNext(state) % (uint64_t)(hi - lo + 1));
}

/* float -> fp16 位模式（round-to-nearest；NaN/Inf/上溢防护为最大有限值，下溢为0） */
static inline uint16_t ConsistentF32ToF16Bits(float f) {
    uint32_t x; memcpy(&x, &f, sizeof(x));
    uint32_t sign = (x >> 16) & 0x8000U;
    uint32_t exp32 = (x >> 23) & 0xFFU;
    uint32_t man32 = x & 0x7FFFFFU;
    if (exp32 == 0xFFU) return (uint16_t)(sign | 0x7BFFU);
    int32_t e = (int32_t)exp32 - 127 + 15;
    if (e >= 31) return (uint16_t)(sign | 0x7BFFU);
    if (e <= 0) return (uint16_t)sign;
    uint32_t bits = ((uint32_t)e << 10) | (man32 >> 13);
    uint32_t rem = man32 & 0x1FFFU;
    if (rem > 0x1000U || (rem == 0x1000U && (bits & 1U))) bits += 1U;
    if (bits >= 0x7C00U) bits = 0x7BFFU;
    return (uint16_t)(sign | bits);
}

/* float -> bf16 位模式（取高16位；NaN 防护为最大有限值） */
static inline uint16_t ConsistentF32ToBf16Bits(float f) {
    uint32_t x; memcpy(&x, &f, sizeof(x));
    uint16_t bits = (uint16_t)(x >> 16);
    if ((bits & 0x7F80U) == 0x7F80U && (bits & 0x007FU) != 0U) {
        bits = (uint16_t)((bits & 0xFF80U) | 0x007FU);
    }
    return bits;
}

/* 按实际 aclDataType 随机填充 host 缓冲（字节数与模板 T 的 sizeof 一致）
   浮点：随机值∈[-2,2]，FLOAT16/BF16 经位模式转换生成正常数（避开 NaN/Inf/次正规）；
   整型：[1,100] 非负；INT4：[1,7]；FLOAT8：[8,119] 安全位模式（避开 NaN/Inf/负零）；
   E8M0：偶数位模式（尾数位必须为0）；FLOAT4：[1,5] 有限值；BOOL：{0,1} */
template <typename T>
static void ConsistentRandFillT(std::vector<T>& buf, aclDataType dataType, int caseId, const char* tensorName) {
    if (buf.empty()) return;
    uint64_t st = ConsistentRandSeed(caseId, tensorName);
    for (size_t k = 0; k < buf.size(); k++) {
        uint64_t r = ConsistentRandNext(st);
        int64_t rv = (int64_t)(r % 40001) - 20000; /* [-20000,20000] -> 缩放后 [-2,2] */
        double dv = (double)rv / 10000.0;
        T v;
        switch (dataType) {
            case ACL_FLOAT16:
            case ACL_BF16: {
                double d = (dv < -2.0) ? -2.0 : (dv > 2.0) ? 2.0 : dv;
                uint16_t bits = (dataType == ACL_FLOAT16) ? ConsistentF32ToF16Bits((float)d)
                                                          : ConsistentF32ToBf16Bits((float)d);
                if (sizeof(T) == sizeof(uint16_t)) {
                    memcpy(&v, &bits, sizeof(uint16_t)); /* int16_t/uint16_t 存储位模式 */
                } else {
                    v = static_cast<T>((int64_t)bits);
                }
                break;
            }
            case ACL_FLOAT:
            case ACL_DOUBLE:
            case ACL_COMPLEX64:
            case ACL_COMPLEX128: {
                double d = (dv < -2.0) ? -2.0 : (dv > 2.0) ? 2.0 : dv;
                v = static_cast<T>(d);
                break;
            }
            case ACL_BOOL: {
                v = static_cast<T>((int64_t)(ConsistentRandNext(st) & 1ULL));
                break;
            }
            case ACL_INT4: {
                v = static_cast<T>((int64_t)ConsistentRandRange(st, 1, 7));
                break;
            }
            case ACL_FLOAT4_E2M1:
            case ACL_FLOAT4_E1M2: {
                v = static_cast<T>((int64_t)ConsistentRandRange(st, 1, 5)); /* 4bit 有限值，避开 0x6/0x7(Inf/NaN) */
                break;
            }
            case ACL_FLOAT8_E8M0: {
                v = static_cast<T>((int64_t)(2 * ConsistentRandRange(st, 4, 59))); /* 偶数位模式 */
                break;
            }
            case ACL_HIFLOAT8:
            case ACL_FLOAT8_E5M2:
            case ACL_FLOAT8_E4M3FN: {
                v = static_cast<T>((int64_t)ConsistentRandRange(st, 8, 119)); /* 安全位模式 */
                break;
            }
            default: {
                /* INT8..INT64/UINT 系列：非负 [1,100]，满足 non_negative 类约束且防溢出 */
                v = static_cast<T>((int64_t)ConsistentRandRange(st, 1, 100));
                break;
            }
        }
        buf[k] = v;
    }
    printf("[FUZZ_CONSISTENT_RAND] case_%d: tensor=%s, dtype=%s, elems=%zu, v0=%lld\n",
           caseId, tensorName, ConsistentDtypeStr(dataType), buf.size(), (long long)buf[0]);
}
/* ========== [CONSISTENT_RAND] 辅助函数结束 ========== */
/* ========== [CONSISTENT] 辅助函数结束 ========== */

static std::string ShapeToStr(const std::vector<int64_t>& s) {
    std::string r = "[";
    for (size_t k = 0; k < s.size(); k++) { if (k) r += ","; r += std::to_string(s[k]); }
    return r + "]";
}

int aclnnAdvanceStep_consistent(int fuzz_num)
{
    auto ret = Init(deviceId, &context, &stream);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);
    // [CONSISTENT] md文档标注默认确定性实现，无需打开确定性计算开关
    printf("[FUZZ_DETERMINISTIC] api=aclnnAdvanceStep, enable_deterministic=0, reason=md文档标注：aclnnAdvanceStep默认确定性实现。\n");
    WriteDTLog("aclnnAdvanceStep", "aclnnAdvanceStep consistent op fuzz start \n");
    const long long kTotalElemsMax = 1048576LL;

    aclrtSetOpExecuteTimeOut(1091);
    DT_Set_TimeOut_Second(3000);
    DT_FUZZ_START(0, fuzz_num, "aclnnAdvanceStep", 0)
    {
        int i = 0;
        int aclnnRet = -1;
        void* itAddr = nullptr; aclTensor* inputTokens = nullptr;
        void* stAddr = nullptr; aclTensor* sampledTokenIds = nullptr;
        void* ipAddr = nullptr; aclTensor* inputPositions = nullptr;
        void* slAddr = nullptr; aclTensor* seqLens = nullptr;
        void* smAddr = nullptr; aclTensor* slotMapping = nullptr;
        void* btAddr = nullptr; aclTensor* blockTables = nullptr;
        uint64_t workspaceSize = 0;
        aclOpExecutor* executor = nullptr;
        void* workspaceAddr = nullptr;

        // [CONSISTENT] 一致性压测：固定输入重复执行 + hash 对比用变量
        char curTilingKey[64];
        snprintf(curTilingKey, sizeof(curTilingKey), "N/A");
        int cstRunCount = 0;
        bool cstAllOk = true;
        size_t cstInputTokensBytes = 0;
        void* cstInputTokensSaveBuf = nullptr;
        uint64_t cstInputTokensHashArr[CONSISTENT_MAX_RUN_TIMES];
        memset(cstInputTokensHashArr, 0, sizeof(cstInputTokensHashArr));
        size_t cstSampledTokenIdsBytes = 0;
        void* cstSampledTokenIdsSaveBuf = nullptr;
        uint64_t cstSampledTokenIdsHashArr[CONSISTENT_MAX_RUN_TIMES];
        memset(cstSampledTokenIdsHashArr, 0, sizeof(cstSampledTokenIdsHashArr));
        size_t cstInputPositionsBytes = 0;
        void* cstInputPositionsSaveBuf = nullptr;
        uint64_t cstInputPositionsHashArr[CONSISTENT_MAX_RUN_TIMES];
        memset(cstInputPositionsHashArr, 0, sizeof(cstInputPositionsHashArr));
        size_t cstSeqLensBytes = 0;
        void* cstSeqLensSaveBuf = nullptr;
        uint64_t cstSeqLensHashArr[CONSISTENT_MAX_RUN_TIMES];
        memset(cstSeqLensHashArr, 0, sizeof(cstSeqLensHashArr));
        size_t cstSlotMappingBytes = 0;
        void* cstSlotMappingSaveBuf = nullptr;
        uint64_t cstSlotMappingHashArr[CONSISTENT_MAX_RUN_TIMES];
        memset(cstSlotMappingHashArr, 0, sizeof(cstSlotMappingHashArr));
        size_t cstBlockTablesBytes = 0;
        void* cstBlockTablesSaveBuf = nullptr;
        uint64_t cstBlockTablesHashArr[CONSISTENT_MAX_RUN_TIMES];
        memset(cstBlockTablesHashArr, 0, sizeof(cstBlockTablesHashArr));

        printf("[FUZZ_LOG] plog_file: aclnnAdvanceStep_consistent_plog_case_%d\n", fuzzi);
        LOG_PRINT("aclnnAdvanceStep_consistent %d\n", fuzzi);
        printf("[FUZZ_LOG] plog_file: aclnnAdvanceStep_fuzz_plog_case_%d.log\n", fuzzi);
        aclnnRet = -1;
        try
        {
            // size distribution: 0=small 1=mid 2=large 3=xlarge
            int sizeBucket = *(int *)DTSetGetNumberRange(&g_Element[i++], 1, 0, 3, "i");
            int numSeqs = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 2, 64, "i");       // numSeqs ∈ [2,64]
            int numQueries = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, 63, "i");    // numQueries < numSeqs
            int blockSize = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, 16, "i");
            int seqLenMax = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, 64, "i");
            // size bucket 调整规模
            const int seqTargets[4] = {8, 64, 256, 1024};
            if (numSeqs > seqTargets[sizeBucket]) { numSeqs = seqTargets[sizeBucket]; }
            if (numQueries >= numSeqs) { numQueries = numSeqs - 1; }
            if (numQueries < 1) { numQueries = 1; }
            if (blockSize < 1) { blockSize = 1; }
            if (seqLenMax < 1) { seqLenMax = 1; }
            int64_t v_numSeqs = (int64_t)numSeqs;
            int64_t v_numQueries = (int64_t)numQueries;
            int64_t v_blockSize = (int64_t)blockSize;

            // shapes
            std::vector<int64_t> seqShape = {v_numSeqs};
            std::vector<int64_t> sampledShape = {v_numQueries, 1};
            int64_t maxSeqLen = (int64_t)seqLenMax;
            int64_t maxBlocks = maxSeqLen / v_blockSize + 1;  // 第二维 > max(seqLens)/blockSize
            std::vector<int64_t> btShape = {v_numSeqs, maxBlocks};

            long long totalElems = GetShapeSize(seqShape) * 4 + GetShapeSize(sampledShape) + GetShapeSize(btShape);
            if (totalElems > kTotalElemsMax) { printf("shape_size too big\n"); goto ERROR; }

            // create tensors（数据敏感：全部正整数）
            {
                std::vector<int64_t> itH((size_t)numSeqs); /* [CONSISTENT_RAND_SKIP] itH: 逐元素自定义构造（数据敏感），保持原构造 */
                std::vector<int64_t> ipH((size_t)numSeqs); /* [CONSISTENT_RAND_SKIP] ipH: 逐元素自定义构造（数据敏感），保持原构造 */
                std::vector<int64_t> slH((size_t)numSeqs); /* [CONSISTENT_RAND_SKIP] slH: 逐元素自定义构造（数据敏感），保持原构造 */
                std::vector<int64_t> smH((size_t)numSeqs); /* [CONSISTENT_RAND_SKIP] smH: 逐元素自定义构造（数据敏感），保持原构造 */
                for (int k = 0; k < numSeqs; k++) {
                    itH[k] = (int64_t)k + 1;
                    ipH[k] = (int64_t)k + 1;
                    slH[k] = (int64_t)((k % seqLenMax) + 1);  // 正整数, ≤ seqLenMax
                    smH[k] = (int64_t)k + 1;
                }
                std::vector<int64_t> stH((size_t)numQueries); /* [CONSISTENT_RAND_SKIP] stH: 逐元素自定义构造（数据敏感），保持原构造 */
                for (int k = 0; k < numQueries; k++) { stH[k] = (int64_t)k + 1; }
                std::vector<int64_t> btH((size_t)(numSeqs * maxBlocks)); /* [CONSISTENT_RAND_SKIP] btH: 逐元素自定义构造（数据敏感），保持原构造 */
                for (int64_t k = 0; k < (int64_t)(numSeqs * maxBlocks); k++) { btH[k] = k + 1; }
                ret = CreateAclTensor_New(itH, seqShape, &itAddr, ACL_INT64, aclFormat::ACL_FORMAT_ND, &inputTokens);
                CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
                ret = CreateAclTensor_New(stH, sampledShape, &stAddr, ACL_INT64, aclFormat::ACL_FORMAT_ND, &sampledTokenIds);
                CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
                ret = CreateAclTensor_New(ipH, seqShape, &ipAddr, ACL_INT64, aclFormat::ACL_FORMAT_ND, &inputPositions);
                CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
                ret = CreateAclTensor_New(slH, seqShape, &slAddr, ACL_INT64, aclFormat::ACL_FORMAT_ND, &seqLens);
                CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
                ret = CreateAclTensor_New(smH, seqShape, &smAddr, ACL_INT64, aclFormat::ACL_FORMAT_ND, &slotMapping);
                CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
                ret = CreateAclTensor_New(btH, btShape, &btAddr, ACL_INT64, aclFormat::ACL_FORMAT_ND, &blockTables);
                CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
            }
                        // ===== [CONSISTENT] 保存全部 tensor 设备侧初始内容（固定输入，含输入tensor的值） =====
            cstInputTokensBytes = (itAddr != nullptr) ? (size_t)GetShapeSize(seqShape) * (size_t)ConsistentSizeOfDtype(ACL_INT64) : 0;
            printf("[FUZZ_CONSISTENT_BYTES] case_%d: tensor=inputTokens, dtype=%d(%s), shapeSize=%llu, cstBytes=%zu, ConsistentSizeOfDtype=%zu\n", fuzzi, (int)ACL_INT64, ConsistentDtypeStr(ACL_INT64), (unsigned long long)GetShapeSize(seqShape), cstInputTokensBytes, ConsistentSizeOfDtype(ACL_INT64));
            if (cstInputTokensBytes == 0 && itAddr != nullptr) {
                printf("[FUZZ_CONSISTENT_BYTES] case_%d: WARN tensor=inputTokens addr!=nullptr but cstBytes=0, dtype may be uncovered by ConsistentSizeOfDtype\n", fuzzi);
            }
            cstInputTokensSaveBuf = (cstInputTokensBytes > 0) ? malloc(cstInputTokensBytes) : nullptr;
            if (cstInputTokensSaveBuf != nullptr && itAddr != nullptr) {
                aclrtMemcpy(cstInputTokensSaveBuf, cstInputTokensBytes, itAddr, cstInputTokensBytes, ACL_MEMCPY_DEVICE_TO_HOST);
            }
            cstSampledTokenIdsBytes = (stAddr != nullptr) ? (size_t)GetShapeSize(sampledShape) * (size_t)ConsistentSizeOfDtype(ACL_INT64) : 0;
            printf("[FUZZ_CONSISTENT_BYTES] case_%d: tensor=sampledTokenIds, dtype=%d(%s), shapeSize=%llu, cstBytes=%zu, ConsistentSizeOfDtype=%zu\n", fuzzi, (int)ACL_INT64, ConsistentDtypeStr(ACL_INT64), (unsigned long long)GetShapeSize(sampledShape), cstSampledTokenIdsBytes, ConsistentSizeOfDtype(ACL_INT64));
            if (cstSampledTokenIdsBytes == 0 && stAddr != nullptr) {
                printf("[FUZZ_CONSISTENT_BYTES] case_%d: WARN tensor=sampledTokenIds addr!=nullptr but cstBytes=0, dtype may be uncovered by ConsistentSizeOfDtype\n", fuzzi);
            }
            cstSampledTokenIdsSaveBuf = (cstSampledTokenIdsBytes > 0) ? malloc(cstSampledTokenIdsBytes) : nullptr;
            if (cstSampledTokenIdsSaveBuf != nullptr && stAddr != nullptr) {
                aclrtMemcpy(cstSampledTokenIdsSaveBuf, cstSampledTokenIdsBytes, stAddr, cstSampledTokenIdsBytes, ACL_MEMCPY_DEVICE_TO_HOST);
            }
            cstInputPositionsBytes = (ipAddr != nullptr) ? (size_t)GetShapeSize(seqShape) * (size_t)ConsistentSizeOfDtype(ACL_INT64) : 0;
            printf("[FUZZ_CONSISTENT_BYTES] case_%d: tensor=inputPositions, dtype=%d(%s), shapeSize=%llu, cstBytes=%zu, ConsistentSizeOfDtype=%zu\n", fuzzi, (int)ACL_INT64, ConsistentDtypeStr(ACL_INT64), (unsigned long long)GetShapeSize(seqShape), cstInputPositionsBytes, ConsistentSizeOfDtype(ACL_INT64));
            if (cstInputPositionsBytes == 0 && ipAddr != nullptr) {
                printf("[FUZZ_CONSISTENT_BYTES] case_%d: WARN tensor=inputPositions addr!=nullptr but cstBytes=0, dtype may be uncovered by ConsistentSizeOfDtype\n", fuzzi);
            }
            cstInputPositionsSaveBuf = (cstInputPositionsBytes > 0) ? malloc(cstInputPositionsBytes) : nullptr;
            if (cstInputPositionsSaveBuf != nullptr && ipAddr != nullptr) {
                aclrtMemcpy(cstInputPositionsSaveBuf, cstInputPositionsBytes, ipAddr, cstInputPositionsBytes, ACL_MEMCPY_DEVICE_TO_HOST);
            }
            cstSeqLensBytes = (slAddr != nullptr) ? (size_t)GetShapeSize(seqShape) * (size_t)ConsistentSizeOfDtype(ACL_INT64) : 0;
            printf("[FUZZ_CONSISTENT_BYTES] case_%d: tensor=seqLens, dtype=%d(%s), shapeSize=%llu, cstBytes=%zu, ConsistentSizeOfDtype=%zu\n", fuzzi, (int)ACL_INT64, ConsistentDtypeStr(ACL_INT64), (unsigned long long)GetShapeSize(seqShape), cstSeqLensBytes, ConsistentSizeOfDtype(ACL_INT64));
            if (cstSeqLensBytes == 0 && slAddr != nullptr) {
                printf("[FUZZ_CONSISTENT_BYTES] case_%d: WARN tensor=seqLens addr!=nullptr but cstBytes=0, dtype may be uncovered by ConsistentSizeOfDtype\n", fuzzi);
            }
            cstSeqLensSaveBuf = (cstSeqLensBytes > 0) ? malloc(cstSeqLensBytes) : nullptr;
            if (cstSeqLensSaveBuf != nullptr && slAddr != nullptr) {
                aclrtMemcpy(cstSeqLensSaveBuf, cstSeqLensBytes, slAddr, cstSeqLensBytes, ACL_MEMCPY_DEVICE_TO_HOST);
            }
            cstSlotMappingBytes = (smAddr != nullptr) ? (size_t)GetShapeSize(seqShape) * (size_t)ConsistentSizeOfDtype(ACL_INT64) : 0;
            printf("[FUZZ_CONSISTENT_BYTES] case_%d: tensor=slotMapping, dtype=%d(%s), shapeSize=%llu, cstBytes=%zu, ConsistentSizeOfDtype=%zu\n", fuzzi, (int)ACL_INT64, ConsistentDtypeStr(ACL_INT64), (unsigned long long)GetShapeSize(seqShape), cstSlotMappingBytes, ConsistentSizeOfDtype(ACL_INT64));
            if (cstSlotMappingBytes == 0 && smAddr != nullptr) {
                printf("[FUZZ_CONSISTENT_BYTES] case_%d: WARN tensor=slotMapping addr!=nullptr but cstBytes=0, dtype may be uncovered by ConsistentSizeOfDtype\n", fuzzi);
            }
            cstSlotMappingSaveBuf = (cstSlotMappingBytes > 0) ? malloc(cstSlotMappingBytes) : nullptr;
            if (cstSlotMappingSaveBuf != nullptr && smAddr != nullptr) {
                aclrtMemcpy(cstSlotMappingSaveBuf, cstSlotMappingBytes, smAddr, cstSlotMappingBytes, ACL_MEMCPY_DEVICE_TO_HOST);
            }
            cstBlockTablesBytes = (btAddr != nullptr) ? (size_t)GetShapeSize(btShape) * (size_t)ConsistentSizeOfDtype(ACL_INT64) : 0;
            printf("[FUZZ_CONSISTENT_BYTES] case_%d: tensor=blockTables, dtype=%d(%s), shapeSize=%llu, cstBytes=%zu, ConsistentSizeOfDtype=%zu\n", fuzzi, (int)ACL_INT64, ConsistentDtypeStr(ACL_INT64), (unsigned long long)GetShapeSize(btShape), cstBlockTablesBytes, ConsistentSizeOfDtype(ACL_INT64));
            if (cstBlockTablesBytes == 0 && btAddr != nullptr) {
                printf("[FUZZ_CONSISTENT_BYTES] case_%d: WARN tensor=blockTables addr!=nullptr but cstBytes=0, dtype may be uncovered by ConsistentSizeOfDtype\n", fuzzi);
            }
            cstBlockTablesSaveBuf = (cstBlockTablesBytes > 0) ? malloc(cstBlockTablesBytes) : nullptr;
            if (cstBlockTablesSaveBuf != nullptr && btAddr != nullptr) {
                aclrtMemcpy(cstBlockTablesSaveBuf, cstBlockTablesBytes, btAddr, cstBlockTablesBytes, ACL_MEMCPY_DEVICE_TO_HOST);
            }

            // ===== [CONSISTENT] 固定输入重复执行 CONSISTENT_RUN_TIMES 次，逐轮对全部 tensor 计算 hash =====
            cstRunCount = 0;
            cstAllOk = true;
            for (int cstRun = 0; cstRun < CONSISTENT_RUN_TIMES; cstRun++) {
                // [CONSISTENT] 恢复固定输入（输出 tensor 同时恢复初始值，覆盖 inplace/累加类算子）
                if (cstInputTokensSaveBuf != nullptr && itAddr != nullptr) {
                    aclrtMemcpy(itAddr, cstInputTokensBytes, cstInputTokensSaveBuf, cstInputTokensBytes, ACL_MEMCPY_HOST_TO_DEVICE);
                }
                if (cstSampledTokenIdsSaveBuf != nullptr && stAddr != nullptr) {
                    aclrtMemcpy(stAddr, cstSampledTokenIdsBytes, cstSampledTokenIdsSaveBuf, cstSampledTokenIdsBytes, ACL_MEMCPY_HOST_TO_DEVICE);
                }
                if (cstInputPositionsSaveBuf != nullptr && ipAddr != nullptr) {
                    aclrtMemcpy(ipAddr, cstInputPositionsBytes, cstInputPositionsSaveBuf, cstInputPositionsBytes, ACL_MEMCPY_HOST_TO_DEVICE);
                }
                if (cstSeqLensSaveBuf != nullptr && slAddr != nullptr) {
                    aclrtMemcpy(slAddr, cstSeqLensBytes, cstSeqLensSaveBuf, cstSeqLensBytes, ACL_MEMCPY_HOST_TO_DEVICE);
                }
                if (cstSlotMappingSaveBuf != nullptr && smAddr != nullptr) {
                    aclrtMemcpy(smAddr, cstSlotMappingBytes, cstSlotMappingSaveBuf, cstSlotMappingBytes, ACL_MEMCPY_HOST_TO_DEVICE);
                }
                if (cstBlockTablesSaveBuf != nullptr && btAddr != nullptr) {
                    aclrtMemcpy(btAddr, cstBlockTablesBytes, cstBlockTablesSaveBuf, cstBlockTablesBytes, ACL_MEMCPY_HOST_TO_DEVICE);
                }
                ret = aclnnAdvanceStepGetWorkspaceSize(inputTokens, sampledTokenIds, inputPositions, seqLens,
                slotMapping, blockTables, v_numSeqs, v_numQueries, v_blockSize, &workspaceSize, &executor);
                if (ret != ACL_SUCCESS) {
                    printf("aclnnAdvanceStep execute failed :%d\n", (int)ret);
                    printf("[FUZZ_CONSISTENT] case_%d: faild, type=execute_error, stage=GetWorkspaceSize, run=%d/%d, ret=%d\n", fuzzi, cstRun + 1, CONSISTENT_RUN_TIMES, (int)ret);
                    cstAllOk = false;
                    break;
                }
                if (workspaceSize > 0) {
                    if (workspaceAddr != nullptr) { aclrtFree(workspaceAddr); workspaceAddr = nullptr; }
                    ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
                    if (ret != ACL_SUCCESS) {
                        printf("[FUZZ_CONSISTENT] case_%d: faild, type=execute_error, stage=workspace_malloc, run=%d/%d, ret=%d\n", fuzzi, cstRun + 1, CONSISTENT_RUN_TIMES, (int)ret);
                        cstAllOk = false;
                        break;
                    }
                }
                ret = aclnnAdvanceStep(workspaceAddr, workspaceSize, executor, stream);
                if (ret != ACL_SUCCESS) {
                    printf("aclnnAdvanceStep execute failed :%d\n", (int)ret);
                    printf("[FUZZ_CONSISTENT] case_%d: faild, type=execute_error, stage=execute, run=%d/%d, ret=%d\n", fuzzi, cstRun + 1, CONSISTENT_RUN_TIMES, (int)ret);
                    cstAllOk = false;
                    break;
                }
                ret = aclrtSynchronizeStream(stream);
                if (ret != ACL_SUCCESS) {
                    printf("[FUZZ_CONSISTENT] case_%d: faild, type=execute_error, stage=sync, run=%d/%d, ret=%d\n", fuzzi, cstRun + 1, CONSISTENT_RUN_TIMES, (int)ret);
                    cstAllOk = false;
                    break;
                }
                // [CONSISTENT] 本轮执行结果 hash
                if (itAddr != nullptr && cstInputTokensBytes > 0) {
                    cstInputTokensHashArr[cstRun] = ConsistentHashDeviceTensor(itAddr, cstInputTokensBytes);
                }
                if (stAddr != nullptr && cstSampledTokenIdsBytes > 0) {
                    cstSampledTokenIdsHashArr[cstRun] = ConsistentHashDeviceTensor(stAddr, cstSampledTokenIdsBytes);
                }
                if (ipAddr != nullptr && cstInputPositionsBytes > 0) {
                    cstInputPositionsHashArr[cstRun] = ConsistentHashDeviceTensor(ipAddr, cstInputPositionsBytes);
                }
                if (slAddr != nullptr && cstSeqLensBytes > 0) {
                    cstSeqLensHashArr[cstRun] = ConsistentHashDeviceTensor(slAddr, cstSeqLensBytes);
                }
                if (smAddr != nullptr && cstSlotMappingBytes > 0) {
                    cstSlotMappingHashArr[cstRun] = ConsistentHashDeviceTensor(smAddr, cstSlotMappingBytes);
                }
                if (btAddr != nullptr && cstBlockTablesBytes > 0) {
                    cstBlockTablesHashArr[cstRun] = ConsistentHashDeviceTensor(btAddr, cstBlockTablesBytes);
                }
                cstRunCount++;
                printf("aclnnAdvanceStep execute success :%d\n", (int)ret);
            }

            // ===== [CONSISTENT] 对比 2 轮 hash，判定一致性（2次执行输出一致即为确定性） =====
            if (cstAllOk && cstRunCount == CONSISTENT_RUN_TIMES) {
                bool cstInputTokensSame = true;
                for (int cstR = 1; cstR < CONSISTENT_RUN_TIMES; cstR++) {
                    if (cstInputTokensHashArr[cstR] != cstInputTokensHashArr[0]) { cstInputTokensSame = false; break; }
                }
                bool cstSampledTokenIdsSame = true;
                for (int cstR = 1; cstR < CONSISTENT_RUN_TIMES; cstR++) {
                    if (cstSampledTokenIdsHashArr[cstR] != cstSampledTokenIdsHashArr[0]) { cstSampledTokenIdsSame = false; break; }
                }
                bool cstInputPositionsSame = true;
                for (int cstR = 1; cstR < CONSISTENT_RUN_TIMES; cstR++) {
                    if (cstInputPositionsHashArr[cstR] != cstInputPositionsHashArr[0]) { cstInputPositionsSame = false; break; }
                }
                bool cstSeqLensSame = true;
                for (int cstR = 1; cstR < CONSISTENT_RUN_TIMES; cstR++) {
                    if (cstSeqLensHashArr[cstR] != cstSeqLensHashArr[0]) { cstSeqLensSame = false; break; }
                }
                bool cstSlotMappingSame = true;
                for (int cstR = 1; cstR < CONSISTENT_RUN_TIMES; cstR++) {
                    if (cstSlotMappingHashArr[cstR] != cstSlotMappingHashArr[0]) { cstSlotMappingSame = false; break; }
                }
                bool cstBlockTablesSame = true;
                for (int cstR = 1; cstR < CONSISTENT_RUN_TIMES; cstR++) {
                    if (cstBlockTablesHashArr[cstR] != cstBlockTablesHashArr[0]) { cstBlockTablesSame = false; break; }
                }
                bool cstAllSame = cstInputTokensSame && cstSampledTokenIdsSame && cstInputPositionsSame && cstSeqLensSame && cstSlotMappingSame && cstBlockTablesSame;
                if (cstAllSame) {
                    printf("[FUZZ_CONSISTENT] case_%d: success, type=consistent, runs=%d, hash_consistent=all\n", fuzzi, CONSISTENT_RUN_TIMES);
                    printf("[FUZZ_RESULT] case_%d: success, ret=%d\n", fuzzi, (int)ret);
                } else {
                    printf("[FUZZ_CONSISTENT] case_%d: faild, type=hash_mismatch, runs=%d, inconsistent=", fuzzi, CONSISTENT_RUN_TIMES);
                    if (!cstInputTokensSame) printf("inputTokens ");
                    if (!cstSampledTokenIdsSame) printf("sampledTokenIds ");
                    if (!cstInputPositionsSame) printf("inputPositions ");
                    if (!cstSeqLensSame) printf("seqLens ");
                    if (!cstSlotMappingSame) printf("slotMapping ");
                    if (!cstBlockTablesSame) printf("blockTables ");
                    printf("\n");
                    printf("[FUZZ_CONSISTENT_DETAIL] case_%d: inputTokens hash:", fuzzi);
                    for (int cstR = 0; cstR < CONSISTENT_RUN_TIMES; cstR++) printf(" run%d=%llu", cstR, (unsigned long long)cstInputTokensHashArr[cstR]);
                    printf("\n");
                    printf("[FUZZ_CONSISTENT_DETAIL] case_%d: sampledTokenIds hash:", fuzzi);
                    for (int cstR = 0; cstR < CONSISTENT_RUN_TIMES; cstR++) printf(" run%d=%llu", cstR, (unsigned long long)cstSampledTokenIdsHashArr[cstR]);
                    printf("\n");
                    printf("[FUZZ_CONSISTENT_DETAIL] case_%d: inputPositions hash:", fuzzi);
                    for (int cstR = 0; cstR < CONSISTENT_RUN_TIMES; cstR++) printf(" run%d=%llu", cstR, (unsigned long long)cstInputPositionsHashArr[cstR]);
                    printf("\n");
                    printf("[FUZZ_CONSISTENT_DETAIL] case_%d: seqLens hash:", fuzzi);
                    for (int cstR = 0; cstR < CONSISTENT_RUN_TIMES; cstR++) printf(" run%d=%llu", cstR, (unsigned long long)cstSeqLensHashArr[cstR]);
                    printf("\n");
                    printf("[FUZZ_CONSISTENT_DETAIL] case_%d: slotMapping hash:", fuzzi);
                    for (int cstR = 0; cstR < CONSISTENT_RUN_TIMES; cstR++) printf(" run%d=%llu", cstR, (unsigned long long)cstSlotMappingHashArr[cstR]);
                    printf("\n");
                    printf("[FUZZ_CONSISTENT_DETAIL] case_%d: blockTables hash:", fuzzi);
                    for (int cstR = 0; cstR < CONSISTENT_RUN_TIMES; cstR++) printf(" run%d=%llu", cstR, (unsigned long long)cstBlockTablesHashArr[cstR]);
                    printf("\n");
                    // [CONSISTENT] 失败时打印全部入参信息（dtype/format/shape/attr/tiling_key）
                    printf("[FUZZ_PARAM] ");
                    printf("inputTokens: dtype=%s, format=%s, shape=", ConsistentDtypeStr(ACL_INT64), ConsistentFormatStr(aclFormat::ACL_FORMAT_ND)); ConsistentPrintShape(seqShape); printf("; ");
                    printf("sampledTokenIds: dtype=%s, format=%s, shape=", ConsistentDtypeStr(ACL_INT64), ConsistentFormatStr(aclFormat::ACL_FORMAT_ND)); ConsistentPrintShape(sampledShape); printf("; ");
                    printf("inputPositions: dtype=%s, format=%s, shape=", ConsistentDtypeStr(ACL_INT64), ConsistentFormatStr(aclFormat::ACL_FORMAT_ND)); ConsistentPrintShape(seqShape); printf("; ");
                    printf("seqLens: dtype=%s, format=%s, shape=", ConsistentDtypeStr(ACL_INT64), ConsistentFormatStr(aclFormat::ACL_FORMAT_ND)); ConsistentPrintShape(seqShape); printf("; ");
                    printf("slotMapping: dtype=%s, format=%s, shape=", ConsistentDtypeStr(ACL_INT64), ConsistentFormatStr(aclFormat::ACL_FORMAT_ND)); ConsistentPrintShape(seqShape); printf("; ");
                    printf("blockTables: dtype=%s, format=%s, shape=", ConsistentDtypeStr(ACL_INT64), ConsistentFormatStr(aclFormat::ACL_FORMAT_ND)); ConsistentPrintShape(btShape); printf("; ");
                    printf("v_numSeqs=%lld; ", (long long)v_numSeqs);
                    printf("v_numQueries=%lld; ", (long long)v_numQueries);
                    printf("v_blockSize=%lld; ", (long long)v_blockSize);
                    printf("tiling_key=%s\n", curTilingKey);
                    printf("[FUZZ_RESULT] case_%d: faild, ret=%d\n", fuzzi, (int)ret);
                }
            } else if (!cstAllOk) {
                // [CONSISTENT] 执行失败也打印全部入参信息
                printf("[FUZZ_PARAM] ");
                printf("inputTokens: dtype=%s, format=%s, shape=", ConsistentDtypeStr(ACL_INT64), ConsistentFormatStr(aclFormat::ACL_FORMAT_ND)); ConsistentPrintShape(seqShape); printf("; ");
                printf("sampledTokenIds: dtype=%s, format=%s, shape=", ConsistentDtypeStr(ACL_INT64), ConsistentFormatStr(aclFormat::ACL_FORMAT_ND)); ConsistentPrintShape(sampledShape); printf("; ");
                printf("inputPositions: dtype=%s, format=%s, shape=", ConsistentDtypeStr(ACL_INT64), ConsistentFormatStr(aclFormat::ACL_FORMAT_ND)); ConsistentPrintShape(seqShape); printf("; ");
                printf("seqLens: dtype=%s, format=%s, shape=", ConsistentDtypeStr(ACL_INT64), ConsistentFormatStr(aclFormat::ACL_FORMAT_ND)); ConsistentPrintShape(seqShape); printf("; ");
                printf("slotMapping: dtype=%s, format=%s, shape=", ConsistentDtypeStr(ACL_INT64), ConsistentFormatStr(aclFormat::ACL_FORMAT_ND)); ConsistentPrintShape(seqShape); printf("; ");
                printf("blockTables: dtype=%s, format=%s, shape=", ConsistentDtypeStr(ACL_INT64), ConsistentFormatStr(aclFormat::ACL_FORMAT_ND)); ConsistentPrintShape(btShape); printf("; ");
                printf("v_numSeqs=%lld; ", (long long)v_numSeqs);
                printf("v_numQueries=%lld; ", (long long)v_numQueries);
                printf("v_blockSize=%lld; ", (long long)v_blockSize);
                printf("tiling_key=%s\n", curTilingKey);
                printf("[FUZZ_RESULT] case_%d: faild, ret=%d\n", fuzzi, (int)ret);
            }
        }
        catch (std::exception& e)
        {
            printf("catch exception %s\n", e.what());
            printf("[FUZZ_CONSISTENT] case_%d: faild, type=exception, ret=%d\n", fuzzi, (int)ret);
            printf("[FUZZ_RESULT] case_%d: faild, ret=%d\n", fuzzi, (int)ret);
        }

ERROR:
        ret = aclrtSynchronizeStream(stream);
        printf("[FUZZ_RESULT] case_%d: %s, ret=%d\n", fuzzi, (aclnnRet == 0) ? "success" : "faild", aclnnRet);
        printf("end \n");
        CheckAndLog(ret);
        pid_t pid = getpid();
        std::string cmd = "grep -rinE 'ai(vec|core) error' /root/ascend/log/debug/plog/ ";
        printf("system return value %d\n", CheckResult(pid));
        // [CONSISTENT] 释放固定输入快照
        if (cstInputTokensSaveBuf != nullptr) { free(cstInputTokensSaveBuf); cstInputTokensSaveBuf = nullptr; }
        if (cstSampledTokenIdsSaveBuf != nullptr) { free(cstSampledTokenIdsSaveBuf); cstSampledTokenIdsSaveBuf = nullptr; }
        if (cstInputPositionsSaveBuf != nullptr) { free(cstInputPositionsSaveBuf); cstInputPositionsSaveBuf = nullptr; }
        if (cstSeqLensSaveBuf != nullptr) { free(cstSeqLensSaveBuf); cstSeqLensSaveBuf = nullptr; }
        if (cstSlotMappingSaveBuf != nullptr) { free(cstSlotMappingSaveBuf); cstSlotMappingSaveBuf = nullptr; }
        if (cstBlockTablesSaveBuf != nullptr) { free(cstBlockTablesSaveBuf); cstBlockTablesSaveBuf = nullptr; }
        if (inputTokens) { aclDestroyTensor(inputTokens); }
        if (sampledTokenIds) { aclDestroyTensor(sampledTokenIds); }
        if (inputPositions) { aclDestroyTensor(inputPositions); }
        if (seqLens) { aclDestroyTensor(seqLens); }
        if (slotMapping) { aclDestroyTensor(slotMapping); }
        if (blockTables) { aclDestroyTensor(blockTables); }
        if (itAddr) { aclrtFree(itAddr); }
        if (stAddr) { aclrtFree(stAddr); }
        if (ipAddr) { aclrtFree(ipAddr); }
        if (slAddr) { aclrtFree(slAddr); }
        if (smAddr) { aclrtFree(smAddr); }
        if (btAddr) { aclrtFree(btAddr); }
        if (workspaceSize > 0 && workspaceAddr) { aclrtFree(workspaceAddr); }
    }
    DT_FUZZ_END()
    WriteDTLog("aclnnAdvanceStep", "aclnnAdvanceStep consistent op fuzz total number:%u, para error number %u, execute error number %u \n", fuzz_num, aclnn_INVALID_Para, aclnn_Inner_Error + Runtime_Error);
    WriteDTLog("aclnnAdvanceStep", "aclnnAdvanceStep consistent op fuzz end \n");
    aclrtDestroyStream(stream);
    aclrtDestroyContext(context);
    aclrtResetDevice(deviceId);
    aclFinalize();
    return 0;
}

extern "C" int aclnnAdvanceStep_consistent_fuzz(int argc, char *argv[])
{
    // [CONSISTENT] 运行时覆盖每用例执行次数（环境变量 CONSISTENT_RUN_TIMES：默认2次，可按需覆盖）
    const char* cstRunEnv = getenv("CONSISTENT_RUN_TIMES");
    if (cstRunEnv != nullptr) {
        int cstRunV = atoi(cstRunEnv);
        if (cstRunV > 0 && cstRunV <= CONSISTENT_MAX_RUN_TIMES) { CONSISTENT_RUN_TIMES = cstRunV; }
    }
    printf("[FUZZ_CONSISTENT_RUNTIMES] run_times=%d\n", CONSISTENT_RUN_TIMES);
    int fuzz_num = MAXFUZZNUMBER;
    if (argc > 1) { fuzz_num = atoi(argv[2]); }
    if (argc == 4) { deviceId = atoi(argv[3]); }
    printf("fuzz_num %d \n", fuzz_num);
    printf("aclnnAdvanceStep_consistent :%d \n", aclnnAdvanceStep_consistent(fuzz_num));
    return 0;
}