aclnnEqScalar

aclnnEmbedding

接口原型

每个算子有两段接口，必须先调用“aclnnXxxGetWorkspaceSize”接口获取入参并根据计算流程计算所需workspace大小，再调用“aclnnXxx”接口执行计算。两段式接口如下：

第一段接口：aclnnStatus aclnnEmbeddingGetWorkspaceSize(const aclTensor *weight, const aclTensor *indices, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnEmbedding(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：Embedding计算是将数据集合映射到向量空间，进而将数据进行量化。

假设Embedding的二维权重矩阵为weight（m+1行、n列），对于任意输入索引张量indices（假设1行3列），输出out是一个3行n列张量。如下所示：

aclnnEmbeddingGetWorkspaceSize

接口定义：

aclnnStatus aclnnEmbeddingGetWorkspaceSize(const aclTensor *weight, const aclTensor *indices, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- weight：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、INT64、INT32、INT16、INT8、UINT8、BOOL、DOUBLE、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持），支持非连续的Tensor，数据格式支持ND。
- indices：Device侧的aclTensor，当indices值越界时，对应行的输出值为随机值。数据类型支持INT64、INT32，支持非连续的Tensor，数据格式支持ND。
- out：Device侧的aclTensor，数据类型同weight，数据格式支持ND，比indices的维度多一。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的weight、indices、out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - weight、indices、out的数据类型和数据格式不在支持的范围内。
  - indices和out的shape不满足匹配关系。
  - 入参的最大维度超过8。 :::

aclnnEmbedding

接口定义：

aclnnStatus aclnnEmbedding(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnEmbeddingGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

调用示例

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

#define CHECK_RET(cond, return_expr) \
  do &#123;                               \
    if (!(cond)) &#123;                   \
      return_expr;                   \
    &#125;                                \
  &#125; while (0)

#define LOG_PRINT(message, ...)     \
  do &#123;                              \
    printf(message, ##__VA_ARGS__); \
  &#125; while (0)

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

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，AscendCL初始化
  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 = aclrtCreateContext(context, deviceId);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret);
  ret = aclrtSetCurrentContext(*context);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext 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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

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

int main() &#123;
  // 1. （固定写法）device/context/stream初始化，参考AscendCL对外接口列表
  // 根据自己的实际device填写deviceId
  int32_t deviceId = 0;
  aclrtContext context;
  aclrtStream stream;
  auto ret = Init(deviceId, &context, &stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

  // 2. 构造输入与输出，需要根据API的接口自定义构造
  std::vector<int64_t> weightShape = &#123;10, 3&#125;;
  std::vector<int64_t> indicesShape = &#123;4&#125;;
  std::vector<int64_t> outShape = &#123;4, 3&#125;;
  void* weightDeviceAddr = nullptr;
  void* indicesDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* weight = nullptr;
  aclTensor* indices = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> weightHostData = &#123;1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,24, 25, 26, 27, 28, 29, 30&#125;;
  std::vector<int64_t> indicesHostData = &#123;1, 2, 3, 4&#125;;
  std::vector<float> outHostData = &#123;0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0&#125;;
  // 创建weight aclTensor
  ret = CreateAclTensor(weightHostData, weightShape, &weightDeviceAddr, aclDataType::ACL_FLOAT, &weight);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建indices aclTensor
  ret = CreateAclTensor(indicesHostData, indicesShape, &indicesDeviceAddr, aclDataType::ACL_INT64, &indices);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3. 调用CANN算子库API，需要修改为具体的API名称
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnEmbedding第一段接口
  ret = aclnnEmbeddingGetWorkspaceSize(weight, indices, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEmbeddingGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) &#123;
    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);
  &#125;
  // 调用aclnnEmbedding第二段接口
  ret = aclnnEmbedding(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEmbedding 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 resultData from device to host failed. ERROR: %d\n", ret);
            return ret);
  for (int64_t i = 0; i < size; i++) &#123;
    LOG_PRINT("resultData[%ld] is: %f\n", i, resultData[i]);
  &#125;

  // 6. 释放aclTensor，需要根据具体API的接口定义修改
  aclDestroyTensor(weight);
  aclDestroyTensor(indices);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnEmbeddingDenseBackward

接口原型

第一段接口：aclnnStatus aclnnEmbeddingDenseBackwardGetWorkspaceSize(const aclTensor *grad, const aclTensor *indices, uint64_t numWeights, uint64_t paddingIdx, bool scaleGradByFreq, const aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnEmbeddingDenseBackward(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：aclnnEmbedding的反向运算（Embedding正向是指将数据集合映射到向量空间，进而将数据进行量化）。

aclnnEmbeddingDenseBackwardGetWorkspaceSize

接口定义：

aclnnStatus aclnnEmbeddingDenseBackwardGetWorkspaceSize(const aclTensor *grad, const aclTensor *indices, uint64_t numWeights, uint64_t paddingIdx, bool scaleGradByFreq, const aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- grad：梯度张量，Device侧的aclTensor。数据类型支持FLOAT16、FLOAT。shape和正向输出的shape一致，支持非连续的Tensor，数据格式支持ND，比indices的维度多一维。
- indices：正向中需要映射到向量空间的索引张量，Device侧的aclTensor。数据类型支持FLOAT16、FLOAT、DOUBLE、UINT8、INT8、INT16、INT32、INT64、BOOL，实际计算时会转为INT32。支持非连续的Tensor，数据格式支持ND。
- numWeights：向量空间的大小。
- paddingIdx：填充ID，默认为None。如果指定的话，将指定位置处的向量元素全部置为0，且paddingIdx对应的参数不会对梯度产生影响。
- scaleGradByFreq：根据单词出现的频率，对梯度进行放缩，默认为False。
- out：反向输出的张量，数据类型支持FLOAT16、FLOAT32，数据格式仅支持2D。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的grad、indices、out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - grad、indices、out的数据类型和数据格式不在支持的范围内。
  - grad、indices的维度关系不匹配。 :::

aclnnEmbeddingDenseBackward

接口定义：

aclnnStatus aclnnEmbeddingDenseBackward(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnEmbeddingDenseBackwardGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

调用示例

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

#define CHECK_RET(cond, return_expr) \
  do &#123;                               \
    if (!(cond)) &#123;                   \
      return_expr;                   \
    &#125;                                \
  &#125; while (0)

#define LOG_PRINT(message, ...)     \
  do &#123;                              \
    printf(message, ##__VA_ARGS__); \
  &#125; while (0)

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

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，AscendCL初始化
  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 = aclrtCreateContext(context, deviceId);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret);
  ret = aclrtSetCurrentContext(*context);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext 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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

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

int main() &#123;
  // 1. （固定写法）device/context/stream初始化，参考AscendCL对外接口列表
  // 根据自己的实际device填写deviceId
  int32_t deviceId = 0;
  aclrtContext context;
  aclrtStream stream;
  auto ret = Init(deviceId, &context, &stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

  // 2. 构造输入与输出，需要根据API的接口自定义构造
  uint64_t numWeights = 4;
  uint64_t paddingIdx = 0;
  bool scaleGradByFreq = false;
  std::vector<int64_t> gradOutputShape = &#123;2, 3&#125;;
  std::vector<int64_t> indicesShape = &#123;2&#125;;
  std::vector<int64_t> outShape = &#123;4, 3&#125;;
  void* gradOutputDeviceAddr = nullptr;
  void* indicesDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* gradOutput = nullptr;
  aclTensor* indices = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> gradOutputHostData = &#123;1, 2, 3, 4, 5, 6&#125;;
  std::vector<int64_t> indicesHostData = &#123;1, 2&#125;;
  std::vector<float> outHostData = &#123;0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0&#125;;
  // 创建gradOutput aclTensor
  ret = CreateAclTensor(gradOutputHostData, gradOutputShape, &gradOutputDeviceAddr, aclDataType::ACL_FLOAT, &gradOutput);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建indices aclTensor
  ret = CreateAclTensor(indicesHostData, indicesShape, &indicesDeviceAddr, aclDataType::ACL_INT64, &indices);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3. 调用CANN算子库API，需要修改为具体的API名称
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnEmbeddingDenseBackward第一段接口
  ret = aclnnEmbeddingDenseBackwardGetWorkspaceSize(gradOutput, indices, numWeights, paddingIdx, scaleGradByFreq, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEmbeddingDenseBackwardGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) &#123;
    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);
  &#125;
  // 调用aclnnEmbeddingDenseBackward第二段接口
  ret = aclnnEmbeddingDenseBackward(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEmbeddingDenseBackward 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 resultData from device to host failed. ERROR: %d\n", ret);
            return ret);
  for (int64_t i = 0; i < size; i++) &#123;
    LOG_PRINT("resultData[%ld] is: %f\n", i, resultData[i]);
  &#125;

  // 6. 释放aclTensor，需要根据具体API的接口定义修改
  aclDestroyTensor(gradOutput);
  aclDestroyTensor(indices);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnEmbeddingRenorm

接口原型

第一段接口：aclnnStatus aclnnEmbeddingRenormGetWorkspaceSize**(aclTensor *selfRef, const aclTensor *indices, double maxNorm, double normType, uint64_t *workspaceSize, aclOpExecutor **executor)**
第二段接口：aclnnStatus aclnnEmbeddingRenorm(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：根据给定的maxNorm和normType计算输入张量selfRef在指定indices下的修正结果。
计算公式：

向量的范数计算公式如下，其中n为normType指定的范数值。

当计算出的范数大于给定的maxNorm，需要做归一化处理，对indices指定的0维元素乘以系数：

aclnnEmbeddingRenormGetWorkspaceSize

接口定义：

aclnnStatus aclnnEmbeddingRenormGetWorkspaceSize(aclTensor *selfRef, const aclTensor *indices, double maxNorm, double normType, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- selfRef：Device侧的aclTensor，进行renorm运算的入参，dim必须为2。数据类型支持FLOAT32、FLOAT16，数据格式支持ND，支持非连续的Tensor。
- indices：Device侧的aclTensor，selfRef中第0维上准备进行renorm计算的索引。数据类型支持INT32、INT64，数据格式支持ND，支持非连续的Tensor。
- maxNorm：指定范数的最大值，超出此值需要对embedding的结果进行归一化处理，仅支持DOUBLE类型。
- normType：指定L_P范数的类型，仅支持DOUBLE类型。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、indices是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self、indices、maxNorm、normType的数据类型和数据格式不在支持的范围内。
  - self的dim不为2。 :::

aclnnEmbeddingRenorm

接口定义：

aclnnStatus aclnnEmbeddingRenorm(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnEmbeddingRenormGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

调用示例

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

#define CHECK_RET(cond, return_expr) \
  do &#123;                               \
    if (!(cond)) &#123;                   \
      return_expr;                   \
    &#125;                                \
  &#125; while (0)

#define LOG_PRINT(message, ...)     \
  do &#123;                              \
    printf(message, ##__VA_ARGS__); \
  &#125; while (0)

int64_t GetShapeSize(const std::vector<int64_t>& shape) &#123;
  int64_t shape_size = 1;
  for (auto i : shape) &#123;
    shape_size *= i;
  &#125;
  return shape_size;
&#125;

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，AscendCL初始化
  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 = aclrtCreateContext(context, deviceId);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret);
  ret = aclrtSetCurrentContext(*context);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext 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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

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

int main() &#123;
  // 1. （固定写法）device/context/stream初始值 参考AscendCL对外接口列表
  // 根据自己的实际device填写deviceId
  int32_t deviceId = 0;
  aclrtContext context;
  aclrtStream stream;
  auto ret = Init(deviceId, &context, &stream);
  // check根据自己的需要处理
  CHECK_RET(ret == 0, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

  // 2. 构造输入与输出，需要根据API的接口自定义构造
  std::vector<int64_t> selfShape = &#123;4, 2&#125;;
  std::vector<int64_t> indicesShape = &#123;4, 2&#125;;
  void* selfDeviceAddr = nullptr;
  void* indicesDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* indices = nullptr;
  std::vector<float> selfHostData = &#123;0, 1, 2, 3, 4, 5, 6, 7&#125;;
  std::vector<int> indicesHostData = &#123;1, 1, 1, 1, 0, 0, 0, 0&#125;;
  float normType = 1.0f;
  float maxNorm = 2.0f;
  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建indices aclTensor
  ret = CreateAclTensor(indicesHostData, indicesShape, &indicesDeviceAddr, aclDataType::ACL_INT32, &indices);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3.调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnEmbeddingRenorm第一段接口
  ret = aclnnEmbeddingRenormGetWorkspaceSize(self, indices, maxNorm, normType, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEmbeddingRenormGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) &#123;
    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;);
  &#125;
  // 调用aclnnEmbeddingRenorm第二段接口
  ret = aclnnEmbeddingRenorm(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEmbeddingRenorm 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(selfShape);
  std::vector<float> resultData(size, 0);
  ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), selfDeviceAddr, size * sizeof(float),
                    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++) &#123;
    LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]);
  &#125;

  // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyTensor(indices);
  return 0;
&#125;

父主题： NN类算子接口

aclnnEqScalar

接口原型

第一段接口：aclnnStatus aclnnEqScalarGetWorkspaceSize(const aclTensor *self, const aclScalar *other, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnEqScalar(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：比较张量self与张量other中的元素值是否相等，并将比较结果写入out中。
计算公式：

aclnnEqScalarGetWorkspaceSize

接口定义：

aclnnStatus aclnnEqScalarGetWorkspaceSize(const aclTensor *self, const aclScalar *other, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、INT64、UINT64、INT32、INT8、UINT8、BOOL、UINT32、BFLOAT16（仅Atlas A2训练系列产品支持）、DOUBLE、INT16、COMPLEX64、COMPLEX128数据类型，数据格式支持ND。
- other：Host侧的aclScalar，数据类型支持FLOAT16、FLOAT、INT64、UINT64、INT32、INT8、UINT8、BOOL、UINT32、BFLOAT16（仅Atlas A2训练系列产品支持）、DOUBLE、INT16、COMPLEX64、COMPLEX128数据类型。
- out：Device侧的aclTensor，数据类型为BOOL，shape与self的shape一致，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、other、out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self和other的数据类型不在支持的范围内。
  - self和out的shape不一致。 :::

aclnnEqScalar

接口定义：

aclnnStatus aclnnEqScalar(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnEqScalarGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

调用示例

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

#define CHECK_RET(cond, return_expr) \
 do &#123;                                \
  if (!(cond)) &#123;                     \
    return_expr;                     \
  &#125;                                  \
 &#125; while(0)

#define LOG_PRINT(message, ...)   \
 do &#123;                             \
  printf(message, ##__VA_ARGS__); \
 &#125; while(0)

int64_t GetShapeSize(const std::vector<int64_t>& shape) &#123;
  int64_t shape_size = 1;
  for (auto i : shape) &#123;
    shape_size *= i;
  &#125;
  return shape_size;
&#125;

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，AscendCL初始化
  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 = aclrtCreateContext(context, deviceId);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret);
  ret = aclrtSetCurrentContext(*context);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext 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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

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

int main() &#123;
  // 1. （固定写法）device/context/stream初始化, 参考AscendCL对外接口列表
  // 根据自己的实际device填写deviceId
  int32_t deviceId = 0;
  aclrtContext context;
  aclrtStream stream;
  auto ret = Init(deviceId, &context, &stream);
  CHECK_RET(ret == 0, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

  // 2. 构造输入与输出，需要根据API的接口自定义构造
  std::vector<int64_t> selfShape = &#123;4, 2&#125;;
  std::vector<int64_t> outShape = &#123;4, 2&#125;;
  void* selfDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclScalar* other = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = &#123;0, 1, 1.2, 0.3, 4.1, 5, 1.6, 7&#125;;
  std::vector<char> outHostData = &#123;0, 0, 0, 0, 0, 0, 0, 0&#125;;
  float otherValue = 1.2f;
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  other = aclCreateScalar(&otherValue, aclDataType::ACL_FLOAT);
  CHECK_RET(other != nullptr, return ret);
  ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_BOOL, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3.调用CANN算子库API，需要修改为具体的算子接口 
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  ret = aclnnEqScalarGetWorkspaceSize(self, other, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEqScalarGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) &#123;
    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);
  &#125;
  ret = aclnnEqScalar(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEqScalar 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<char> resultData(size, 0);
  ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr, size * sizeof(char), 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++) &#123;
    LOG_PRINT("result[%ld] is: %d\n", i, resultData[i]);
  &#125;

  // 6. 释放aclTensor，需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnEqTensor

接口原型

第一段接口：aclnnStatus aclnnEqTensorGetWorkspaceSize(const aclTensor *self, const aclTensor *other, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnEqTensor(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：比较两个张量的元素是否相等，返回一个Bool类型张量。
计算公式：

aclnnEqTensorGetWorkspaceSize

接口定义：

aclnnStatus aclnnEqTensorGetWorkspaceSize(const aclTensor *self, const aclTensor *other, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self: Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、INT64、INT32、INT8、UINT8、BOOL、BFLOAT16（仅Atlas A2训练系列产品支持）、DOUBLE、INT16、COMPLEX64、COMPLEX128，shape需要与other满足broadcast关系，数据类型需要与other满足互推导关系，支持非连续的Tensor，数据格式支持ND。
- other: Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、INT64、INT32、INT8、UINT8、BOOL、BFLOAT16（仅Atlas A2训练系列产品支持）、DOUBLE、INT16、COMPLEX64、COMPLEX128，shape需要与self满足broadcast关系，数据类型需要与other满足互推导关系，支持非连续的Tensor，数据格式支持ND。
- out: Device侧的aclTensor，输出一个数据类型为BOOL类型的张量，数据格式支持ND。
- workspaceSize: 返回用户需要在Device侧申请的workspace大小。
- executor: 返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、other、out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self和other的数据类型不在支持的范围内。
  - self和other的shape无法做broadcast。
  - self、other、out的维度大于8。 :::

aclnnEqTensor

接口定义：

aclnnStatus aclnnEqTensor(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnEqTensorGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

调用示例

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

#define CHECK_RET(cond, return_expr) \
  do &#123;                               \
    if (!(cond)) &#123;                   \
      return_expr;                   \
    &#125;                                \
  &#125; while (0)

#define LOG_PRINT(message, ...)     \
  do &#123;                              \
    printf(message, ##__VA_ARGS__); \
  &#125; while (0)

int64_t GetShapeSize(const std::vector<int64_t>& shape) &#123;
  int64_t shape_size = 1;
  for (auto i : shape) &#123;
    shape_size *= i;
  &#125;
  return shape_size;
&#125;

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，AscendCL初始化
  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 = aclrtCreateContext(context, deviceId);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret);
  ret = aclrtSetCurrentContext(*context);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext 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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

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

int main() &#123;
  // 1. （固定写法）device/context/stream初始化, 参考AscendCL对外接口列表
  // 根据自己的实际device填写deviceId
  int32_t deviceId = 0;
  aclrtContext context;
  aclrtStream stream;
  auto ret = Init(deviceId, &context, &stream);
  // check根据自己的需要处理
  CHECK_RET(ret == 0, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

  // 2. 构造输入与输出，需要根据API的接口自定义构造
  std::vector<int64_t> selfShape = &#123;4, 2&#125;;
  std::vector<int64_t> otherShape = &#123;4, 2&#125;;
  std::vector<int64_t> outShape = &#123;4, 2&#125;;
  void* selfDeviceAddr = nullptr;
  void* otherDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* other = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = &#123;0, 1, 2, 3, 4, 5, 6, 7&#125;;
  std::vector<float> otherHostData = &#123;0, 1, 9, 9, 9, 9, 9, 9&#125;;
  std::vector<char> outHostData = &#123;0, 0, 0, 0, 0, 0, 0, 0&#125;;
  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建other aclTensor
  ret = CreateAclTensor(otherHostData, otherShape, &otherDeviceAddr, aclDataType::ACL_FLOAT, &other);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_BOOL, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3.调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnEqTensor第一段接口
  ret = aclnnEqTensorGetWorkspaceSize(self, other, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEqTensorGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) &#123;
    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;);
  &#125;
  // 调用aclnnEqTensor第二段接口
  ret = aclnnEqTensor(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEqTensor 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<char> resultData(size, 0);
  ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr, size * sizeof(char), 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++) &#123;
    LOG_PRINT("result[%ld] is: %d\n", i, resultData[i]);
  &#125;

  // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyTensor(other);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnEqual

接口原型

第一段接口：aclnnStatus aclnnEqualGetWorkspaceSize(const aclTensor *self, const aclTensor *other, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnEqual(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：计算两个张量是否有相同的大小和元素，返回一个Bool类型。
计算公式：

aclnnEqualGetWorkspaceSize

接口定义：

aclnnStatus aclnnEqualGetWorkspaceSize(const aclTensor *self, const aclTensor *other, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self: Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、INT32、INT8、UINT8、BOOL、DOUBLE、INT64、INT16、UINT16、UINT32、UINT64，数据类型需要与other满足互推导关系，支持非连续的Tensor，数据格式支持ND。
- other: Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、INT32、INT8、UINT8、BOOL、DOUBLE、INT64、INT16、UINT16、UINT32、UINT64，数据类型需要与self满足互推导关系，支持非连续的Tensor，数据格式支持ND。
- out: 输出一个数据类型为BOOL类型，一维包含一个元素的Tensor。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、other是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self和other的数据类型不在支持的范围内。
  - self、other、out的维度大于8。 :::

aclnnEqual

接口定义：

aclnnStatus aclnnEqual(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnEqualGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

调用示例

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

#define CHECK_RET(cond, return_expr) \
  do &#123;                               \
    if (!(cond)) &#123;                   \
      return_expr;                   \
    &#125;                                \
  &#125; while (0)

#define LOG_PRINT(message, ...)     \
  do &#123;                              \
    printf(message, ##__VA_ARGS__); \
  &#125; while (0)

int64_t GetShapeSize(const std::vector<int64_t>& shape) &#123;
  int64_t shape_size = 1;
  for (auto i : shape) &#123;
    shape_size *= i;
  &#125;
  return shape_size;
&#125;

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，AscendCL初始化
  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 = aclrtCreateContext(context, deviceId);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret);
  ret = aclrtSetCurrentContext(*context);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext 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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

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

int main() &#123;
  // 1. （固定写法）device/context/stream初始化, 参考AscendCL对外接口列表
  // 根据自己的实际device填写deviceId
  int32_t deviceId = 0;
  aclrtContext context;
  aclrtStream stream;
  auto ret = Init(deviceId, &context, &stream);
  // check根据自己的需要处理
  CHECK_RET(ret == 0, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

  // 2. 构造输入与输出，需要根据API的接口自定义构造
  std::vector<int64_t> selfShape = &#123;4, 2&#125;;
  std::vector<int64_t> otherShape = &#123;4, 2&#125;;
  std::vector<int64_t> outShape = &#123;1&#125;;
  void* selfDeviceAddr = nullptr;
  void* otherDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* other = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = &#123;0, 1, 2, 3, 4, 5, 6, 7&#125;;
  std::vector<float> otherHostData = &#123;0, 1, 2, 3, 4, 5, 6, 7&#125;;
  std::vector<char> outHostData = &#123;0&#125;;
  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建other aclTensor
  ret = CreateAclTensor(otherHostData, otherShape, &otherDeviceAddr, aclDataType::ACL_FLOAT, &other);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_BOOL, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3.调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnEqual第一段接口
  ret = aclnnEqualGetWorkspaceSize(self, other, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEqualGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) &#123;
    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;);
  &#125;
  // 调用aclnnEqual第二段接口
  ret = aclnnEqual(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEqual 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<char> resultData(size, 0);
  ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr, size * sizeof(char), 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++) &#123;
    LOG_PRINT("result[%ld] is: %d\n", i, resultData[i]);
  &#125;

  // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyTensor(other);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnErf/aclnnInplaceErf

接口原型

:::note 说明

aclnnErf和aclnnInplaceErf实现相同的功能，其使用区别如下，请根据自身实际场景选择合适的算子。
- aclnnErf：需新建一个输出张量对象存储计算结果。
- aclnnInplaceErf：无需新建输出张量对象，直接在输入张量的内存中存储计算结果。
每个算子分为两段接口，必须先调用“aclnnXxxGetWorkspaceSize”接口获取入参并根据计算流程计算所需workspace大小，再调用“aclnnXxx”接口执行计算。 :::
aclnnErf两段式接口如下：
- **第一段接口：**aclnnStatus aclnnErfGetWorkspaceSize(const aclTensor *self, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
- **第二段接口：**aclnnStatus aclnnErf(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
aclnnInplaceErf两段式接口如下：
- **第一段接口：**aclnnStatus aclnnInplaceErfGetWorkspaceSize(const aclTensor *selfRef, uint64_t *workspaceSize, aclOpExecutor **executor)
- **第二段接口：**aclnnStatus aclnnInplaceErf(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：计算张量中每个元素的误差函数值。
计算公式：

aclnnErfGetWorkspaceSize

接口定义：

aclnnStatus aclnnErfGetWorkspaceSize(const aclTensor *self, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，输入张量。数据类型支持FLOAT64、FLOAT32、FLOAT16、BOOL，数据格式支持ND，shape必须和out一样，支持非连续的Tensor。
- out：Device侧的aclTensor，输出张量。数据类型支持FLOAT64、FLOAT32、FLOAT16，数据格式支持ND，shape必须和self一样，支持非连续的Tensor。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self和out的数据类型和数据格式不在支持的范围内。
  - self和out的shape不一致。 :::

aclnnErf

接口定义：

aclnnStatus aclnnErf(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnErfGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

aclnnInplaceErfGetWorkspaceSize

接口定义：

aclnnStatus aclnnInplaceErfGetWorkspaceSize(const aclTensor *selfRef, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- selfRef：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT32、FLOAT64。支持非连续的Tensor，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的selfRef是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：selfRef的数据类型和数据格式不在支持的范围内。 :::

aclnnInplaceErf

接口定义：

aclnnStatus aclnnInplaceErf(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnInplaceErfGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码。

调用示例

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

#define CHECK_RET(cond, return_erfr) \
  do &#123;                               \
    if (!(cond)) &#123;                   \
      return_erfr;                   \
    &#125;                                \
  &#125; while (0)

#define LOG_PRINT(message, ...)     \
  do &#123;                              \
    printf(message, ##__VA_ARGS__); \
  &#125; while (0)

int64_t GetShapeSize(const std::vector<int64_t>& shape) &#123;
  int64_t shape_size = 1;
  for (auto i : shape) &#123;
    shape_size *= i;
  &#125;
  return shape_size;
&#125;

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，AscendCL初始化
  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 = aclrtCreateContext(context, deviceId);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret);
  ret = aclrtSetCurrentContext(*context);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext 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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

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

int main() &#123;
  // 1. （固定写法）device/context/stream初始化, 参考AscendCL对外接口列表
  // 根据自己的实际device填写deviceId
  int32_t deviceId = 0;
  aclrtContext context;
  aclrtStream stream;
  auto ret = Init(deviceId, &context, &stream);
  // check根据自己的需要处理
  CHECK_RET(ret == 0, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

  // 2. 构造输入与输出，需要根据API的接口自定义构造
  std::vector<int64_t> selfShape = &#123;2, 2&#125;;
  std::vector<int64_t> outShape = &#123;2, 2&#125;;
  void* selfDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = &#123;0, 1, 2, 3&#125;;
  std::vector<float> outHostData = &#123;0, 0, 0, 0&#125;;
  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3.调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnErf第一段接口
  ret = aclnnErfGetWorkspaceSize(self, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnErfGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) &#123;
    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;);
  &#125;
  std::cout << "aclnnErf 1ok" << std::endl;
  // 调用aclnnErf第二段接口
  ret = aclnnErf(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnErf failed. ERROR: %d\n", ret); return ret);
  uint64_t inplaceWorkspaceSize = 0;
  aclOpExecutor* inplaceExecutor;
  // 调用aclnnInplaceErf第一段接口
  ret = aclnnInplaceErfGetWorkspaceSize(self, &inplaceWorkspaceSize, &inplaceExecutor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceErfGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* inplaceWorkspaceAddr = nullptr;
  if (inplaceWorkspaceAddr > 0) &#123;
    ret = aclrtMalloc(&inplaceWorkspaceAddr, inplaceWorkspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret;);
  &#125;
  // 调用aclnnInplaceErf第二段接口
  ret = aclnnInplaceErf(inplaceWorkspaceAddr, inplaceWorkspaceSize, inplaceExecutor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceErf 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(float), 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++) &#123;
    LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]);
  &#125;
  auto inplaceSize = GetShapeSize(selfShape);
  std::vector<float> inplaceResultData(inplaceSize, 0);
  ret = aclrtMemcpy(inplaceResultData.data(), inplaceResultData.size() * sizeof(inplaceResultData[0]), selfDeviceAddr, inplaceSize * sizeof(float), 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 < inplaceSize; i++) &#123;
    LOG_PRINT("inplaceResult[%ld] is: %f\n", i, inplaceResultData[i]);
  &#125;

  // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

在线提单

aclnnEmbedding​

接口原型​

功能描述​

aclnnEmbeddingGetWorkspaceSize​

aclnnEmbedding​

调用示例​

aclnnEmbeddingDenseBackward​

接口原型​

功能描述​

aclnnEmbeddingDenseBackwardGetWorkspaceSize​

aclnnEmbeddingDenseBackward​

调用示例​

aclnnEmbeddingRenorm​

接口原型​

功能描述​

aclnnEmbeddingRenormGetWorkspaceSize​

aclnnEmbeddingRenorm​

调用示例​

aclnnEqScalar​

接口原型​

功能描述​

aclnnEqScalarGetWorkspaceSize​

aclnnEqScalar​

调用示例​

aclnnEqTensor​

接口原型​

功能描述​

aclnnEqTensorGetWorkspaceSize​

aclnnEqTensor​

调用示例​

aclnnEqual​

接口原型​

功能描述​

aclnnEqualGetWorkspaceSize​

aclnnEqual​

调用示例​

aclnnErf/aclnnInplaceErf​

接口原型​

功能描述​

aclnnErfGetWorkspaceSize​

aclnnErf​

aclnnInplaceErfGetWorkspaceSize​

aclnnInplaceErf​

调用示例​

aclnnEmbedding

接口原型

功能描述

aclnnEmbeddingGetWorkspaceSize

aclnnEmbedding

调用示例

aclnnEmbeddingDenseBackward

接口原型

功能描述

aclnnEmbeddingDenseBackwardGetWorkspaceSize

aclnnEmbeddingDenseBackward

调用示例

aclnnEmbeddingRenorm

接口原型

功能描述

aclnnEmbeddingRenormGetWorkspaceSize

aclnnEmbeddingRenorm

调用示例

aclnnEqScalar

接口原型

功能描述

aclnnEqScalarGetWorkspaceSize

aclnnEqScalar

调用示例

aclnnEqTensor

接口原型

功能描述

aclnnEqTensorGetWorkspaceSize

aclnnEqTensor

调用示例

aclnnEqual

接口原型

功能描述

aclnnEqualGetWorkspaceSize

aclnnEqual

调用示例

aclnnErf/aclnnInplaceErf

接口原型

功能描述

aclnnErfGetWorkspaceSize

aclnnErf

aclnnInplaceErfGetWorkspaceSize

aclnnInplaceErf

调用示例