aclnnNormalFloatTensor

aclnnNonzero

接口原型

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

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

功能描述

算子功能：按行优先排列返回张量self中非0元素索引的张量。

aclnnNonzeroGetWorkspaceSize

接口定义：

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

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

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

aclnnNonzero

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_nonzero.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> selfShape = &#123;4, 2&#125;;
  std::vector<int64_t> outShape = &#123;7, 2&#125;;
  void* selfDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = &#123;0, 1, 2, 3, 4, 5, 6, 7&#125;;
  std::vector<int64_t> outHostData(14, 0);
  // 创建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_INT64, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3. 调用CANN算子库API，需要修改为具体的API名称
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnNonzero第一段接口
  ret = aclnnNonzeroGetWorkspaceSize(self, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNonzeroGetWorkspaceSize 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;
  // 调用aclnnNonzero第二段接口
  ret = aclnnNonzero(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNonzero 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<int64_t> 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++) &#123;
    LOG_PRINT("result[%ld] is: %ld\n", i, resultData[i]);
  &#125;

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

父主题： NN类算子接口

aclnnNorm

接口原型

**第一段接口：**aclnnStatus aclnnNormGetWorkspaceSize(const aclTensor *self, const aclScalar *p, const aclIntArray* dim, bool keepDim，aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnNorm(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：计算张量的矩阵范数或向量范数。
计算公式：
- 1-范数：
- 2-范数：
- 无穷-范数
常见的矩阵范数除了1、2范数和无穷范数之外，还包括F范数（表示矩阵元素绝对值的平方和再开平方）、核范数（表示所有矩阵行向量绝对值之和的最大值）等数学范数。

aclnnNormGetWorkspaceSize

接口定义：

aclnnStatus aclnnNormGetWorkspaceSize(const aclTensor *self, const aclScalar *p, const aclIntArray* dim, bool keepDim，aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、BFLOAT16（仅Atlas A2训练系列产品支持）、DOUBLE、COMPLEX64、COMPLEX128。支持非连续的Tensor，数据格式支持ND。
- p：Host侧的aclScalar，范数类型，数据类型仅支持INT32。
- dim：指定要计算范数的维度，Host侧的aclIntArray，数据类型支持INT32。如果dim为None，将在self的所有维度上计算范数。
- keepDim：输出张量是否保留dim，Host侧的aclScalar。当dim=None和out=None则忽略。默认值为False，数据类型支持BOOL。
- out：表示输出张量，Device侧的aclTensor。数据类型支持FLOAT、FLOAT16、BFLOAT16（仅Atlas A2训练系列产品支持）、DOUBLE、COMPLEX64、COMPLEX128，数据格式支持ND，且数据格式需要与self一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self的数据类型和数据格式不在支持的范围内。
  - 推导出的数据类型无法转换为指定输出out的类型。
  - p、dim和keepDim的数据类型和数据格式不符合入参要求。 :::

aclnnNorm

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_norm.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> outShape = &#123;1, 2&#125;;
  void* selfDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* out = nullptr;
  aclScalar* pScalar = nullptr;
  aclIntArray* dim = nullptr;
  std::vector<float> selfHostData = &#123;0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1&#125;;
  std::vector<float> outHostData = &#123;0.0, 0.0&#125;;
  std::vector<int64_t> dimData = &#123;0&#125;;
  float pValue = 0.0f;
  bool keepDim = true;
  // 创建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);
  // 创建p aclScalar
  pScalar = aclCreateScalar(&pValue, aclDataType::ACL_FLOAT);
  CHECK_RET(pScalar != nullptr, return ret);
  // 创建dim aclIntArray
  dim = aclCreateIntArray(dimData.data(), 1);
  CHECK_RET(dim != nullptr, return ret);

  // 3.调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnNormGetWorkspaceSize第一段接口
  ret = aclnnNormGetWorkspaceSize(self, pScalar, dim, keepDim, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormGetWorkspaceSize 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;
  // 调用aclnnNorm第二段接口
  ret = aclnnNorm(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNorm 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;

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

父主题： NN类算子接口

aclnnNormalFloatFloat

接口原型

**第一段接口：**aclnnStatus aclnnNormalFloatFloatGetWorkspaceSize(float mean, float std, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnNormalFloatFloat(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：生成随机数张量，该随机数是从给定的均值（float）和标准差（float）的独立正态分布中获取。

aclnnNormalFloatFloatGetWorkspaceSize

接口定义：

aclnnStatus aclnnNormalFloatFloatGetWorkspaceSize(float mean, float std, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- mean：计算输入，生成随机数分布的均值，数据类型支持FLOAT。
- std：计算输入，生成随机数分布的方差，数据类型支持FLOAT。
- seed：计算输入，采样伪随机数生成器的种子值，数据类型支持INT64。
- offset：计算输入，采样伪随机数生成器的的偏移量，数据类型支持INT64。
- out：Device侧的aclTensor，输出张量，数据类型支持FLOAT16、FLOAT32、DOUBLE，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - 传入的mean和std的数据类型不在支持的范围之内。
  - 推导出的数据类型无法转换为指定输出out的类型。
  - seed和offset的数据类型和取值范围不符合接口入参要求。 :::

aclnnNormalFloatFloat

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_normal_v2.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> outShape = &#123;1, 4&#125;;
  void* outDeviceAddr = nullptr;
  aclTensor* out= nullptr;
  std::vector<float> outHostData = &#123;0.0, 0.0, 0.0, 0.0&#125;;
  float mean = 3.2f;
  float std = 1.2f;
  int64_t seed = 1;
  int64_t offset = 1;
  // 创建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;
  // 调用aclnnNormalFloatFloat第一段接口
  ret = aclnnNormalFloatFloatGetWorkspaceSize(mean, std, seed, offset, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormalFloatFloatGetWorkspaceSize 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;
  // 调用aclnnNormalFloatFloat第二段接口
  ret = aclnnNormalFloatFloat(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormalFloatFloat 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侧
  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;

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

父主题： NN类算子接口

aclnnNormalFloatTensor

接口原型

**第一段接口：**aclnnStatus aclnnNormalFloatTensorGetWorkspaceSize(float mean, const aclTensor *std, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnNormalFloatTensor(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：生成随机数张量，该随机数是从给定的均值（float）和标准差（tensor）的独立正态分布中获取。

aclnnNormalFloatTensorGetWorkspaceSize

接口定义：

aclnnStatus aclnnNormalFloatTensorGetWorkspaceSize(float mean, const aclTensor *std, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- mean：计算输入，生成随机数分布的均值，数据类型支持FLOAT。
- std：计算输入，Device侧的aclTensor，生成随机数分布方差的张量，数据类型支持FLOAT16、FLOAT32、DOUBLE。数据格式支持ND，张量中元素总数和均值元素需保持一致。
- seed：计算输入，采样伪随机数生成器的种子值，数据类型支持INT64，数据格式支持ND。需要满足step不等于0。
- offset：计算输入，采样伪随机数生成器的的偏移量，数据类型支持INT64，数据格式支持ND。
- out：Device侧的aclTensor，输出张量，数据类型支持FLOAT16、FLOAT32、DOUBLE，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的std或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - 传入的mean和std的数据类型不在支持的范围之内。
  - 推导出的数据类型无法转换为指定输出out的类型。
  - mean、seed和offset的数据类型和取值范围不符合接口入参要求。 :::

aclnnNormalFloatTensor

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_normal_v2.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> stdShape = &#123;1, 4&#125;;
  std::vector<int64_t> outShape = &#123;1, 4&#125;;
  void* stdDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* std= nullptr;
  aclTensor* out= nullptr;
  std::vector<float> stdHostData = &#123;1.1, 1.2, 1.3, 1.4&#125;;
  std::vector<float> outHostData = &#123;0.0, 0.0, 0.0, 0.0&#125;;
  float mean = 1.2f;
  int64_t seed = 1;
  int64_t offset = 1;
  // 创建self aclTensor
  ret = CreateAclTensor(stdHostData , stdShape , &stdDeviceAddr , aclDataType::ACL_FLOAT, &std);
  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;
  // 调用aclnnNormalFloatTensor第一段接口
  ret = aclnnNormalFloatTensorGetWorkspaceSize(mean, std, seed, offset, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormalFloatTensorGetWorkspaceSize 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;
  // 调用aclnnNormalFloatTensor第二段接口
  ret = aclnnNormalFloatTensor(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormalFloatTensor 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侧
  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;

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

父主题： NN类算子接口

aclnnNormalTensorFloat

接口原型

**第一段接口：**aclnnStatus aclnnNormalTensorFloatGetWorkspaceSize(const aclTensor *mean, float std, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnNormalTensorFloat(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：生成随机数张量，该随机数是从给定的均值（tensor）和标准差（float）的独立正态分布中获取。

aclnnNormalTensorFloatGetWorkspaceSize

接口定义：

aclnnStatus aclnnNormalTensorFloatGetWorkspaceSize(const aclTensor *mean, float std, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- mean：计算输入，Device侧的aclTensor，生成随机数分布均值的张量，数据类型支持FLOAT16、FLOAT32、DOUBLE，数据格式支持ND。
- std：计算输入，生成随机数分布的方差，数据类型支持FLOAT。
- seed：计算输入，采样伪随机数生成器的种子值，数据类型支持INT64。
- offset：计算输入，采样伪随机数生成器的的偏移量，数据类型支持INT64。
- out：Device侧的aclTensor，输出张量，数据类型支持FLOAT16、FLOAT32、DOUBLE，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的mean或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - 传入的mean的数据类型不在支持的范围之内。
  - 推导出的数据类型无法转换为指定输出out的类型。
  - std、seed和offset的数据类型和取值范围不符合接口入参要求。 :::

aclnnNormalTensorFloat

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_normal_v2.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> meanShape = &#123;1, 4&#125;;
  std::vector<int64_t> outShape = &#123;1, 4&#125;;
  void* meanDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* mean= nullptr;
  aclTensor* out= nullptr;
  std::vector<float> meanHostData = &#123;0.5, 1.5, 2.5, 3.5&#125;;
   std::vector<float> outHostData = &#123;0.0, 0.0, 0.0, 0.0&#125;;
   float std = 1.2f;
   int64_t seed = 1;
   int64_t offset = 2;
   // 创建self aclTensor
   ret = CreateAclTensor(meanHostData , meanShape , &meanDeviceAddr , aclDataType::ACL_FLOAT, &mean);
   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;
  // 调用aclnnNormalTensorFloat第一段接口
  ret = aclnnNormalTensorFloatGetWorkspaceSize(mean, std, seed, offset, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormalTensorFloatGetWorkspaceSize 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;
  // 调用aclnnNormalTensorFloat第二段接口
  ret = aclnnNormalTensorFloat(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormalTensorFloat 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侧
  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;

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

父主题： NN类算子接口

aclnnNormalTensorTensor

接口原型

**第一段接口：**aclnnStatus aclnnNormalTensorTensorGetWorkspaceSize(const aclTensor *mean, const aclTensor *std, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnNormalTensorTensor(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：生成随机数张量，该随机数是从给定的均值（tensor）和标准差（tensor）的独立正态分布中获取。

aclnnNormalTensorTensorGetWorkspaceSize

接口定义：

aclnnStatus aclnnNormalTensorTensorGetWorkspaceSize(const aclTensor *mean, const aclTensor *std, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- mean：计算输入，Device侧的aclTensor，生成随机数分布均值的张量，数据类型支持FLOAT16、FLOAT32、DOUBLE，数据格式支持ND。其中，张量中元素总数和方差元素需保持一致。
- std：计算输入，Device侧的aclTensor，生成随机数分布方差的张量，数据类型支持FLOAT16、FLOAT32、DOUBLE，数据格式支持ND。其中，张量中元素总数和均值元素需保持一致。
- seed：计算输入，采样伪随机数生成器的种子值，数据类型支持INT64。
- offset：计算输入，采样伪随机数生成器的的偏移量，数据类型支持INT64。
- out：Device侧的aclTensor，输出张量，数据类型支持FLOAT16、FLOAT32、DOUBLE，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的mean、std或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - 传入的mean和std数据类型不在支持的范围之内。
  - 推导出的数据类型无法转换为指定输出out的类型。
  - seed和offset的数据类型和取值范围不符合接口入参要求。 :::

aclnnNormalTensorTensor

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_normal_v2.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> meanShape = &#123;1, 4&#125;;
  std::vector<int64_t> stdShape = &#123;1, 4&#125;;
  std::vector<int64_t> outShape = &#123;1, 4&#125;;
  void* meanDeviceAddr = nullptr;
  void* stdDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* mean= nullptr;
  aclTensor* std= nullptr;
  aclTensor* out= nullptr;
  std::vector<float> meanHostData = &#123;0.1, 1.1, 2.1, 3.1&#125;;
  std::vector<float> stdHostData = &#123;1.1, 1.2, 1.3, 1.4&#125;;
  std::vector<float> outHostData = &#123;0.0, 0.0, 0.0, 0.0&#125;;
  int64_t seed = 1;
  int64_t offset = 1;
   // 创建self aclTensor
   ret = CreateAclTensor(meanHostData , meanShape , &meanDeviceAddr , aclDataType::ACL_FLOAT, &mean);
   CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建self aclTensor
  ret = CreateAclTensor(stdHostData, stdShape, &stdDeviceAddr, aclDataType::ACL_FLOAT, &std);
  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;
  // 调用aclnnNormalTensorTensor第一段接口
  ret = aclnnNormalTensorTensorGetWorkspaceSize(mean, std, seed, offset,  out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormalTensorTensorGetWorkspaceSize 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;
  // 调用aclnnNormalTensorTensor第二段接口
  ret = aclnnNormalTensorTensor(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormalTensorTensor 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侧
  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;

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

父主题： NN类算子接口

aclnnOneHot

接口原型

**第一段接口：**aclnnStatus aclnnOneHotGetWorkspaceSize(const aclTensor *self, int64_t numClasses, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnOneHot(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：于长度为n的输入self，经过OneHot计算后得到一个大小为[n∗k]的输出out，其中k的值等于numClasses。
计算公式：

示例：

self = tensor([0, 1, 2, 0, 1])  
out = aclnnOneHot(self, 5)
# numClasses=5，输出结果如下  
tensor([[1, 0, 0, 0, 0],       
        [0, 1, 0, 0, 0],       
        [0, 0, 1, 0, 0],       
        [1, 0, 0, 0, 0],       
        [0, 1, 0, 0, 0]])

aclnnOneHotGetWorkspaceSize

接口定义：

aclnnStatus aclnnOneHotGetWorkspaceSize(const aclTensor *self, int64_t numClasses, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持INT32、INT64，支持非连续的Tensor，数据格式支持ND。
- numClasses：Host侧整型，类别数，数据类型支持INT64，最小值为-1。如果self存在元素大于numClasses，这些元素会被编码成全0的Tensor。
- out：Device侧的aclTensor，数据类型支持INT32、INT64。支持非连续的Tensor，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnOneHot

接口定义：

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

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

调用示例

#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_one_hot.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;;
    int64_t numClasses = 4;
    std::vector<int64_t> outShape = &#123;4, 2, 4&#125;;
    void *selfDeviceAddr = nullptr;
    void *outDeviceAddr = nullptr;
    aclTensor *self = nullptr;
    aclTensor *out = nullptr;
    std::vector<long int> selfHostData = &#123;0, 1, 2, 3, 3, 2, 1, 0&#125;;
    std::vector<long int> outHostData = &#123;
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0&#125;;
    // 创建self aclTensor
    ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_INT64, &self);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // 创建out aclTensor
    ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_INT64, &out);
    CHECK_RET(ret == ACL_SUCCESS, return ret);

    // 3.调用CANN算子库API，需要修改为具体的算子接口
    uint64_t workspaceSize = 0;
    aclOpExecutor *executor;
    // 调用aclnnOneHot第一段接口
    ret = aclnnOneHotGetWorkspaceSize(self, numClasses, out, &workspaceSize, &executor);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnOneHotGetWorkspaceSize 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;
    // 调用aclnnOneHot第二段接口
    ret = aclnnOneHot(workspaceAddr, workspaceSize, executor, stream);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnOneHot 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<long int> resultData(size, 0);
    ret = aclrtMemcpy(resultData.data(),
        resultData.size() * sizeof(resultData[0]),
        outDeviceAddr,
        size * sizeof(long int),
        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: %ld\n", i, resultData[i]);
    &#125;

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

    // 7. 释放device资源，需要根据具体API的接口定义修改
    aclrtFree(selfDeviceAddr);
    aclrtFree(outDeviceAddr);
    if (workspaceSize > 0) &#123;
        aclrtFree(workspaceAddr);
    &#125;
    aclrtDestroyStream(stream);
    aclrtDestroyContext(context);
    aclrtResetDevice(deviceId);
    aclFinalize();
    return 0;
&#125;

父主题： NN类算子接口

在线提单

aclnnNonzero​

接口原型​

功能描述​

aclnnNonzeroGetWorkspaceSize​

aclnnNonzero​

调用示例​

aclnnNorm​

接口原型​

功能描述​

aclnnNormGetWorkspaceSize​

aclnnNorm​

调用示例​

aclnnNormalFloatFloat​

接口原型​

功能描述​

aclnnNormalFloatFloatGetWorkspaceSize​

aclnnNormalFloatFloat​

调用示例​

aclnnNormalFloatTensor​

接口原型​

功能描述​

aclnnNormalFloatTensorGetWorkspaceSize​

aclnnNormalFloatTensor​

调用示例​

aclnnNormalTensorFloat​

接口原型​

功能描述​

aclnnNormalTensorFloatGetWorkspaceSize​

aclnnNormalTensorFloat​

调用示例​

aclnnNormalTensorTensor​

接口原型​

功能描述​

aclnnNormalTensorTensorGetWorkspaceSize​

aclnnNormalTensorTensor​

调用示例​

aclnnOneHot​

接口原型​

功能描述​

aclnnOneHotGetWorkspaceSize​

aclnnOneHot​

调用示例​

aclnnNonzero

接口原型

功能描述

aclnnNonzeroGetWorkspaceSize

aclnnNonzero

调用示例

aclnnNorm

接口原型

功能描述

aclnnNormGetWorkspaceSize

aclnnNorm

调用示例

aclnnNormalFloatFloat

接口原型

功能描述

aclnnNormalFloatFloatGetWorkspaceSize

aclnnNormalFloatFloat

调用示例

aclnnNormalFloatTensor

接口原型

功能描述

aclnnNormalFloatTensorGetWorkspaceSize

aclnnNormalFloatTensor

调用示例

aclnnNormalTensorFloat

接口原型

功能描述

aclnnNormalTensorFloatGetWorkspaceSize

aclnnNormalTensorFloat

调用示例

aclnnNormalTensorTensor

接口原型

功能描述

aclnnNormalTensorTensorGetWorkspaceSize

aclnnNormalTensorTensor

调用示例

aclnnOneHot

接口原型

功能描述

aclnnOneHotGetWorkspaceSize

aclnnOneHot

调用示例