Closed
[Documentation|文档反馈]: [aclnnLeftShift] 约束说明的位宽基准写作 self 数据类型,混 dtype 时实现按互推导后的类型判定(int8+int16/s=8 实测 -14336 而非 0) #4358
liuhanwen8Add on  18 days agoClosed at  1 day ago
liuhanwen8
liuhanwen8
18 days ago Create

现象

aclnnLeftShift 资料「约束说明」把越界判据的位宽基准写成 self 数据类型,但实现是先按互推导规则把 self/shiftBits 都 Cast 到推导类型再算,判据落在 推导后的类型 上。两者在混 dtype 且 shiftBits 落在「self 位宽 ~ 推导类型位宽」区间时给出不同结论。

实测(Ascend 910B3 / CANN 9.2.0,两段接口均返回 0,sync 返回 0):

self shiftBits out s 实测输出 按资料应为
int8(值 200,补码 -56) int16 int16 8 -14336(= -56 << 8) 0
int8(值 200,补码 -56) int16 int16 7 -7168 -7168(对照组,两基准重合)

s=8 已经 不小于 self 的位宽 8,按资料应输出 0;实测按 16 位(推导类型 int16)计算,输出 -14336。

注:本机发布件(CANN 9.2.0)对同 dtype 的越界移位另有缺陷(不返回 0,仓内 master 已修),因此本条对照只取 s 落在合法区间的用例,避免与该缺陷混淆;本条的观测点(s=8 相对 int8 越界、相对 int16 未越界)与该缺陷无关,master 上的行为同样如此(aclnn_left_shift.cpp:264-276 先 Cast 到 promoteType)。

期望

资料 math/left_shift/docs/aclnnLeftShift.md:224,226 原文逐字:

  • - 只能保证shiftBits的数值小于self数据类型位宽时,精度无误差。
  • - 当shiftBits为负数或不小于self数据类型的位宽时,输出为0。

参数表又允许两输入「满足数据类型推导规则」(混 dtype 合法)。两句合起来,读者会认为混 dtype 时仍以 self 的位宽为界,与实测不符。

按资料这句话,混 dtype 且 s ∈ [bw(self), bw(推导类型)) 时应输出 0;实测输出真实移位结果。

环境

  • 硬件:Atlas A2(Ascend 910B3),npu-smi 26.1.1;CANN 9.2.0,Linux aarch64,g++ 10.3.1
  • 仓库与提交:cann/ops-math ff51993c(master)
  • 实现锚点:math/left_shift/op_api/aclnn_left_shift.cpp:264-276(先 Cast 到 promoteType);math/left_shift/op_kernel_aicpu/left_shift_aicpu.cpp:44-56(kBitWidth = sizeof(T)*CHAR_BIT,T 为推导后类型)
  • 复现日期:2026-10-31

复现步骤

  1. 保存下方脚本为 repro_mixed.cpp
  2. source /usr/local/Ascend/ascend-toolkit/set_env.sh
  3. g++ -O2 -std=c++17 repro_mixed.cpp -o repro_mixed -I$ASCEND_HOME_PATH/include -L$ASCEND_HOME_PATH/lib64 -lascendcl -lopapi -lnnopbase
  4. ./repro_mixed,第 1 行 out[0]=-14336(资料预期 0),第 2 行 out[0]=-7168(对照,两基准一致)

复现脚本

#include <cstdio>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_left_shift.h"

static aclTensor* Mk(aclDataType dt, long long v, void** dev){
    int es=(dt==ACL_INT8)?1:(dt==ACL_INT16)?2:4; int64_t n=8;
    std::vector<unsigned char> b(n*es,0);
    for(int i=0;i<n;++i) for(int k=0;k<es;++k) b[i*es+k]=(unsigned char)((v>>(8*k))&0xFF);
    aclrtMalloc(dev,b.size(),ACL_MEM_MALLOC_HUGE_FIRST);
    aclrtMemcpy(*dev,b.size(),b.data(),b.size(),ACL_MEMCPY_HOST_TO_DEVICE);
    std::vector<int64_t> sh{n}, st{1};
    return aclCreateTensor(sh.data(),1,dt,st.data(),0,ACL_FORMAT_ND,sh.data(),1,*dev);
}

static void Run(const char* tag, aclDataType a, aclDataType b, aclDataType o, long long s, int es_out){
    aclrtStream st=nullptr; aclrtCreateStream(&st);
    void *pa=nullptr,*pb=nullptr,*po=nullptr;
    aclTensor* ta=Mk(a,-56,&pa);   // self 值 200(int8 补码 -56)
    aclTensor* tb=Mk(b,s,&pb);
    aclTensor* to=Mk(o,0,&po);
    uint64_t ws=0; aclOpExecutor* ex=nullptr;
    int r1=aclnnLeftShiftGetWorkspaceSize(ta,tb,to,&ws,&ex);
    void* wsp=nullptr; if(ws>0) aclrtMalloc(&wsp,ws,ACL_MEM_MALLOC_HUGE_FIRST);
    int r2=(r1==0)?aclnnLeftShift(wsp,ws,ex,st):-1;
    int rs=(r2==0)?aclrtSynchronizeStream(st):-1;
    long long got=0;
    if(rs==0){ unsigned char buf[8]={0}; aclrtMemcpy(buf,es_out,po,es_out,ACL_MEMCPY_DEVICE_TO_HOST);
               for(int k=es_out-1;k>=0;--k) got=(got<<8)|buf[k];
               if(es_out==2 && (got&0x8000)) got-=0x10000; }
    printf("%-28s ret1=%d ret2=%d sync=%d out[0]=%lld\n",tag,r1,r2,rs,got);
    aclDestroyTensor(ta); aclDestroyTensor(tb); aclDestroyTensor(to);
    if(wsp) aclrtFree(wsp);
    aclrtFree(pa); aclrtFree(pb); aclrtFree(po); aclrtDestroyStream(st);
}

int main(){
    aclInit(nullptr); aclrtSetDevice(0);
    Run("int8+int16 s=8 (defect)",  ACL_INT8,  ACL_INT16, ACL_INT16, 8, 2);
    Run("int8+int16 s=7 (control)", ACL_INT8,  ACL_INT16, ACL_INT16, 7, 2);
    aclrtResetDevice(0); aclFinalize(); return 0;
}

影响

  • 混 dtype 使用本接口时,按资料预期「越界即 0」的输入会拿到真实移位结果(本例 -14336 vs 0),静默偏差,不做对照很难发现。
  • 两种基准只在 self 与 shiftBits dtype 不同、且 s ∈ [bw(self), bw(推导类型)) 时可区分;同 dtype 时两基准重合,本条不可观测。
  • 同批实测另发现 16 位整型 rank≥6 广播会触发 507018(已单独提单),与本条无关。

建议

二选一:

  1. 资料按实现补限定,例如「当 self 与 shiftBits 数据类型不同时,位宽基准为二者推导后的数据类型位宽」;
  2. 实现改按 self 的位宽判越界。

参考实现口径:torch.bitwise_left_shift(int8, int16) 也是先提升到 int16 再移位(-56 << 8 = -14336),与当前实现一致,因此改资料更符合既有语义,且改动只涉及文档,无兼容风险。

likedislike
liuhanwen8liuhanwen8
18 days ago Added label: documentation
liuhanwen8
liuhanwen8
18 days ago Comments:

补充一份同根因、不同入口的证据,供维护者合并参考(本条不另起 issue)。

标量版 aclnnLeftShifts 上同样出现「位宽基准按 promote 类型」,且多一个触发维度:out dtype 宽于 self

资料 math/left_shift/docs/aclnnLeftShifts.md:

  • 参数表 out 数据类型列了 8 类整型(INT8…UINT64),「使用说明」只要求 shape 与 self 一致,未要求 dtype 相同;
  • 约束说明同样是「当 shiftBits 为负数或不小于 self 数据类型的位宽时,输出为 0」。

实测(Atlas A2 / 910B2,CANN 9.2.0 与仓内 master 行为一致):

self shiftBits out 实测 按资料应为
int8 [1,2,3,127] int64 标量 8(= self 位宽 8) int8 [0,0,0,0] 0(符合)
int8 [1,2,3,127] int64 标量 8 int16 [256,512,768,32512] 0
int8 [1,2,3,127] int64 标量 8 int32 [256,512,768,32512] 0
int8 [1,2,3,127] int64 标量 8 int64 [256,512,768,32512] 0

机制与本条一致:PromoteType(int8, int64) = int64 → 左移在 64 位域完成、判界位宽成 64 →
x << 8 保留;写回 int8 时截断刚好为 0(所以 out==self 时「看起来对」),写回更宽的
out 时原样保留,127 << 8 = 32512。

复现脚本(自包含,g++ 一条命令):

// g++ -O2 -o repro repro.cpp -I$ASCEND_HOME_PATH/include -L$ASCEND_HOME_PATH/lib64 -lascendcl -lopapi -lnnopbase && ./repro
#include <cstdio>
#include <vector>
#include <cstdint>
#include "acl/acl.h"
#include "aclnnop/aclnn_left_shift.h"

static aclTensor* MakeT(aclDataType dt, const std::vector<int64_t>& shape, int elemBytes,
                        const std::vector<int64_t>& vals, void** dev)
{
    int64_t n = 1; for (auto d : shape) n *= d;
    size_t bytes = static_cast<size_t>(n) * elemBytes;
    if (aclrtMalloc(dev, bytes, ACL_MEM_MALLOC_HUGE_FIRST) != ACL_SUCCESS) return nullptr;
    std::vector<unsigned char> host(bytes, 0);
    for (int64_t i = 0; i < n && i < (int64_t)vals.size(); ++i)
        for (int b = 0; b < elemBytes; ++b)
            host[i * elemBytes + b] = (unsigned char)(((uint64_t)vals[i] >> (8 * b)) & 0xFF);
    aclrtMemcpy(*dev, bytes, host.data(), bytes, ACL_MEMCPY_HOST_TO_DEVICE);
    std::vector<int64_t> strides(shape.size(), 1);
    for (int i = (int)shape.size() - 2; i >= 0; --i) strides[i] = shape[i + 1] * strides[i + 1];
    return aclCreateTensor(shape.data(), shape.size(), dt, strides.data(), 0, ACL_FORMAT_ND,
                           shape.data(), shape.size(), *dev);
}

static void Run(aclDataType outDt, int outBytes, const char* tag)
{
    std::vector<int64_t> shape{4}, on{0, 0, 0, 0}, sv{1, 2, 3, 127};
    void* sDev = nullptr; void* oDev = nullptr;
    aclTensor* self = MakeT(ACL_INT8, shape, 1, sv, &sDev);
    aclTensor* out = MakeT(outDt, shape, outBytes, on, &oDev);
    int64_t shift = 8;
    aclScalar* sc = aclCreateScalar(&shift, ACL_INT64);       // Python int 的默认类型
    uint64_t ws = 0; aclOpExecutor* ex = nullptr; aclrtStream st = nullptr;
    aclrtCreateStream(&st);
    if (aclnnLeftShiftsGetWorkspaceSize(self, sc, out, &ws, &ex) == ACL_SUCCESS) {
        void* wsa = nullptr;
        if (ws) aclrtMalloc(&wsa, ws, ACL_MEM_MALLOC_HUGE_FIRST);
        aclnnLeftShifts(wsa, ws, ex, st);
        aclrtSynchronizeStream(st);
        unsigned char h[4 * 8] = {0};
        aclrtMemcpy(h, sizeof(h), oDev, 4 * outBytes, ACL_MEMCPY_DEVICE_TO_HOST);
        printf("%-12s out=[", tag);
        for (int i = 0; i < 4; ++i) {
            int64_t v = 0;
            for (int b = outBytes - 1; b >= 0; --b) v = (v << 8) | h[i * outBytes + b];
            printf("%lld%s", (long long)v, i == 3 ? "" : ", ");
        }
        printf("]\n");
        if (wsa) aclrtFree(wsa);
    }
    aclrtDestroyStream(st); if (ex) aclDestroyAclOpExecutor(ex);
    aclDestroyScalar(sc); aclDestroyTensor(self); aclDestroyTensor(out);
    aclrtFree(sDev); aclrtFree(oDev);
}

int main()
{
    aclInit(nullptr); aclrtSetDevice(0);
    printf("self=int8{1,2,3,127}, shiftBits=int64 8 (>= self 位宽 8),资料要求全 0\n");
    Run(ACL_INT8, 1, "out=int8");
    Run(ACL_INT16, 2, "out=int16");
    Run(ACL_INT32, 4, "out=int32");
    Run(ACL_INT64, 8, "out=int64");
    aclrtResetDevice(0); aclFinalize();
    return 0;
}

实测输出:

self=int8{1,2,3,127}, shiftBits=int64 8 (>= self 位宽 8),资料要求全 0
out=int8     out=[0, 0, 0, 0]
out=int16    out=[256, 512, 768, 32512]
out=int32    out=[256, 512, 768, 32512]
out=int64    out=[256, 512, 768, 32512]

另一处相关(已单独提 #4372)

同一资料错误码表 161002 第 2 子项(dtype 不支持推导)在 self 为空 tensor 时被跳过:
aclnn_left_shift.cpp:196-201 的 IsEmpty() 早退排在 PromoteType/CheckPromoteTypeScalar
(:203-206)之前,非空返回 161002、空返回 0。见 #4372(机制是校验次序,与本条的位宽基准不同)。

likedislike
陈思
陈思Collaborators
18 days ago Comments:

您好,感谢反馈,也收到标量入口的补充。核对 cann/ops-math 提交 212ce9d5460b1be26cfbee481aff1acbf5cc5c62 后,确认这两份约束说明需要明确位宽基准:当前实现先将 self 与 shiftBits 转换到二者推导出的计算类型,再执行左移,最后转换成 out 类型;A2 所走的 AI CPU 实现以计算类型 T 的 sizeof(T) × CHAR_BIT 判断移位范围。张量入口、标量入口、位宽判断

因此,张量版 INT8 的 -56 与 INT16 的移位量共同提升到 INT16 后,移位量 8 仍小于计算位宽 16,得到 -14336,与您报告的结果一致。标量版 INT8 输入配 INT64 标量 8 时,则在 INT64 域计算,[1,2,3,127] 的中间结果为 [256,512,768,32512];写回 INT8 后这些值的低 8 位恰为 0,写回 INT16/INT32/INT64 则保留这些值。这里 out 影响最终转换结果,计算位宽由输入类型推导决定。

可行的修订方向是将两份文档中的“self 数据类型位宽”统一明确为“self 与 shiftBits 按类型推导规则得到的计算类型位宽”,并补充“结果随后转换为 out 类型,窄类型输出可能发生截断”,配上上述张量和标量示例。这样可以保持现有计算顺序,并说明为什么同一输入搭配不同输出类型会得到不同结果。我们会继续跟踪这处文档对齐。张量版约束、标量版约束

likedislike
陈思陈思Collaborators
18 days ago Assign chen_0715 as responsible person
陈思陈思Collaborators
18 days ago Added label: pending-confirmation
陈思陈思Collaborators
16 days ago Removed label: pending-confirmation
CchenyifengCollaborators
15 days ago Assign sakuraqqz as responsible person
CchenyifengCollaborators
15 days ago Removed responsible person chen_0715
CANN-robotCANN-robotCollaborators
1 day ago Close issue
CANN-robotCANN-robotCollaborators
1 day ago changed custom state from 进行中 to 已完成
CANN-robotCANN-robotCollaborators
1 day ago Added label: resolved