CANN ops-math 标量除法算子 aclnnDivs/aclnnInplaceDivs 接口详解与 NPU 实战调用指南

原创2026-09-19 20:20:511,411 阅读
文章标签:算子库人工智能深度学习高性能计算CANNAscend

CANN ops-math 标量除法算子 aclnnDivs/aclnnInplaceDivs 接口详解与 NPU 实战调用指南

本篇文章以 CANN ops-math 开源仓库中 aclnnDivs&aclnnInplaceDivs 算子文档 为主体,系统讲解在昇腾 NPU 上完成"Tensor 与 Scalar 逐元素除法"的两组 aclnn 接口:非原地版 aclnnDivs 与原地版 aclnnInplaceDivs。你将掌握两段式接口的调用范式、各参数的类型与约束、数据类型推导规则、错误返回码含义,以及一份可直接编译运行的完整 C++ 调用样例;文章还会结合 op_api 源码 与 ST/UT 测试 说明其底层执行链路与验证方式。

一、产品支持情况

aclnnDivs 与 aclnnInplaceDivs 在不同昇腾产品上的支持情况如下(与 math/div/docs/aclnnDivs&aclnnInplaceDivs.md 保持一致):

产品 是否支持
Ascend 950PR/Ascend 950DT 支持
Atlas A3 训练系列产品/Atlas A3 推理系列产品 支持
Atlas A2 训练系列产品/Atlas A2 推理系列产品 支持
Atlas 200I/500 A2 推理产品 不支持
Atlas 推理系列产品 不支持
Atlas 训练系列产品 支持

需要说明的是,不同产品在数据类型支持上有细节差异(详见"数据类型约束与推导规则"一节),例如 Atlas 训练系列产品不支持 BFLOAT16 输入,而 Ascend 950PR/Ascend 950DT 的 out 不支持整型与 BOOL 类型,这些差异在源码 aclnn_div.cpp 中通过 ASCEND910_DTYPE_SUPPORT_LIST 与 ASCEND910B_DTYPE_SUPPORT_LIST 两套支持列表及平台判断逻辑分别处理。

二、功能说明与计算语义

2.1 接口功能与计算公式

该接口完成 Tensor 与 Scalar 的除法计算,计算过程可描述为:对输入张量 input 中的每一个元素,逐一除以标量 other,结果写入 out:

outi=inputiotherout_i = \frac{input_i}{other}

其中 input 即接口参数 self(原地版为 selfRef),other 为 aclScalar 类型的标量,out 为输出张量。

2.2 复数计算的特殊说明

当涉及 Complex(复数)运算时,如果分母(other)的模为 0,仍然采用通用的复数计算公式,不做特殊处理(例如不产生 CPU/GPU 上的约定结果)。也就是说,在复数除零这类边界语义上,本实现与 CPU/GPU 存在差异,业务侧若依赖该边界行为需要自行注意。

三、两段式接口设计

aclnnDivs 与 aclnnInplaceDivs 均遵循 CANN aclnn 算子库的两段式接口范式(可参考 two_phase_api.md):

  1. 第一段接口(GetWorkspaceSize):aclnnDivsGetWorkspaceSize / aclnnInplaceDivsGetWorkspaceSize。负责入参校验,并完成算子计算流程的编排,返回执行所需 workspace 大小(uint64_t *workspaceSize)以及包含了算子计算流程的执行器(aclOpExecutor **executor)。
  2. 第二段接口(执行):aclnnDivs / aclnnInplaceDivs。接收第一段接口产出的 workspace 地址、workspace 大小、executor 以及用户指定的 aclrtStream,真正下发计算任务。

在调用顺序上,必须先调用第一段接口获取 workspace 大小与执行器,再据其申请 Device 侧内存(workspaceSize > 0 时),最后调用第二段接口执行计算。完整流程见文末调用示例。

3.1 aclnnDivs 与 aclnnInplaceDivs 的使用区别

两个接口实现的功能完全相同,区别仅在于结果存放方式:

  • aclnnDivs:需要调用方新建一个输出张量对象 out,计算结果写入该输出张量;
  • aclnnInplaceDivs:无需新建输出张量对象,直接在输入张量 selfRef 的内存中覆盖存储计算结果(原地计算)。

原地接口可以省去一次输出张量分配与拷贝,适合需要对原张量就地更新的场景;若希望保留原输入,则应使用非原地接口。

四、函数原型

4.1 aclnnDivsGetWorkspaceSize(第一段)

aclnnStatus aclnnDivsGetWorkspaceSize(
  const aclTensor *self,
  const aclScalar *other,
  aclTensor       *out,
  uint64_t        *workspaceSize,
  aclOpExecutor  **executor)

4.2 aclnnDivs(第二段)

aclnnStatus aclnnDivs(
  void          *workspace,
  uint64_t       workspaceSize,
  aclOpExecutor *executor,
  aclrtStream    stream)

4.3 aclnnInplaceDivsGetWorkspaceSize(第一段)

aclnnStatus aclnnInplaceDivsGetWorkspaceSize(
  aclTensor       *selfRef,
  const aclScalar *other,
  uint64_t        *workspaceSize,
  aclOpExecutor  **executor)

4.4 aclnnInplaceDivs(第二段)

aclnnStatus aclnnInplaceDivs(
  void          *workspace,
  uint64_t       workspaceSize,
  aclOpExecutor *executor,
  aclrtStream    stream)

从源码 aclnn_div.h 可以看到,这些接口均以 ACLNN_API 导出、以 extern "C" 包裹,域名为 aclnn_math,与 aclnnDiv、aclnnDivMod、aclnnDivMods 等除法族接口一并声明。

五、aclnnDivsGetWorkspaceSize 参数详解

第一段接口完成入参校验并返回 workspace 大小与执行器,各参数含义如下:

参数名 输入/输出 描述 使用说明 数据类型 数据格式 维度(shape) 非连续Tensor
self 输入 公式中的输入 input - FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL、COMPLEX128、COMPLEX64、BFLOAT16 ND - √
other 输入 公式中的输入 other - FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL、COMPLEX128、COMPLEX64、BFLOAT16 - - -
out 输出 公式中的 out 数据类型需要是 self 与 other 推导之后可转换的数据类型,shape 与 self 相同 FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL、COMPLEX128、COMPLEX64、BFLOAT16 ND - √
workspaceSize 输出 返回需要在 Device 侧申请的 workspace 大小 - - - - -
executor 输出 返回 op 执行器,包含了算子计算流程 - - - - -

要点说明:

  • self 支持非连续 Tensor(表中"√"),数据格式为 ND;other 为 aclScalar,无 shape/format 约束;
  • out 的 shape 必须与 self 相同(标量除法不做广播,形状逐元素对齐),数据类型须为 self 与 other 按推导规则推导后可转换到的类型;
  • 维度约束:self 与 other 的维度不能大于 8,否则返回参数非法错误。

六、数据类型约束与推导规则

数据类型推导是使用本接口最容易出错的地方,不同产品约束不同:

Atlas 训练系列产品:

  • self、out 数据类型不支持 BFLOAT16;
  • self 与 other 的数据类型需满足数据类型推导规则(互推导关系参见 deduction_relationship.md)。

Atlas A2 训练系列产品/Atlas A2 推理系列产品、Atlas A3 训练系列产品/Atlas A3 推理系列产品:

Ascend 950PR/Ascend 950DT:

  • out 数据类型不支持 INT32、INT64、INT16、INT8、UINT8、BOOL;
  • self 与 other 需满足 Tensor-Scalar 互推导关系(参见 deduction_relationship.md),且推导之后的数据类型若为整数类型或布尔类型,会转换为 FLOAT 参与计算。

从源码实现看,类型推导逻辑集中在 aclnn_div.cpp 中的 InferDivsModeDtype/CompatibleInferDivsDtype 与 PromoteIntegerInputsToFloat 等函数:整数类型输入默认提升到 FLOAT(仅在部分芯片上保留 INT32 精度),FP16/BF16 会提升到 FLOAT 计算以避免标量被提前降精度(PromoteLowPrecToFloat),复数输入则通过 CombineCategoriesWithComplex 与 InnerTypeToComplexType 完成复数类型映射。也就是说,"推导结果落到 FLOAT"不仅发生在 950 产品上,也是标量除法接口的整体默认行为。

七、aclnnDivs 参数说明

第二段接口 aclnnDivs 的参数如下:

参数名 输入/输出 描述
workspace 输入 在 Device 侧申请的 workspace 内存地址
workspaceSize 输入 在 Device 侧申请的 workspace 大小,由第一段接口 aclnnDivsGetWorkspaceSize 获取
executor 输入 op 执行器,包含了算子计算流程
stream 输入 指定执行任务的 Stream

八、aclnnInplaceDivsGetWorkspaceSize 参数详解

与 aclnnDivsGetWorkspaceSize 相比,原地版本没有 out 参数,输入输出共用 selfRef:

参数名 输入/输出 描述 使用说明 数据类型 数据格式 维度(shape) 非连续Tensor
selfRef 输入 公式中的输入 selfRef - FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL、COMPLEX128、COMPLEX64、BFLOAT16 ND - √
other 输入 公式中的输入 other - FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL、COMPLEX128、COMPLEX64、BFLOAT16 - - -
workspaceSize 输出 返回需要在 Device 侧申请的 workspace 大小 - - - - -
executor 输出 返回 op 执行器,包含了算子计算流程 - - - - -

各产品约束与第六节一致,只是将 self 换成 selfRef:

  • Atlas 训练系列产品:selfRef 不支持 BFLOAT16,且需满足数据类型推导规则;
  • Atlas A2/A3 系列:selfRef 与 other 需满足数据类型推导规则;
  • Ascend 950PR/Ascend 950DT:selfRef 不支持 INT32、INT64、INT16、INT8、UINT8、BOOL;推导结果为整数或布尔类型时转换为 FLOAT。

从源码 aclnn_div.cpp 第 1142-1147 行可以看到,aclnnInplaceDivsGetWorkspaceSize 的实现非常简洁:将 selfRef 直接作为输出 out 传入 aclnnDivsGetWorkspaceSize 完成校验与编排,计算链路完全复用,体现了原地接口与普通接口在实现上的同构关系。

九、aclnnInplaceDivs 参数说明

参数名 输入/输出 描述
workspace 输入 在 Device 侧申请的 workspace 内存地址
workspaceSize 输入 在 Device 侧申请的 workspace 大小,由第一段接口 aclnnInplaceDivsGetWorkspaceSize 获取
executor 输入 op 执行器,包含了算子计算流程
stream 输入 指定执行任务的 Stream

十、返回值与错误码

两段接口均返回 aclnnStatus 状态码,具体可参见 aclnn_return_code.md。

第一段接口完成入参校验,以下场景会报错:

aclnnDivsGetWorkspaceSize:

返回码 错误码 描述
ACLNN_ERR_PARAM_NULLPTR 161001 传入的 self、other 或 out 是空指针
ACLNN_ERR_PARAM_INVALID 161002 self 和 other 的数据类型和数据格式不在支持的范围之内
ACLNN_ERR_PARAM_INVALID 161002 self 和 other 不满足数据类型推导规则
ACLNN_ERR_PARAM_INVALID 161002 推导出的数据类型无法转换为指定输出 out 的类型
ACLNN_ERR_PARAM_INVALID 161002 self 和 other 的维度大于 8

aclnnInplaceDivsGetWorkspaceSize:

返回码 错误码 描述
ACLNN_ERR_PARAM_NULLPTR 161001 传入的 selfRef、other 是空指针
ACLNN_ERR_PARAM_INVALID 161002 selfRef 和 other 的数据类型和数据格式不在支持的范围之内
ACLNN_ERR_PARAM_INVALID 161002 selfRef 和 other 不满足数据类型推导规则
ACLNN_ERR_PARAM_INVALID 161002 selfRef 和 other 的维度大于 8

这些校验在源码 aclnn_div.cpp 的 CheckParamsScalar 中按序执行:先检查空指针(返回 NULLPTR 类错误),再检查数据格式(不允许私有格式)、数据类型(对照平台支持列表)、shape 一致性(self 与 out 的 view shape 必须一致)与类型推导/转换可行性,任何一步失败都会以 ACLNN_ERR_PARAM_INVALID 返回。

十一、源码实现剖析:workspace 如何产生、计算如何执行

以 aclnnDivsGetWorkspaceSize 为入口,aclnn_div.cpp 的核心执行链路可以归纳为四步,理解这条链路有助于排查性能与精度问题:

  1. 创建执行器并完成参数校验:CREATE_EXECUTOR() 创建 aclOpExecutor,随后 CheckParamsScalar 完成空指针、格式、类型、shape 校验;
  2. 空 Tensor 短路:若 self->IsEmpty(),直接返回 workspaceSize = 0 与空执行器,不进入 kernel 计算(源码注释明确空 tensor 由 kernel 侧支持);
  3. 类型提升与输入预处理:根据推导规则确定计算类型 promoteType,将 self 转为连续 Tensor(l0op::Contiguous)并按需 l0op::Cast 到计算类型;标量 other 通过 executor->ConvertToTensor(other, promoteType) 转成同类型 Tensor。在部分平台上还会走 CanUseMuls 优化路径:当 self 为 FP16/BF16/FLOAT 时,直接计算标量倒数 1/other(在 double 下计算后单次舍入到 float,以对齐 CUDA 标量除法精度),再以 l0op::Muls 一次乘完成除法,避免构造除数 Tensor;
  4. 计算、回写与 workspace 上报:l0op::RealDiv 完成逐元素除法,l0op::Cast 将结果转回 out 的数据类型,l0op::ViewCopy 将结果写入(可能非连续的)out,最后 executor->GetWorkspaceSize() 汇总整条计算链所需的 Device 侧内存大小并连同 executor 一起返回。

第二段接口 aclnnDivs 则统一调用 CommonOpExecutorRun(workspace, workspaceSize, executor, stream),由框架完成真正下发。值得注意的还有混合精度支持:源码中 isDivsMixDtypeSupport 在 910B/910_93 等平台上允许 FP16×FLOAT、BF16×FLOAT、BF16×DOUBLE 等标量组合(AllowedMixDtypePairs),此时走独立的混合精度分支,无需按常规规则整体提升。

十二、约束说明

  • 确定性计算:aclnnDivs 与 aclnnInplaceDivs 默认采用确定性实现,即相同输入在多次运行中计算结果一致(相关背景可参考 determinism_compute.md)。

十三、完整调用示例

以下示例完整覆盖两段式调用、workspace 申请、结果回读与资源释放,可直接作为开发模板。具体编译和执行过程请参考 compile_and_run_sample.md。

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_div.h"

#define CHECK_RET(cond, return_expr) \
  do {                               \
    if (!(cond)) {                   \
      return_expr;                   \
    }                                \
  } while (0)

#define LOG_PRINT(message, ...)     \
  do {                              \
    printf(message, ##__VA_ARGS__); \
  } while (0)

int64_t GetShapeSize(const std::vector<int64_t>& shape) {
  int64_t shapeSize = 1;
  for (auto i : shape) {
    shapeSize *= i;
  }
  return shapeSize;
}

int Init(int32_t deviceId, aclrtStream* stream) {
  // 固定写法,资源初始化
  auto ret = aclInit(nullptr);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret);
  ret = aclrtSetDevice(deviceId);
  CHECK_RET(ret == ACL_SUCCESS,
            LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); aclFinalize(); return ret);
  ret = aclrtCreateStream(stream);
  CHECK_RET(ret == ACL_SUCCESS,
            LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret);
            aclrtResetDevice(deviceId); aclFinalize(); return ret);
  return 0;
}

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) {
  auto size = GetShapeSize(shape) * sizeof(T);
  // 调用aclrtMalloc申请device侧内存
  auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret);
  // 调用aclrtMemcpy将host侧数据拷贝到device侧内存上
  ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret);

  // 计算连续tensor的strides
  std::vector<int64_t> strides(shape.size(), 1);
  for (int64_t i = shape.size() - 2; i >= 0; i--) {
    strides[i] = shape[i + 1] * strides[i + 1];
  }

  // 调用aclCreateTensor接口创建aclTensor
  *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND,
                            shape.data(), shape.size(), *deviceAddr);
  return 0;
}

int main() {
  // 1.(固定写法)device/stream初始化,参考acl API手册
  // 根据自己的实际device填写deviceId
  int32_t deviceId = 0;
  aclrtStream stream;
  auto ret = Init(deviceId, &stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

  // 2. 构造输入与输出,需要根据API的接口自定义构造
  std::vector<int64_t> selfShape = {4, 2};
  std::vector<int64_t> outShape = {4, 2};
  void* selfDeviceAddr = nullptr;
  void* otherDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclScalar* other = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = {0, 1, 2, 3, 4, 5, 6, 7};
  std::vector<float> outHostData(8, 0);
  float otherValue = 2.0f;
  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建other aclScalar
  other = aclCreateScalar(&otherValue, aclDataType::ACL_FLOAT);
  CHECK_RET(other != nullptr, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;

  // aclnnDivs接口调用示例
  LOG_PRINT("test aclnnDivs\n");

  // 3. 调用CANN算子库API,需要修改为具体的API名称
  // 调用aclnnDivs第一段接口
  ret = aclnnDivsGetWorkspaceSize(self, other, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnDivsGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) {
    ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret);
  }
  // 调用aclnnDivs第二段接口
  ret = aclnnDivs(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnDivs failed. ERROR: %d\n", ret); return ret);

  // 4.(固定写法)同步等待任务执行结束
  ret = aclrtSynchronizeStream(stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);

  // 5. 获取输出的值,将device侧内存上的结果拷贝至host侧,需要根据具体API的接口定义修改
  auto size = GetShapeSize(outShape);
  std::vector<float> resultData(size, 0);
  ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr,
                    size * sizeof(resultData[0]), ACL_MEMCPY_DEVICE_TO_HOST);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret);
  for (int64_t i = 0; i < size; i++) {
    LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]);
  }

  // aclnnInplaceDivs接口调用示例
  LOG_PRINT("\ntest aclnnInplaceDivs\n");

  // 3. 调用CANN算子库API,需要修改为具体的API名称
  // 调用aclnnInplaceDivs第一段接口
  ret = aclnnInplaceDivsGetWorkspaceSize(self, other, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceDivsGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  if (workspaceSize > 0) {
    ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret);
  }
  // 调用aclnnInplaceDivs第二段接口
  ret = aclnnInplaceDivs(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceDivs failed. ERROR: %d\n", ret); return ret);

  // 4.(固定写法)同步等待任务执行结束
  ret = aclrtSynchronizeStream(stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);

  // 5. 获取输出的值,将device侧内存上的结果拷贝至host侧,需要根据具体API的接口定义修改
  ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), selfDeviceAddr,
                    size * sizeof(resultData[0]), ACL_MEMCPY_DEVICE_TO_HOST);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret);
  for (int64_t i = 0; i < size; i++) {
    LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]);
  }

  // 6. 释放aclTensor和aclScalar,需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyScalar(other);
  aclDestroyTensor(out);

  // 7. 释放Device资源
  aclrtFree(selfDeviceAddr);
  aclrtFree(outDeviceAddr);
  if (workspaceSize > 0) {
    aclrtFree(workspaceAddr);
  }
  aclrtDestroyStream(stream);
  aclrtResetDevice(deviceId);
  aclFinalize();

  return 0;
}

对上述示例的要点拆解:

  • 第 3 步是核心差异点:非原地调用需要先创建 out 并传入 aclnnDivsGetWorkspaceSize;原地调用不需要 out,直接以 self(内存上原地更新)作为 selfRef 传入 aclnnInplaceDivsGetWorkspaceSize;
  • workspace 必须按第一段接口返回的大小申请,且仅在 workspaceSize > 0 时才需要 aclrtMalloc,否则传空指针即可;
  • 结果回读位置不同:非原地从 outDeviceAddr 回读,原地从 selfDeviceAddr 回读(因为结果写回了原输入内存);
  • 本示例使用 FLOAT 输入、other = 2.0f、shape {4, 2},输入 {0,1,2,3,4,5,6,7} 的期望输出为 {0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5}。

十四、测试与验证

仓库为 aclnnDivs 提供了完善的测试支撑,可用于接口行为验证:

小结

aclnnDivs/aclnnInplaceDivs 是 CANN ops-math 除法族中最常用的"Tensor ÷ 标量"接口:两者语义等价,区别仅在结果是否写回原输入。使用时要特别留意三点——先调第一段接口再调第二段接口的两段式范式、self/other/out 的数据类型互推导约束(含各产品差异)、以及复数除零与 CPU/GPU 的语义差异。掌握文末的完整调用模板,再结合 ST 用例 中的数据组合,即可在支持的昇腾产品上快速完成该算子的开发与验证。

登录后查看全文
ops-math