现象

aclnnCumsum 在 fp32 [1024,8]、dim=0、默认确定性配置下，同一输入连续 5 次执行得到 5 个不同输出哈希；设置 ACL_OPT_DETERMINISTIC=1 后，5 次得到同一个哈希。资料要求默认确定性实现。

期望

资料 math/cumsum/docs/aclnnCumsum.md 的约束说明原文：「确定性计算：aclnnCumsum默认确定性实现」。因此默认配置下同一输入重复执行应输出逐字节一致；不应出现 5 次 5 种位模式。

环境

• 硬件：Atlas A2 910B2，8 卡，npu-smi 26.1.1
• CANN：9.2.0，Linux aarch64，g++ 11.4.0
• 仓库与提交：cann/ops-math 584b2ea6（git fetch 后 master）
• 复现日期：2026-10-23

复现步骤

1. 保存下方脚本为 repro.cpp
2. 保存编译命令为 build.sh 并执行 bash build.sh
3. 执行 ./repro
4. 观察 CONTROL 对照组 det=0 输出 5 个不同哈希、DEFECT 缺陷组 det=1 输出 5 个相同哈希

复现脚本

// 对照/缺陷两组：默认 vs ACL_OPT_DETERMINISTIC=1，同一输入连续 5 次输出哈希
// g++ -std=c++17 -O2 repro.cpp -o repro -I$ASCEND_HOME_PATH/include -I$ASCEND_HOME_PATH/include/aclnnop -L$ASCEND_HOME_PATH/lib64 -lascendcl -lopapi -lnnopbase
#include <acl/acl.h>
#include <aclnnop/aclnn_cumsum.h>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <vector>

#define CK(x) do { if ((int)(x) != 0) { std::printf("ERR %d\n", (int)(x)); std::exit(1); } } while (0)

static uint64_t hash_bytes(const void* p, size_t n) {
    const unsigned char* b = (const unsigned char*)p;
    uint64_t h = 1469598103934665603ULL;
    for (size_t i = 0; i < n; ++i) { h ^= b[i]; h *= 1099511628211ULL; }
    return h;
}

static void run_group(int det) {
    aclrtContext ctx; CK(aclrtCreateContext(&ctx, 0)); CK(aclrtSetCurrentContext(ctx));
    CK(aclrtCtxSetSysParamOpt(ACL_OPT_DETERMINISTIC, det));
    aclrtStream s; CK(aclrtCreateStream(&s));
    const int64_t sh[2] = {1024, 8}, st[2] = {8, 1};
    const size_t n = 1024 * 8, bytes = n * sizeof(float);
    std::vector<float> in(n), out(n), zero(n, 0.0f);
    for (size_t i = 0; i < n; ++i) in[i] = (float)(((int)(i * 37 + 11) % 200) - 100) / 10.0f;
    void *di = nullptr, *do_ = nullptr;
    CK(aclrtMalloc(&di, bytes, ACL_MEM_MALLOC_HUGE_FIRST));
    CK(aclrtMalloc(&do_, bytes, ACL_MEM_MALLOC_HUGE_FIRST));
    CK(aclrtMemcpy(di, bytes, in.data(), bytes, ACL_MEMCPY_HOST_TO_DEVICE));
    aclTensor* x = aclCreateTensor(sh, 2, ACL_FLOAT, st, 0, ACL_FORMAT_ND, sh, 2, di);
    aclTensor* y = aclCreateTensor(sh, 2, ACL_FLOAT, st, 0, ACL_FORMAT_ND, sh, 2, do_);
    for (int r = 0; r < 5; ++r) {
        CK(aclrtMemcpy(do_, bytes, zero.data(), bytes, ACL_MEMCPY_HOST_TO_DEVICE));
        uint64_t ws = 0; aclOpExecutor* e = nullptr;
        CK(aclnnCumsumGetWorkspaceSize(x, 0, ACL_FLOAT, y, &ws, &e));
        void* w = nullptr;
        if (ws) CK(aclrtMalloc(&w, ws, ACL_MEM_MALLOC_HUGE_FIRST));
        CK(aclnnCumsum(w, ws, e, s));
        CK(aclrtSynchronizeStream(s));
        CK(aclrtMemcpy(out.data(), bytes, do_, bytes, ACL_MEMCPY_DEVICE_TO_HOST));
        std::printf("det=%d run=%d digest=%016llx\n", det, r,
                    (unsigned long long)hash_bytes(out.data(), bytes));
        if (w) aclrtFree(w);
    }
    aclDestroyTensor(x); aclDestroyTensor(y);
    aclrtFree(di); aclrtFree(do_);
    aclrtDestroyStream(s); aclrtDestroyContext(ctx);
}

int main() {
    CK(aclInit(nullptr)); CK(aclrtSetDevice(0));
    std::printf("CONTROL 对照组 det=0\n"); run_group(0);
    std::printf("DEFECT 缺陷组 det=1\n"); run_group(1);
    aclrtResetDevice(0); aclFinalize();
    return 0;
}

实测输出：

CONTROL 对照组 det=0
det=0 run=0 digest=b336efea06128bd3
det=0 run=1 digest=539fed0d20d4ad1f
det=0 run=2 digest=e8a3a5340e8d09a8
det=0 run=3 digest=3ed6d0f33c3ac9d9
det=0 run=4 digest=7ef8785201337c74
DEFECT 缺陷组 det=1
det=1 run=0 digest=375ece58ea1dfdaa
det=1 run=1 digest=375ece58ea1dfdaa
det=1 run=2 digest=375ece58ea1dfdaa
det=1 run=3 digest=375ece58ea1dfdaa
det=1 run=4 digest=375ece58ea1dfdaa

影响

默认配置下，依赖 bitwise 复现的训练断点续训、结果对比、缓存复用会拿到不稳定输出；开启 ACL_OPT_DETERMINISTIC=1 可规避，但会产生性能代价。

建议

在 math/cumsum 的默认实现中固定归约/累加顺序并消除非确定性原子累加；或修改资料，把“默认确定性实现”改为“需显式开启 ACL_OPT_DETERMINISTIC”。