CANN ops-nn ForeachPowScalarList 算子实战:aclnn 两段式接口实现张量列表逐元素幂运算

原创2026-09-21 20:17:09693 阅读
文章标签:人工智能深度学习算子库高性能计算模型量化AscendCANN

CANN ops-nn ForeachPowScalarList 算子实战:aclnn 两段式接口实现张量列表逐元素幂运算

本篇技术指南围绕 CANN ops-nn 仓库中的 ForeachPowScalarList 算子及其对外接口 aclnnForeachPowScalarList 展开,完整讲解该算子的产品支持范围、数学定义、两段式调用流程、全部参数约束与返回码语义,并给出可编译运行的 C++ 调用示例。同时结合仓库源码(OpDef 定义、AscendC kernel 实现、tiling 策略与测试用例)深入剖析其底层实现原理,帮助读者在 Atlas 系列 NPU 上正确、高效地使用该接口完成"张量列表 × 标量列表"的批量幂运算。

算子概述与产品支持情况

ForeachPowScalarList 是 CANN ops-nn 仓库 foreach/foreach_pow_scalar_list 目录下的一个 foreach 系列算子,对应 PyTorch 的 torch._foreach_pow 语义。它接收一个张量列表 x 和一个等长的标量列表 exponent,对列表中每个张量分别执行一次以对应标量为指数的幂运算,最终输出一个新的张量列表 y。

该算子对外暴露为 aclnn 接口,其产品支持情况如下(详见 docs/aclnnForeachPowScalarList.md 与 README.md):

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

需要注意的是,README 中还额外注明:Kirin X90 / Kirin 9030 处理器系列产品上,x 和 y 的数据类型不支持 BFLOAT16。这一点在源码中也有印证——foreach_pow_scalar_list_def.cpp 中 Kirin 平台的 tensor_dtype_list_kirin 仅包含 {DT_FLOAT16, DT_FLOAT, DT_INT32},排除了 DT_BF16。

功能说明与计算公式

接口功能:对输入张量列表 x 中的每个张量进行指数运算,指数为标量列表 exponent 中与之对应的标量,即逐张量、逐元素地计算幂。

计算公式定义如下:

x=[x0,x1,...xn−1]exponent=[exponent0,exponent1,...exponentn−1]y=[y0,y1,...yn−1]x = [{x_0}, {x_1}, ... {x_{n-1}}]\\ exponent = [{exponent_0}, {exponent_1}, ... {exponent_{n-1}}]\\ y = [{y_0}, {y_1}, ... {y_{n-1}}]

yi=xiexponenti(i=0,1,...n−1)y_i = {{x_i}}^{exponent_i} \quad (i=0,1,...n-1)

其中 n 为张量列表中张量的个数,要求标量列表 exponent 的元素个数与张量列表 x 中 Tensor 的个数相等,二者按下标一一对应。

两段式接口与函数原型

每个 aclnn 算子都采用两段式接口设计。必须先调用 aclnnForeachPowScalarListGetWorkspaceSize 接口,获取计算所需的 workspace 大小以及包含算子计算流程的执行器;再调用 aclnnForeachPowScalarList 接口执行实际计算。

第一段接口(获取 workspace 大小与执行器):

aclnnStatus aclnnForeachPowScalarListGetWorkspaceSize(
  const aclTensorList *x,
  const aclScalarList *scalars,
  const aclTensorList *out,
  uint64_t            *workspaceSize,
  aclOpExecutor      **executor)

第二段接口(执行计算):

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

aclnnForeachPowScalarListGetWorkspaceSize 参数详解

第一段接口完成入参校验、workspace 大小计算与执行器创建,其参数说明如下:

参数名 输入/输出 描述 使用说明 数据类型 数据格式 维度(shape) 非连续Tensor
x(aclTensorList*) 输入 表示进行 n 次方运算的底数,对应公式中的 x 支持空 Tensor;该参数中所有 Tensor 的数据类型保持一致 FLOAT32、FLOAT16、INT32、BFLOAT16 ND 0-8 √
scalars(aclScalarList*) 输入 表示进行 n 次方运算的指数,对应公式中的 exponent 元素个数与 x 中 Tensor 的个数相等;数据类型与入参 x 具有一定对应关系(见下文);取值的绝对值必须小于等于 (2^31-1) FLOAT32、INT64 - - -
out(aclTensorList*) 输出 表示进行 n 次方运算的输出结果,对应公式中的 y 支持空 Tensor;该参数中所有 Tensor 的数据类型保持一致;数据类型和数据格式与入参 x 一致,shape size 大于等于入参 x 的 shape size FLOAT32、FLOAT16、INT32、BFLOAT16 ND 0-8 ×
workspaceSize(uint64_t*) 输出 返回需要在 Device 侧申请的 workspace 大小 - - - - -
executor(aclOpExecutor**) 输出 返回 op 执行器,包含了算子计算流程 - - - - -

其中 scalars 与 x 的数据类型对应关系如下:

  • 当 x 的数据类型为 FLOAT32、FLOAT16、BFLOAT16 时,scalars 数据类型支持 FLOAT32;
  • 当 x 的数据类型为 INT32 时,scalars 数据类型支持 INT64。

该对应关系在算子注册源码中同样可以验证。foreach_pow_scalar_list_def.cpp 中通过 DtypeTensor2Scalar 工具将输入张量类型逐一映射为对应的标量类型;foreach_pow_scalar_list_proto.h 的图模式 IR 也声明 x/y 支持 {DT_FLOAT, DT_FLOAT16, DT_INT32, DT_BF16},而 scalars 支持 {DT_FLOAT, DT_INT64}。

另外需要注意:

  • 底数 x 支持非连续 Tensor(表格中"非连续Tensor"列为 √),但输出 out 不支持非连续 Tensor(列为 ×),这是 README 约束说明中明确指出的限制;
  • x 与 out 支持 0-8 维的 ND 格式张量,超过 8 维会触发错误返回。

aclnnForeachPowScalarList 参数详解

第二段接口直接使用第一段接口产出的 workspace 与 executor 发起计算,参数说明如下:

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

返回值与错误码

两个接口均返回 aclnnStatus 状态码,具体参见 aclnn 返回码。第一段接口完成入参校验,出现以下场景时报错:

返回码 错误码 描述
ACLNN_ERR_PARAM_NULLPTR 161001 传入的 x、scalars、out 是空指针
ACLNN_ERR_PARAM_INVALID 161002 x、scalars、out 的数据类型不在支持的范围之内
ACLNN_ERR_PARAM_INVALID 161002 x 和 out 的数据类型不一致
ACLNN_ERR_INNER_TILING_ERROR 561002 x 与 out 的 shape 不满足约束
ACLNN_ERR_INNER_TILING_ERROR 561002 x 或 out 中的 Tensor 的数据类型不一致
ACLNN_ERR_INNER_TILING_ERROR 561002 x 或 out 中的 Tensor 维度超过 8 维

从错误码分布可以看出,参数层面的校验(空指针、类型不合法、类型不一致)在第一段接口即被拦截,而 shape 与维度相关的约束则在 tiling 阶段(错误码 561002,TILING_ERROR)才会暴露。

约束说明

  • 确定性计算:aclnnForeachPowScalarList 默认为确定性实现,即相同输入在多次运行中产生一致的输出结果;
  • 输出 out 不支持非连续 Tensor;
  • scalars 中指数取值绝对值必须小于等于 (2^31-1)。

调用示例与代码解读

以下示例代码来自 examples/test_aclnn_foreach_pow_scalar_list.cpp,与 API 文档中的示例一致,仅供参考。具体编译和执行过程可参考 编译与运行样例。

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_foreach_pow_scalar_list.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); return ret);
  ret = aclrtCreateStream(stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); 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> selfShape1 = {2, 3};
  std::vector<int64_t> selfShape2 = {1, 3};
  std::vector<int64_t> outShape1 = {2, 3};
  std::vector<int64_t> outShape2 = {1, 3};
  void* input1DeviceAddr = nullptr;
  void* input2DeviceAddr = nullptr;
  void* out1DeviceAddr = nullptr;
  void* out2DeviceAddr = nullptr;
  aclTensor* input1 = nullptr;
  aclTensor* input2 = nullptr;
  aclScalar* alpha1 = nullptr;
  aclScalar* alpha2 = nullptr;
  aclTensor* out1 = nullptr;
  aclTensor* out2 = nullptr;
  std::vector<float> input1HostData = {1, 2, 3, 4, 5, 6};
  std::vector<float> input2HostData = {7, 8, 9};
  std::vector<float> out1HostData(6, 0);
  std::vector<float> out2HostData(3, 0);
  float alpha1Value = 1.2f;
  float alpha2Value = 2.2f;
  // 创建input1 aclTensor
  ret = CreateAclTensor(input1HostData, selfShape1, &input1DeviceAddr, aclDataType::ACL_FLOAT, &input1);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建input2 aclTensor
  ret = CreateAclTensor(input2HostData, selfShape2, &input2DeviceAddr, aclDataType::ACL_FLOAT, &input2);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建alpha1 aclScalar
  alpha1 = aclCreateScalar(&alpha1Value, aclDataType::ACL_FLOAT);
  CHECK_RET(alpha1 != nullptr, return ret);
  // 创建alpha2 aclScalar
  alpha2 = aclCreateScalar(&alpha2Value, aclDataType::ACL_FLOAT);
  CHECK_RET(alpha2 != nullptr, return ret);
  // 创建out1 aclTensor
  ret = CreateAclTensor(out1HostData, outShape1, &out1DeviceAddr, aclDataType::ACL_FLOAT, &out1);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out2 aclTensor
  ret = CreateAclTensor(out2HostData, outShape2, &out2DeviceAddr, aclDataType::ACL_FLOAT, &out2);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  std::vector<aclTensor*> tempInput{input1, input2};
  aclTensorList* tensorListInput = aclCreateTensorList(tempInput.data(), tempInput.size());
  std::vector<aclTensor*> tempOutput{out1, out2};
  aclTensorList* tensorListOutput = aclCreateTensorList(tempOutput.data(), tempOutput.size());
  std::vector<aclScalar*> tempscalar{alpha1, alpha2};
  aclScalarList* scalarlist = aclCreateScalarList(tempscalar.data(), tempscalar.size());

  // 3. 调用CANN算子库API,需要修改为具体的API名称
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnForeachPowScalarList第一段接口
  ret = aclnnForeachPowScalarListGetWorkspaceSize(tensorListInput, scalarlist, tensorListOutput, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnForeachPowScalarListGetWorkspaceSize 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);
  }
  // 调用aclnnForeachPowScalarList第二段接口
  ret = aclnnForeachPowScalarList(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnForeachPowScalarList 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(outShape1);
  std::vector<float> out1Data(size, 0);
  ret = aclrtMemcpy(out1Data.data(), out1Data.size() * sizeof(out1Data[0]), out1DeviceAddr,
                    size * sizeof(out1Data[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("out1 result[%ld] is: %f\n", i, out1Data[i]);
  }

  size = GetShapeSize(outShape2);
  std::vector<float> out2Data(size, 0);
  ret = aclrtMemcpy(out2Data.data(), out2Data.size() * sizeof(out2Data[0]), out2DeviceAddr,
                    size * sizeof(out2Data[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("out2 result[%ld] is: %f\n", i, out2Data[i]);
  }

  // 6. 释放aclTensor和aclScalar,需要根据具体API的接口定义修改
  aclDestroyTensorList(tensorListInput);
  aclDestroyTensorList(tensorListOutput);
  aclDestroyScalarList(scalarlist);

  // 7.释放device资源,需要根据具体API的接口定义修改
  aclrtFree(input1DeviceAddr);
  aclrtFree(input2DeviceAddr);
  aclrtFree(out1DeviceAddr);
  aclrtFree(out2DeviceAddr);
  if (workspaceSize > 0) {
    aclrtFree(workspaceAddr);
  }
  aclrtDestroyStream(stream);
  aclrtResetDevice(deviceId);
  aclFinalize();
  return 0;
}

该示例的核心流程可以归纳为七个步骤:

  1. 资源初始化:aclInit → aclrtSetDevice → aclrtCreateStream,这是所有 aclnn 程序的固定写法;
  2. 构造输入输出:通过 aclrtMalloc/aclrtMemcpy 准备 Device 侧数据,用 aclCreateTensor 创建 aclTensor,用 aclCreateScalar 创建 aclScalar,再通过 aclCreateTensorList 与 aclCreateScalarList 组装成张量列表与标量列表。示例中为 {1,2,3,4,5,6} 与 {7,8,9} 两个底数张量分别配指数 1.2 与 2.2,即分别计算 x^1.2 与 x^2.2;
  3. 两段式调用:先调 GetWorkspaceSize 获取 workspace 大小与 executor,按需 aclrtMalloc 申请 workspace,再调执行接口;
  4. 同步等待:aclrtSynchronizeStream 确保算子执行完毕;
  5. 结果回拷:将 Device 侧结果通过 aclrtMemcpy 拷回 Host 并打印;
  6. 释放列表资源:aclDestroyTensorList、aclDestroyScalarList;
  7. 释放 Device 资源:aclrtFree、aclrtDestroyStream、aclrtResetDevice、aclFinalize。

底层实现原理:从 OpDef 到 AscendC Kernel

ForeachPowScalarList 算子在仓库中是一个完整的三段式算子工程,理解其源码有助于更准确地使用接口。

算子定义(OpDef)

foreach_pow_scalar_list_def.cpp 是算子的 Host 侧定义文件,核心内容如下:

  • 输入 x 为 DYNAMIC 动态输入(TensorList),数据类型支持 DT_FLOAT16, DT_FLOAT, DT_INT32, DT_BF16,格式统一为 FORMAT_ND,并开启 AutoContiguous 自动连续化;
  • 输入 scalars 为 ScalarList 类型(REQUIRED 必选参数),数据类型由 DtypeTensor2Scalar 从张量类型推导而来,即浮点输入对应 FLOAT32、整型输入对应 INT64,与 API 文档的数据类型对应关系完全一致;
  • 输出 y 同样为 DYNAMIC 动态输出;
  • AI Core 配置上开启了 DynamicRankSupportFlag(支持动态维度)、DynamicShapeSupportFlag(支持动态 shape)、PrecisionReduceFlag(允许精度降低),并注册了 ascend950、ascend910_93、ascend910b、kirinx90、kirin9030 等平台配置。

Tiling 策略

arch35/foreach_pow_scalar_list_tiling_arch35.cpp 实现了 arch35 平台的 tiling 逻辑:

  • 通过平台信息获取 AIV 核数 coreNum 与 UB 内存大小 ubSize;
  • 遍历 x 中每个 Tensor 的 shape,累加得到总元素数 totalElements,并记录每个 Tensor 的元素数到 tensorElements[];
  • 按"每个核至少处理 MIN_PER_CORE = 1024 个元素"的原则计算所需核数 needCoreNum = min(coreNum, ceil(totalElements / 1024)),并通过 SetBlockDim 设置实际并行核数;当 totalElements == 0 时退化为单核执行;
  • 通过 GetLibApiWorkSpaceSize 获取系统 workspace 大小,并申请用户 workspace;
  • 根据 x 的数据类型(FLOAT/FLOAT16/INT32/BF16)设置不同的 tiling key,kernel 侧据此选择对应的实例化模板;
  • 校验张量数量上限为 MAX_TENSOR_NUM = 256。

tiling 数据结构定义在 arch35/foreach_pow_scalar_list_tiling_data.h,包含 needCoreNum、tensorCount、totalElements 以及最多 256 个 Tensor 的元素数数组 tensorElements[256]。

AscendC Kernel 实现

kernel 入口在 op_kernel/foreach_pow_scalar_list.cpp,根据 tiling key 分发到不同数据类型的模板实例:TILING_KEY 1/2/3/4 分别对应 half、float、int、bfloat16_t,其中 BF16 分支在 __NPU_ARCH__ == 3003 || 3113 架构下被排除(与 Kirin 平台不支持 BF16 的限制对应)。

核心计算类 ForeachPowScalarListND<T> 定义在 op_kernel/foreach_pow_scalar_list.h,实现要点:

  • 多核切分:kernel 通过 GetBlockIdx() 获取当前核号,从 tiling 数据中解析出本核负责的 Tensor 区间 [tensorStart, tensorEnd] 及每个 Tensor 内部的起始/结束偏移,实现"整 Tensor 级 + 区间级"两级负载划分;
  • 双缓冲流水:使用 BUFFER_NUM = 2 的双缓冲队列(dataQueue/outQueue),CopyIn 通过 DataCopy(整块)或 DataCopyPad(余数块)将 Global Memory 数据搬入 UB,ComputeAndCopyOut 计算完毕后异步拷回 Global Memory,实现搬入-计算-搬出的流水重叠;
  • 逐 Tensor 处理:Process() 循环遍历本核负责的每个 Tensor,从 inScalarGM 读取该 Tensor 对应的标量值,再调用 SingleTensorProcess 按 maxDataCount 分块批量处理;
  • BF16 精度处理:由于 AscendC 向量指令的幂运算 Power 支持 float/half 等类型,InnerComputer<bfloat16_t> 采用特化实现——先将 BF16 数据 Cast 到 float 计算(RoundMode::CAST_NONE),完成 Power<float> 后再以 RoundMode::CAST_RINT 舍入转回 BF16 写出,从而保证计算精度;
  • Scalar 读取:每个 Tensor 的指数通过 inScalarGM.GetValue(i) 从标量列表内存中按下标取出,浮点类型直接强转为模板类型,BF16 则转为 float 参与计算。

图模式调用

除了 aclnn 接口,该算子还支持图模式调用。通过算子 IR 中 REG_OP(ForeachPowScalarList) 注册的 DYNAMIC_INPUT(x)、INPUT(scalars)、DYNAMIC_OUTPUT(y) 构图方式即可接入 Graph 引擎,两种调用方式在 README 的"调用说明"一节中有明确对照。

测试与验证

仓库为该算子配备了完整的测试体系,可用于验证接口行为与计算正确性。

UT 单测(tests/ut/op_kernel/test_foreach_pow_scalar_list.cpp)通过 ICPU 模式直接运行 kernel:针对 float32、float16、int32 等数据类型,构造 {{128,64},{16,128},{32,128}} 三张不同 shape 的 Tensor 列表,由 gen_data.py 生成输入数据、compare_data.py 对比输出,验证各数据类型的计算结果。

ATK 系统测试(tests/st/aclnnForeachPowScalarList/executor_aclnnForeachPowScalarList.py)以 PyTorch 的 torch._foreach_pow(x, scalars) 作为对标基准,注册 function_aclnnForeachPowScalarList 执行器;atk_aclnnForeachPowScalarList.json 中声明了 200 组覆盖 fp16/fp32/bf16/int32 数据类型、从 1 维到 8 维、单 Tensor 到多 Tensor 列表、标量取值范围 0~5 的用例矩阵,例如 bf16 的 [1,3,1]、int32 的 [1,1,2] 等多维组合,从系统层面验证 aclnn 接口与 PyTorch 语义的一致性。

总结

ForeachPowScalarList 是 CANN ops-nn 中用于批量幂运算的 foreach 系列算子,通过 aclnn 两段式接口对外提供调用能力。使用时需要重点关注:输入与输出数据类型的对应关系(浮点输入配 FLOAT32 标量、INT32 输入配 INT64 标量)、指数绝对值不超过 (2^31-1) 的取值约束、输出不支持非连续 Tensor、Tensor 维度不超过 8 维,以及不同产品(尤其 Kirin 平台不支持 BF16)的能力差异。其底层通过多核 tiling 切分、UB 双缓冲流水和 BF16 升精度计算等机制保证执行效率与精度,并通过 UT 与 ATK 双层测试与 PyTorch 语义对齐。

登录后查看全文
ops-nn