补充证据(2026-11-03,A3 910_9362 / CANN 9.2.0-beta.2)
一、p 语义的完整边界(26 个取值全谱扫描)
固定输入 x = [0.6606, 0.5879, 0.5558, 0.7391, 0.5660, 0.6953],fp32
(L1 = Σ|x| = 3.804700,L2 = √Σx² = 1.562370):
| p 取值 | 设备输出 | 落到的分支 |
|---|---|---|
1 / 1.0000001 / 1.001 / 1.1 / 1.5 / 1.9 / 1.9999999 |
3.80469799 | L1 |
0.5 / 0.9 / 0.999 / 0 |
1.56236744 | L2 |
2 / 2.0000001 / 2.5 / 3 / 4 / 10 |
1.56236744 | L2 |
-1 / -2 / -0.5 |
1.56236744 | L2 |
2147483647 / 2147483648 / 4294967296 / 1e10 |
1.56236744 | L2 |
inf / -inf / nan |
1.56236744 | L2 |
二、三条比原报告更强的论断
1. 区间语义是 trunc,不是 rint、不是近似匹配。
p = 1.9999999 仍走 L1 —— 这不是「p 接近 1 时容差匹配」,而是
static_cast<int>(1.9999999) == 1 的直接结果。
整个开区间 p ∈ [1.0, 2.0) 全部塌成 p=1。
2. 除 trunc(p)==1 之外全部落默认分支。
// foreach_norm.cpp:51
uint8_t modelCode = TWO_SCALAR_NORM_MODEL_CODE; // 默认 = L2
// foreach_norm.cpp:56
if (static_cast<int>(scalarVal) == 1) modelCode = ONE; // 唯一分支
不是「p=3 时算错」,而是「只有 p∈[1,2) 走 L1、其余一切都走 L2」。
3. p ≥ 2^31 时 static_cast<int>(float) 是 C++ UB,设备静默返回合法值。
p = 2147483648 / 4294967296 / 1e10 / inf / nan 实测:
- 无错误码(两段均返回 0)
- 无异常/日志
- 返回
1.56236744(= L2),一个看起来完全合理的值
这一点比「p=3 返回 L2」严重:后者用户对比两次不同 p 就能发现异常;
UB 区间连「该期待什么」都无法确定,日志干净、返回码 0,线上极难察觉。
三、死代码证据
// foreach_norm.cpp:30-35 —— 定义了 6 个常量
constexpr uint8_t ZERO_SCALAR_NORM_MODEL_CODE = 0; // 注释标 "not used now"
constexpr uint8_t ONE_SCALAR_NORM_MODEL_CODE = 1;
constexpr uint8_t TWO_SCALAR_NORM_MODEL_CODE = 2;
constexpr uint8_t POSITIVE_INF_SCALAR_NORM_MODEL_CODE = 3; // 注释标 "not used now"
constexpr uint8_t NEGATIVE_INF_SCALAR_NORM_MODEL_CODE = 4; // 注释标 "not used now"
constexpr uint8_t DEFAULT_SCALAR_NORM_MODEL_CODE = 5; // 注释标 "not used now"
3/4/5 三个常量在全文件中没有任何赋值点 —— 是死代码。
若资料声明支持 p=+inf / p=-inf,则属「文档声明 vs 实现」不符。
四、非缺陷侧的实测排除(供维护者参考,避免重复投入)
以下三项用真机实测排除,均不是缺陷:
| 检查项 | 方法 | 结果 |
|---|---|---|
8 元素块尾块(elementsPerBlock=8) |
1/2/7/8/9/15/16/17/23/24/25/63/64/65/127/128/129/255/256/257/511/512/513/1023/1024/1025/4095/4096/4097 共 29 个长度 | 29/29 PASS,最大相对误差 3.8e-8(fp32 ULP = 1.19e-7) |
| TensorList 长度上限 | n = 1/8/32/63/64/65/96/128/200/256/257 | 1–256 全 PASS,257 正确拒 161002 |
| 非连续输入(transposed / 混合连续非连续) | ND vs transposed 逐值比对 | 全 PASS |
其中 list 长度一项值得单独说明:foreach_reduce_tiling_def.h:36-39 的
tensorStartList/tensorEndList/tensorStartOffsetList/tensorEndOffsetList 只有 64 槽,
而长度上限是 256(foreach_reduce_tiling_func.cpp:276),
代码里没有 coreIndex < MAX_CORE_CONT 的钳位。
当前 A3 上 needCoreNum ≤ 64,所以 256 长度恰好安全。
但这是依赖隐含前提而非显式保证:若某代设备 AIV 核数 > 64 或 tiling 逻辑调整,
AssignDataToEachCore 的 coreIndex++(:190)可能越界写 tiling 结构体相邻字段。
目前无实证,仅作风险提示,不建议单独提 issue。
五、复现方式
python3 probe_norm_p_spectrum.py # p 全谱 26 值扫描
python3 probe_fs_block.py # 8 元素块尾块 29 点
python3 probe_listlen2.py # list 长度 1→256
python3 probe_nc_py.py # 非连续 ND vs transposed
python3 probe_ex_bitscale.py # EX:连跑 8 次 / 插 shape 扰乱 / 换种子
脚本与原始输出已随本轮归档提交。


初步分析
感谢反馈,我们已开始核对这个问题。
现象理解:aclnnForeachNorm 在 p 不是 1 或 2 时不报错,而是静默返回其他阶数的结果(p=3 返 L2、p=1.5 返 L1),两段接口均返回 0。
当前判断:初步判断是入参 p 缺少取值范围校验、实现按分支回落到已支持阶数,待复现确认具体回落路径,暂不能认定根因。
涉及范围:foreach/foreach_norm 的 op_host 校验与 kernel 实现,以及 aclnnForeachNorm 资料中对 p 支持范围的声明。
下一步:我们会复现 p=1.5/3 等取值,确认应当是补校验返回错误码还是补齐实现,并同步修正资料声明。


您好,该问题已收到,当前问题 @tramp-ll 正在处理中


p当前再arch22上只支持1 和 2,其他数值无法保证精度正确,已添加文档说明


1)问题描述
aclnnForeachNorm的第二个入参scalar是范数阶数p。资料(foreach/foreach_norm/docs/aclnnForeachNorm.md,A2/A3 段)给出的公式是通用形式:实测:只有 p ∈ {1, 2} 正确,其余 p 全部静默返回 p=1 或 p=2 的结果,两段返回码都是 0。
同一份输入、同一进程内连续调用:
输入
x = fp32[16x32],取值0.25 + 0.5*(i%97)/97(全正,无 inf/nan),结果只有 1 个元素。关键反证:不是硬件限制。 同一台设备、同一份输入,
torch._foreach_norm对全部 p 都正确:torch._foreach_norm(NPU)aclnnForeachNorm(同 NPU)(x =
[0.5, 2.0, 0.0, -0.5];torch.linalg.vector_norm(npu, 1.5)同样给 2.3207943。)2)环境信息
npu-smi 26.1.1)Ascend-cann-toolkit_9.2.0-beta.2_linux-aarch64)cann/ops-nn@118c0c713)重现步骤
自包含 C++ 复现(
aclInit→ 构造 → 两段调用 → 读回,不依赖任何测试框架):#include <cstdio> #include <cmath> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_foreach_norm.h" static aclTensor* mk(const std::vector<float>& d, const std::vector<int64_t>& s, void** dev) { size_t n = 1; for (auto v : s) n *= (size_t)v; size_t bytes = n * sizeof(float); if (aclrtMalloc(dev, bytes, ACL_MEM_MALLOC_HUGE_FIRST) != 0) return nullptr; if (aclrtMemcpy(*dev, bytes, d.data(), bytes, ACL_MEMCPY_HOST_TO_DEVICE) != 0) return nullptr; std::vector<int64_t> st(s.size(), 1); for (int64_t i = (int64_t)s.size() - 2; i >= 0; --i) st[i] = s[i+1] * st[i+1]; return aclCreateTensor(s.data(), s.size(), ACL_FLOAT, st.data(), 0, ACL_FORMAT_ND, s.data(), s.size(), *dev); } int main() { aclInit(nullptr); aclrtSetDevice(0); aclrtStream stream = nullptr; aclrtCreateStream(&stream); std::vector<int64_t> xs{16, 32}, os{1}; std::vector<float> xv(512), ov(1, 0.f); for (size_t i = 0; i < xv.size(); ++i) xv[i] = 0.25f + 0.5f * (float)(i % 97) / 97.f; void *xd = nullptr, *od = nullptr; aclTensor* x = mk(xv, xs, &xd); aclTensor* o = mk(ov, os, &od); aclTensor* xl[1] = {x}; aclTensor* ol[1] = {o}; aclTensorList* xL = aclCreateTensorList(xl, 1); aclTensorList* oL = aclCreateTensorList(ol, 1); const double ps[] = {1.0, 1.5, 2.0, 3.0, 0.5, INFINITY, -INFINITY, NAN}; for (double p : ps) { // 注意:double 变量必须配 ACL_DOUBLE;配 ACL_FLOAT 会因只读 4 字节而全变成 0 aclScalar* sc = aclCreateScalar(&p, ACL_DOUBLE); uint64_t ws = 0; aclOpExecutor* ex = nullptr; auto r1 = aclnnForeachNormGetWorkspaceSize(xL, sc, oL, &ws, &ex); printf("p=%-6g ret_gws=%-3d ", p, (int)r1); if (r1 == 0) { void* w = nullptr; if (ws > 0) aclrtMalloc(&w, ws, ACL_MEM_MALLOC_HUGE_FIRST); auto r2 = aclnnForeachNorm(w, ws, ex, stream); aclrtSynchronizeStream(stream); float got = 0.f; aclrtMemcpy(&got, sizeof(got), od, sizeof(got), ACL_MEMCPY_DEVICE_TO_HOST); printf("ret_exec=%-3d out[0]=%.6g", (int)r2, got); if (ws > 0) aclrtFree(w); } printf("\n"); aclDestroyScalar(sc); } aclDestroyTensorList(xL); aclDestroyTensorList(oL); aclrtFree(xd); aclrtFree(od); aclrtDestroyStream(stream); aclrtResetDevice(0); aclFinalize(); return 0; }编译:
g++ -std=c++17 probe.cpp -o probe \ -I$ASCEND_HOME_PATH/include -L$ASCEND_HOME_PATH/aarch64-linux/lib64 \ -L$ASCEND_HOME_PATH/lib64 -lopapi -lnnopbase -lacl_rt ./probe实测输出(A3):
一行 PyTorch 对照(证明非硬件限制):
import torch, torch_npu x = torch.tensor([0.5, 2.0, 0.0, -0.5], dtype=torch.float32) print('cpu p=1.5:', torch._foreach_norm([x], 1.5)[0].item()) # 2.3207943 print('npu p=1.5:', torch._foreach_norm([x.npu()], 1.5)[0].item()) # 2.3207943 同样正确4)预期结果
以下两种修复任一即可:
(Σ|x|^p)^(1/p)计算,并补齐
±inf → max/min|x|(950 资料已明写该语义);并在资料
scalar参数说明里写明「仅支持 1 与 2」。现状是第三种:既不按公式算、也不拒绝,静默返回另一个阶数的值 ——
调用方传 p=3 拿到 L2 范数、传 p=1.5 拿到 L1 范数,无从察觉。
5)仓内定位参考
foreach/foreach_norm/op_kernel/foreach_norm.cpp:24-35modelCode 2: p=1 ... 3: p=2 ... (now we only consider p=1 || p=2)foreach/foreach_norm/op_kernel/foreach_norm.cpp:55-57if (static_cast<int>(scalarVal) == 1) { modelCode = ONE...; },之后仅if/else两条分支foreach/foreach_norm/op_host/foreach_norm_def.cpp:30-31scalar仅声明.Scalar(),无任何取值校验foreach/foreach_norm/op_host/foreach_norm_infershape.cppstatic_cast<int>(1.5) == 1→ 落 p=1;其余(含 nan / ±inf / 0.5 / 负数)走else→ 落 p=2。这与实测「p=1.5 得 L1、p≥2 与 p=0.5/±inf/nan 得 L2」完全吻合。
6)影响面
任何用
aclnnForeachNorm(x, p)做 L1/L2 以外范数(L3、L0.5、L∞、L−∞)的调用方都会拿到错误结果,且无任何报错。A2、A3 两个产品均复现。
7)备注
#7710(Documentation:公式未区分张量列表与单张量内元素)不同,#7710讲表述歧义,本条讲 p 取值的语义漂移。cann/ops-nn1500 条 issue 中无同题。