现象

aclnnReplicationPad3dBackward 在 padding 含负值（裁剪）时：第一段返回 0、第二段返回 0，
但 aclrtSynchronizeStream 返回 507035（设备侧运行时错误）。同族 1d / 2d 反向的同类负 padding
却正常 PASS，说明裁剪语义本身是被支持的，3d 实现不一致。

同一台 A2 单机逐项对照（FLOAT32，值全 1）：

期望

要么与 1d/2d 一致地正确完成裁剪（推荐，因为同族已支持），
要么在第一段返回 161002（ACLNN_ERR_PARAM_INVALID）明确拒绝。

当前行为是最差的一种：参数被接受、kernel 被拉起、在 stream 同步时才报设备错误。
异步/图模式下调用方很难把它归因到「padding 为负」，且设备侧错误会污染后续算子。

影响

• 调用方拿到 507035（运行时错误），无法区分「自己传错参数」与「环境/设备故障」。
• 错误发生在执行段而非校验段，异步场景下定位成本高；同族 1d/2d 能跑通更会误导使用者以为 3d 也行。

建议

按 1d/2d 的实现路径让 3d 反向也支持负 padding 裁剪；若短期做不到，
在 op_api / tiling 前置判负并返回 161002，不要等到 kernel 阶段失败。

环境

• 仓：cann/ops-math @ 584b2ea6（master，2026-10-24 fetch）
• 硬件：Ascend 910B2（A2）单卡；CANN 9.2.0（toolkit）；Linux aarch64
• 实测日期 2026-10-25（4.2 单机，非多会话争用机）

复现步骤

1. 把下方「复现脚本」存为 repro_rpp3b_negpad.cpp；LF 换行
2. 编译：g++ -std=c++17 -O2 repro_rpp3b_negpad.cpp -o repro -I"$ASCEND_HOME_PATH/include" -L"$ASCEND_HOME_PATH/lib64" -lascendcl -lopapi -lnnopbase
3. 运行：ASCEND_LAUNCH_BLOCKING=1 ./repro
4. CTRL-pospad 应为 ret(gws)=0 ret(exec)=0 sync=0；DEFECT-negpad 实测 ret(gws)=0 ret(exec)=0 sync=507035

复现脚本

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

static aclTensor* Make(std::vector<float>& h, std::vector<int64_t>& sh, void** dev) {
    int64_t n = 1; for (auto d : sh) n *= d;
    size_t b = size_t(n > 0 ? n : 1) * sizeof(float);
    aclrtMalloc(dev, b, ACL_MEM_MALLOC_HUGE_FIRST);
    if (n > 0) aclrtMemcpy(*dev, b, h.data(), b, ACL_MEMCPY_HOST_TO_DEVICE);
    std::vector<int64_t> st(sh.size(), 1);
    for (int64_t i = int64_t(sh.size()) - 2; i >= 0; --i) st[i] = sh[i + 1] * st[i + 1];
    return aclCreateTensor(sh.data(), sh.size(), ACL_FLOAT, st.data(), 0,
                           ACL_FORMAT_ND, sh.data(), sh.size(), *dev);
}

static std::vector<int64_t> Padded(const std::vector<int64_t>& s, const std::vector<int64_t>& p) {
    std::vector<int64_t> o = s; int r = int(o.size());
    for (int k = r - 1; k >= 0; --k) {
        int i = 2 * (r - 1 - k);
        if (i + 1 < int(p.size())) o[k] += p[i] + p[i + 1];
    }
    return o;
}

static void Run(const char* tag, std::vector<int64_t> selfShape, std::vector<int64_t> pads,
                aclrtStream stream) {
    std::vector<int64_t> goShape = Padded(selfShape, pads);
    int64_t nSelf = 1, nGo = 1;
    for (auto d : selfShape) nSelf *= d;
    for (auto d : goShape) nGo *= d;
    std::vector<float> selfH(size_t(nSelf > 0 ? nSelf : 1), 1.0f);
    std::vector<float> goH(size_t(nGo > 0 ? nGo : 1), 1.0f);
    std::vector<float> giH(size_t(nSelf > 0 ? nSelf : 1), -7.0f);
    void *sd = nullptr, *gd = nullptr, *id = nullptr;
    aclTensor* self = Make(selfH, selfShape, &sd);
    aclTensor* go = Make(goH, goShape, &gd);
    aclTensor* gi = Make(giH, selfShape, &id);
    aclIntArray* pa = aclCreateIntArray(pads.data(), int64_t(pads.size()));
    uint64_t ws = 0; aclOpExecutor* ex = nullptr;
    auto rc1 = aclnnReplicationPad3dBackwardGetWorkspaceSize(go, self, pa, gi, &ws, &ex);
    void* w = nullptr;
    if (rc1 == 0 && ws > 0) aclrtMalloc(&w, ws, ACL_MEM_MALLOC_HUGE_FIRST);
    aclnnStatus rc2 = (aclnnStatus)-1;
    if (rc1 == 0) rc2 = aclnnReplicationPad3dBackward(w, ws, ex, stream);
    aclnnStatus rc3 = (rc1 == 0 && rc2 == 0) ? aclrtSynchronizeStream(stream) : -1;
    printf("[%-14s] pad=[", tag);
    for (size_t i = 0; i < pads.size(); ++i) printf("%s%ld", i ? "," : "", long(pads[i]));
    printf("]  ret(gws)=%d ret(exec)=%d sync=%d\n", int(rc1), int(rc2), int(rc3));
    aclDestroyTensor(self); aclDestroyTensor(go); aclDestroyTensor(gi); aclDestroyIntArray(pa);
    if (w) aclrtFree(w);
    aclrtFree(sd); aclrtFree(gd); aclrtFree(id);
}

int main() {
    aclInit(nullptr); aclrtSetDevice(0);
    aclrtStream s = nullptr; aclrtCreateStream(&s);
    Run("CTRL-pospad", {1, 1, 4, 5, 6}, {1, 1, 1, 1, 1, 1}, s);      // 对照组 CTRL
    Run("DEFECT-negpad", {1, 1, 4, 5, 6}, {-1, 1, 0, 2, 1, 0}, s);   // 缺陷组 DEFECT
    aclrtDestroyStream(s); aclrtResetDevice(0); aclFinalize();
    return 0;
}

实测输出：

[CTRL-pospad] pad=[1,1,1,1,1,1] ret(gws)=0 ret(exec)=0 sync=0；
[DEFECT-negpad] pad=[-1,1,0,2,1,0] ret(gws)=0 ret(exec)=0 sync=507035。