aclnnRepeatInterleaveTensor

aclnnRepeatInterleaveIntWithDim

接口原型

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

**第一段接口：**aclnnStatus aclnnRepeatInterleaveIntWithDimGetWorkspaceSize(const aclTensor *self, int64_t repeats, int64_t dim, int64_t outputSize, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnRepeatInterleaveIntWithDim(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：对输入张量self中每个元素按指定维度dim，每个元素重复repeats的相应次数。
示例：

假设输入张量self是 ([[a, b], [c, d], [e, f]])，repeats为2，dim为0，生成的张量out为( [[a, b], [a, b], [c, d], [c, d], [e, f], [e, f]])。换言之，在dim 0维度，对应的a、b会重复2次，对应的c、d会重复2次，对应的e、f会重复2次。

aclnnRepeatInterleaveIntWithDimGetWorkspaceSize

接口定义：

aclnnStatus aclnnRepeatInterleaveIntWithDimGetWorkspaceSize(const aclTensor *self, int64_t repeats, int64_t dim, int64_t outputSize, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持UINT8、INT8、INT16、INT32、INT64、BOOL、FLOAT16、FLOAT32。支持空Tensor，支持非连续的Tensor，数据格式支持ND。
- repeats：Device侧的整型，重复的次数，数据类型为INT64，repeats的值必须为自然数。
- dim：重复的维度，数据类型为INT64，取值范围为[-self.dim(), self.dim()-1]。
- outputSize：重复后的张量最终大小，数据类型为INT64。outputSize必须等于repeats * self的dim维度size。
- out： Device侧的aclTensor，数据类型支持UINT8、INT8、INT16、INT32、INT64、BOOL、FLOAT16、FLOAT32，且数据类型需要与self一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self的数据类型不在支持范围内。
  - self、out的数据类型不一样。
  - repeats不为自然数。
  - dim取值不在支持的范围内。
  - self的维度数超过8。
  - 当self为0维时，不支持传入dim。 :::

aclnnRepeatInterleaveIntWithDim

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_repeat_interleave.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;2, 3&#125;;
  std::vector<int64_t> outShape = &#123;4, 3&#125;;
  void* selfDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* out = nullptr;
  int64_t dim = 0;
  int64_t repeats = 2;
  int64_t output_size = 4;
  std::vector<float> selfHostData = &#123;3, 4, 5, -3, -4, -5&#125;;
  std::vector<float> outHostData = &#123;0, 0, 0, 0, 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);
  // 创建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;
  // 调用aclnnRepeatInterleaveIntWithDim第一段接口
  ret = aclnnRepeatInterleaveIntWithDimGetWorkspaceSize(self, repeats, dim, output_size, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnRepeatInterleaveIntWithDimGetWorkspaceSize 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;
  // 调用aclnnRepeatInterleaveIntWithDim第二段接口
  ret = aclnnRepeatInterleaveIntWithDim(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnRepeatInterleaveIntWithDim failed. ERROR: %d\n", ret); return ret);

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

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

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

父主题： NN类算子接口

aclnnRepeatInterleaveWithDim

接口原型

**第一段接口：**aclnnStatus aclnnRepeatInterleaveWithDimGetWorkspaceSize(const aclTensor *self, const aclTensor *repeats, int64_t dim, int64_t outputSize, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnRepeatInterleaveWithDim(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：对输入张量self的每个元素按指定维度dim，重复repeats中对应位置的相应次数。
示例：
- 样例1：假设输入张量self是([[a, b], [c, d], [e, f]])，repeats为([1, 2, 3])，dim为0，生成的张量out为 ([[a, b], [c, d], [c, d], [e, f], [e, f], [e, f]])。换言之，在dim 0维度，对应的a、b会重复1次，对应的c、d会重复2次，对应的e、f会重复3次。
- 样例2：假设输入张量self是([[a, b], [c, d], [e, f]])，repeats为([2])，dim为0，生成的张量out为([[a, b], [a, b], [c, d], [c, d], [e, f], [e, f]])。换言之，在dim 0维度，对应的a、b会重复2次，对应的c、d会重复2次，对应的e、f会重复2次。

aclnnRepeatInterleaveWithDimGetWorkspaceSize

接口定义：

aclnnStatus aclnnRepeatInterleaveWithDimGetWorkspaceSize(const aclTensor *self, const aclTensor *repeats, int64_t dim, int64_t outputSize, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持UINT8、INT8、INT16、INT32、INT64、BOOL、FLOAT16、FLOAT32。支持空Tensor，支持非连续的Tensor。数据格式支持ND。
- repeats：Device侧的aclTensor。数据类型支持INT64。repeats只能为0D/1D Tensor。如果为1D Tensor，那么repeats的size必须为1或self的dim维度的size。支持空Tensor，支持非连续的Tensor。数据格式支持ND。
- dim：重复的维度，数据类型为INT64，取值范围为[-self.dim(), self.dim()-1]。
- outputSize：重复后的最终大小。数据类型为INT64。如果repeats中有多个值，则outputSize值必须为repeats的求和。如果repeats只有一个元素时，则outputSize值必须为repeats * self的dim维度size。
- out： Device侧的aclTensor，数据类型支持UINT8、INT8、INT16、INT32、INT64、BOOL、FLOAT16、FLOAT32，且数据类型需要与self一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、repeats或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self、repeats的数据类型不在支持范围内。
  - self、out的数据类型不一致。
  - repeats不为0D/1D Tensor。
  - repeats Tensor中的值不为自然数。
  - dim取值不在支持的范围内。
  - self的维度数超过8。
  - 当self为0维时，不支持传入dim。 :::

aclnnRepeatInterleaveWithDim

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_repeat_interleave.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;2, 3&#125;;
  std::vector<int64_t> repeatsShape = &#123;2&#125;;
  std::vector<int64_t> outShape = &#123;3, 3&#125;;
  void* selfDeviceAddr = nullptr;
  void* repeatsDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* repeats = nullptr;
  aclTensor* out = nullptr;
  int64_t dim = 0;
  int64_t output_size = 3;
  std::vector<int64_t> selfHostData = &#123;3, 4, 5, -3, -4, -5&#125;;
  std::vector<int64_t> repeatsHostData = &#123;1, 2&#125;;
  std::vector<int64_t> outHostData = &#123;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);
  // 创建repeats aclTensor
  ret = CreateAclTensor(repeatsHostData, repeatsShape, &repeatsDeviceAddr, aclDataType::ACL_INT64, &repeats);
  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;
  // 调用aclnnRepeatInterleaveWithDim第一段接口
  ret = aclnnRepeatInterleaveWithDimGetWorkspaceSize(self, repeats, dim, output_size, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnRepeatInterleaveWithDimGetWorkspaceSize 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;
  // 调用aclnnRepeatInterleaveWithDim第二段接口
  ret = aclnnRepeatInterleaveWithDim(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnRepeatInterleaveWithDim 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(repeats);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnRepeatInterleaveTensor

接口原型

**第一段接口：**aclnnStatus aclnnRepeatInterleaveTensorGetWorkspaceSize(const aclTensor *repeats, int64_t outputSize, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnRepeatInterleaveTensor(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：针对张量repeats的第i个元素，将i重复repeats[i]次。
示例：

假设输入张量repeats为([1, 3])，生成的张量为([0, 1, 1, 1])。对于repeats的第0个元素 1，意为将0重复1次。对于repeats的第1个元素3，意为将1重复3次。

aclnnRepeatInterleaveTensorGetWorkspaceSize

接口定义：

aclnnStatus aclnnRepeatInterleaveTensorGetWorkspaceSize(const aclTensor *repeats, int64_t outputSize, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- repeats：Device侧的aclTensor。数据类型支持IINT32、INT64。repeats只能为1D Tensor（包括shape=[0,]的场景），元素值必须是自然数。支持非连续的Tensor，数据格式支持ND。
- outputSize：指定输出张量的大小。数据类型为INT64。outputSize必须等于repeats的值之和。
- out： Device侧的aclTensor，数据类型支持INT32、INT64。数据类型需要与self一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnRepeatInterleaveTensor

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_repeat_interleave.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> repeatsShape = &#123;3&#125;;
  std::vector<int64_t> outShape = &#123;6&#125;;
  void* repeatsDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* repeats = nullptr;
  int64_t output_size = 6;
  aclTensor* out = nullptr;
  std::vector<int64_t> repeatsHostData = &#123;1, 2, 3&#125;;
  std::vector<int64_t> outHostData = &#123;0, 0, 0, 0, 0, 0&#125;;
  // 创建repeats aclTensor
  ret = CreateAclTensor(repeatsHostData, repeatsShape, &repeatsDeviceAddr, aclDataType::ACL_INT64, &repeats);
  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;
  // 调用aclnnRepeatInterleaveTensor第一段接口
  ret = aclnnRepeatInterleaveTensorGetWorkspaceSize(repeats, output_size, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnRepeatInterleaveTensorGetWorkspaceSize 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;
  // 调用aclnnRepeatInterleaveTensor第二段接口
  ret = aclnnRepeatInterleaveTensor(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnRepeatInterleaveTensor 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(repeats);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnReplicationPad1d

接口原型

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

功能描述

算子功能：使用输入的边界值填充张量（1D）。

示例：

输入self=([[0,1,2]])
输入padding=([2,2])
输出out=([[0,0,0,1,2,2,2]])

aclnnReplicationPad1dGetWorkspaceSize

接口定义：

aclnnStatus aclnnReplicationPad1dGetWorkspaceSize(const aclTensor *self, const aclIntArray *padding, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，输入张量，数据类型支持FLOAT16、FLOAT32、DOUBLE、INT8、INT16、INT32、INT64、UINT8、COMPLEX64、COMPLEX128，支持非连续的Tensor，数据格式支持ND。维度支持二维或三维，在最后一维做padding。
- padding：Host侧的aclIntArray，数据类型为INT64，长度为2，数值依次代表左、右需要填充的值。
- out：Device侧的aclTensor，输出张量，数据类型、数据格式、维度与self一致，out最后一维度的数值等于self最后一维度的数值加padding的两个值。支持非连续的Tensor。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self、padding和out的数据类型或数据格式不在支持的范围之内。
  - self、padding和out的输入shape不在支持的范围之内。
  - self为空tensor且存在非batch size维度的值为0。
  - out最后一维的值不等于self最后一维的值加padding的两个值。 :::

aclnnReplicationPad1d

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_replication_pad1d.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;1, 3&#125;;
  std::vector<int64_t> outShape = &#123;1, 7&#125;;
  void* selfDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclIntArray* padding = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = &#123;1, 2, 3&#125;;
  std::vector<int64_t> paddingData  = &#123;2, 2&#125;;
  std::vector<float> outHostData = &#123;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);
  // 创建padding aclIntArray
  padding = aclCreateIntArray(paddingData.data(), 2);
  CHECK_RET(padding != nullptr, 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;
  // 调用aclnnReplicationPad1d第一段接口
  ret = aclnnReplicationPad1dGetWorkspaceSize(self, padding, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnReplicationPad1dGetWorkspaceSize 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;
  // 调用aclnnReplicationPad1d第二段接口
  ret = aclnnReplicationPad1d(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnReplicationPad1d 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，需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyIntArray(padding);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnReplicationPad1dBackward

接口原型

**第一段接口：**aclnnStatus aclnnReplicationPad1dBackwardGetWorkspaceSize(const aclTensor *gradOutput, const aclTensor *self, const aclIntArray *padding, aclTensor *gradInput, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnReplicationPad1dBackward(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：1D边界填充函数（aclnnReplicationPad1d）的反向计算。

示例：

输入gradOutput=([[1,1,1,1,1]])
输入self=([[0,1,2])
输入padding=([1,1])
输出gradInput=([[2,1,2]])

aclnnReplicationPad1dBackwardGetWorkspaceSize

接口定义：

aclnnStatus aclnnReplicationPad1dBackwardGetWorkspaceSize(const aclTensor *gradOutput, const aclTensor *self, const aclIntArray *padding, aclTensor *gradInput, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- gradOutput：Device侧的aclTensor，输入张量，数据类型支持FLOAT16、FLOAT32、DOUBLE、COMPLEX64、COMPLEX128。支持非连续的Tensor，数据格式支持ND，维度支持二维或三维且与self和gradInput一致，shape需要与aclnnReplicationPad1d正向传播的输出一致。
- self：Device侧的aclTensor，输入张量，数据类型与gradOutput一致，支持非连续的Tensor，数据格式支持ND，维度支持二维或三维且与gradOutput和gradInput一致，shape与gradInput一致。
- padding：Host侧的aclIntArray，数据类型为INT64，长度为2，数值依次代表左、右需要填充的值。
- gradInput：Device侧的aclTensor，输出张量，数据类型与gradOutput一致，shape与self一致，支持非连续的Tensor，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的gradOutput、self或gradInput是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - gradOutput、self、padding和gradInput的数据类型或数据格式不在支持的范围之内。
  - gradOutput、self、padding和gradInput的输入shape不在支持范围之内。
  - self为空tensor且存在非batch size维度的值为0。
  - gradOutput shape与aclnnReplicationPad1d正向传播的输出不一致。 :::

aclnnReplicationPad1dBackward

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_replication_pad1d_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 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> gradOutputShape = &#123;1, 4&#125;;
  std::vector<int64_t> selfShape = &#123;1, 2&#125;;
  std::vector<int64_t> gradInputShape = &#123;1, 2&#125;;
  void* gradOutputDeviceAddr = nullptr;
  void* selfDeviceAddr = nullptr;
  void* gradInputDeviceAddr = nullptr;
  aclTensor* gradOutput = nullptr;
  aclTensor* self = nullptr;
  aclIntArray* padding = nullptr;
  aclTensor* gradInput = nullptr;
  std::vector<float> gradOutputHostData = &#123;1, 1, 1, 1&#125;;
  std::vector<float> selfHostData = &#123;1, 2&#125;;
  std::vector<int64_t> paddingData = &#123;1, 1&#125;;
  std::vector<float> gradInputHostData = &#123;0, 0&#125;;
  // 创建gradOutput aclTensor
  ret = CreateAclTensor(gradOutputHostData, gradOutputShape, &gradOutputDeviceAddr, aclDataType::ACL_FLOAT, &gradOutput);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建padding aclIntArray
  padding = aclCreateIntArray(paddingData.data(), 2);
  CHECK_RET(padding != nullptr, return ret);
  // 创建gradInput aclTensor
  ret = CreateAclTensor(gradInputHostData, gradInputShape, &gradInputDeviceAddr, aclDataType::ACL_FLOAT, &gradInput);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3.调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnReplicationPad1dBackward第一段接口
  ret = aclnnReplicationPad1dBackwardGetWorkspaceSize(gradOutput, self, padding, gradInput, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnReplicationPad1dBackwardGetWorkspaceSize 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;
  // 调用aclnnReplicationPad1dBackward第二段接口
  ret = aclnnReplicationPad1dBackward(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnReplicationPad1dBackward 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(gradInputShape);
  std::vector<float> resultData(size, 0);
  ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), gradInputDeviceAddr, 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(gradOutput);
  aclDestroyTensor(self);
  aclDestroyIntArray(padding);
  aclDestroyTensor(gradInput);
  return 0;
&#125;

父主题： NN类算子接口

aclnnReplicationPad2d

接口原型

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

功能描述

算子功能：使用输入的边界值填充张量（2D）。

示例：

输入self=([[[[0,1,2],             
             [3,4,5],             
             [6,7,8]]]])
输入padding=([2,2,2,2])
输出out=([[[[0,0,0,1,2,2,2]],         
            [0,0,0,1,2,2,2]],         
            [0,0,0,1,2,2,2],         
            [3,3,3,4,5,5,5],         
            [6,6,6,7,8,8,8],         
            [6,6,6,7,8,8,8],         
            [6,6,6,7,8,8,8]]]])

aclnnReplicationPad2dGetWorkspaceSize

接口定义：

aclnnStatus aclnnReplicationPad2dGetWorkspaceSize(const aclTensor *self, const aclIntArray *padding, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，输入张量，数据类型支持FLOAT16、FLOAT32、DOUBLE、INT8、INT16、INT32、INT64、UINT8、COMPLEX64、COMPLEX128，支持非连续的Tensor，数据格式支持ND。维度支持三维或四维，在最后两维做padding。
- padding：Host侧的aclIntArray，数据类型为INT64，长度为4，数值依次代表左、右、上、下需要填充的值。
- out：Device侧的aclTensor，输出张量，数据类型、数据格式、维度与self一致，out倒数第2维度的数值等于self倒数第2维度的数值加padding后两个值，out最后一维度的数值等于self最后一维度的数值加padding前两个值。支持非连续的Tensor。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self、padding和out的数据类型或数据格式不在支持的范围之内。
  - self、padding和out的输入shape不在支持的范围之内。
  - self为空tensor且存在非batch size维度的值为0。
  - out后两维度的值不等于self后两维度的值加对应padding。 :::

aclnnReplicationPad2d

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_replication_pad2d.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;1, 1, 2, 2&#125;;
  std::vector<int64_t> outShape = &#123;1, 1, 4, 4&#125;;
  void* selfDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclIntArray* padding = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = &#123;1, 2, 3, 4&#125;;
  std::vector<int64_t> paddingData  = &#123;1, 1, 1, 1&#125;;
  std::vector<float> outHostData = &#123;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_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建padding aclIntArray
  padding = aclCreateIntArray(paddingData.data(), 4);
  CHECK_RET(padding != nullptr, 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;
  // 调用aclnnReplicationPad2d第一段接口
  ret = aclnnReplicationPad2dGetWorkspaceSize(self, padding, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnReplicationPad2dGetWorkspaceSize 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;
  // 调用aclnnReplicationPad2d第二段接口
  ret = aclnnReplicationPad2d(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnReplicationPad2d 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，需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyIntArray(padding);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

在线提单

aclnnRepeatInterleaveIntWithDim​

接口原型​

功能描述​

aclnnRepeatInterleaveIntWithDimGetWorkspaceSize​

aclnnRepeatInterleaveIntWithDim​

调用示例​

aclnnRepeatInterleaveWithDim​

接口原型​

功能描述​

aclnnRepeatInterleaveWithDimGetWorkspaceSize​

aclnnRepeatInterleaveWithDim​

调用示例​

aclnnRepeatInterleaveTensor​

接口原型​

功能描述​

aclnnRepeatInterleaveTensorGetWorkspaceSize​

aclnnRepeatInterleaveTensor​

调用示例​

aclnnReplicationPad1d​

接口原型​

功能描述​

aclnnReplicationPad1dGetWorkspaceSize​

aclnnReplicationPad1d​

调用示例​

aclnnReplicationPad1dBackward​

接口原型​

功能描述​

aclnnReplicationPad1dBackwardGetWorkspaceSize​

aclnnReplicationPad1dBackward​

调用示例​

aclnnReplicationPad2d​

接口原型​

功能描述​

aclnnReplicationPad2dGetWorkspaceSize​

aclnnReplicationPad2d​

调用示例​

aclnnRepeatInterleaveIntWithDim

接口原型

功能描述

aclnnRepeatInterleaveIntWithDimGetWorkspaceSize

aclnnRepeatInterleaveIntWithDim

调用示例

aclnnRepeatInterleaveWithDim

接口原型

功能描述

aclnnRepeatInterleaveWithDimGetWorkspaceSize

aclnnRepeatInterleaveWithDim

调用示例

aclnnRepeatInterleaveTensor

接口原型

功能描述

aclnnRepeatInterleaveTensorGetWorkspaceSize

aclnnRepeatInterleaveTensor

调用示例

aclnnReplicationPad1d

接口原型

功能描述

aclnnReplicationPad1dGetWorkspaceSize

aclnnReplicationPad1d

调用示例

aclnnReplicationPad1dBackward

接口原型

功能描述

aclnnReplicationPad1dBackwardGetWorkspaceSize

aclnnReplicationPad1dBackward

调用示例

aclnnReplicationPad2d

接口原型

功能描述

aclnnReplicationPad2dGetWorkspaceSize

aclnnReplicationPad2d

调用示例