Documentation
Download
文档中心
aclnnRepeatInterleaveWithDim

aclnnRepeatInterleaveWithDim

📄 View Source Code

Applicable Products

ProductSupported
Ascend 950PR/Ascend 950DT√
Atlas A3 training products/Atlas A3 inference products√
Atlas A2 training products/Atlas A2 inference products√
Atlas 200I/500 A2 inference products×
Atlas inference products×
Atlas training products×

Function

  • Description: Repeats each element in the tensor along the specified dimension according to the corresponding count in the Tensor repeats.

  • Example: Assume the input tensor is [[a, b], [c, d], [e, f]], repeats is ([1, 2, 3]), and dim is 0.

    The final generated tensor is ([[a, b], [c, d], [c, d], [e, f], [e, f], [e, f]]). In dimension 0, the corresponding a and b are repeated once, c and d are repeated twice, and e and f are repeated three times.

    Assume the input tensor is ([[a, b], [c, d], [e, f]]), repeats is ([2]), and dim is 0. The final generated tensor is [[a, b], [a, b], [c, d], [c, d], [e, f], [e, f]]. In dimension 0, the corresponding a and b are repeated twice, c and d are repeated twice, and e and f are repeated twice. Note: This scenario is equivalent to repeats being (2).

Function Prototype

Each operator uses a two-phase API. You must first call the "aclnnRepeatInterleaveWithDimGetWorkspaceSize" API to obtain the workspace size required for computation and the executor that contains the operator computation process, and then call the "aclnnRepeatInterleaveWithDim" API to perform the computation.

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,
  aclrtStream    stream)

aclnnRepeatInterleaveWithDimGetWorkspaceSize

  • Parameters:

    Parameter Input/Output Description Instruction Data Type Data Format Dimension (Shape) Non-contiguous Tensor
    self (aclTensor*) Input The input tensor whose data is to be replicated as described in Function. Supports empty tensors. UINT8, INT8, INT16, INT32, INT64, BOOL, FLOAT16, BFLOAT16, FLOAT ND 1-8 √
    repeats (aclTensor*) Input Number of repetitions. Supports empty tensors.
    Must be a 0D or 1D tensor.
    If it is a 1D tensor, the size of repeats must be 1 or equal to the size of the dim dimension of self.    		 INT32, INT64 ND 0–1 √
    dim (int64_t) Input Specifies the dimension along which to repeat. The value ranges from [-self.dim(), self.dim() - 1]. - - - -
    outputSize (int64_t) Input. The final size of the dim dimension after repetition. If repeats contains multiple values, the outputSize value must be the sum of repeats.
    If repeats contains only one element, the outputSize value must be repeats * the size of the dim dimension of self.    		 - - - -
    out (aclTensor*) Output Output tensor after data replication as described in Function. The data type must be the same as self.
    If repeats contains multiple values, the size of out along the dim dimension equals the sum of all elements in repeats.
    If repeats contains only one element, the size of out along the dim dimension equals repeats * the size of self along the dim dimension.    		 UINT8, INT8, INT16, INT32, INT64, BOOL, FLOAT16, BFLOAT16, FLOAT ND - √
    workspaceSize (uint64_t*) Output Returns the workspace size to be applied for on the Device side. - - - - -
    executor (aclOpExecutor**) Output Returns the op executor, which contains the operator computation flow. - - - - -

  • Return value

    aclnnStatus: return code. For details, see aclnn Return Code.

    The first-phase API performs input parameter validation and returns an error in the following scenarios:

    Return Value Return Code Description
    ACLNN_ERR_PARAM_NULLPTR 161001 Null pointer in self, repeats, or out.
    ACLNN_ERR_PARAM_INVALID 161002 The data type of self or repeats is not within the supported range.
    The data types of self and out are different.
    repeats is not a 0D/1D tensor.
    The value of dim is not within the range [-number of dimensions of self, number of dimensions of self - 1].
    When repeats is a 1D tensor, the size of repeats is neither 1 nor the size of the dim dimension of self.
    The number of dimensions of self exceeds 8.
    When self is 0-dimensional, dim is not supported.

aclnnRepeatInterleaveWithDim

  • Parameters:

    Parameter Input/Output Description
    workspace Input Specifies the workspace memory address applied for on the device.
    workspaceSize Input Specifies the workspace size applied for on the device, which is obtained through the first-phase API aclnnRepeatInterleaveWithDimGetWorkspaceSize.
    executor Input Operator executor that contains the operator computation process.
    stream Input Specifies the stream on which the task is executed.

  • Return value

    aclnnStatus: return code. For details, see aclnn Return Code.

Constraints

  • Deterministic computation:

    • aclnnRepeatInterleaveWithDim defaults to a deterministic implementation.

  • Input shape constraints: repeats can only be a 0D or 1D tensor. If it is a 1D tensor, the size of repeats must be 1 or the size of the dim dimension of self.

  • Input value range constraints: The values in the repeats tensor must be natural numbers.

  • Other restrictions: The value of outputSize must meet the following calculation: When repeats contains only one element, outputSize = size of the dim dimension of self * value of repeats; when repeats contains multiple values, outputSize = sum of the values of repeats.

Example

The following provides example code for reference only. For details about compilation and running, see Compile and Run Samples.

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

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

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

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

int Init(int32_t deviceId, aclrtStream* stream) {
  // Boilerplate: resource initialization.
  auto ret = aclInit(nullptr);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret);
  ret = aclrtSetDevice(deviceId);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); return ret);
  ret = aclrtCreateStream(stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret);
  return 0;
}

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) {
  auto size = GetShapeSize(shape) * sizeof(T);
  // Call aclrtMalloc to allocate device-side memory.
  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);
  // Call aclrtMemcpy to copy host-side data to device-side memory.
  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);

  // Calculate strides of a contiguous tensor.
  std::vector<int64_t> strides(shape.size(), 1);
  for (int64_t i = shape.size() - 2; i >= 0; i--) {
    strides[i] = shape[i + 1] * strides[i + 1];
  }

  // Call aclCreateTensor to create an aclTensor.
  *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND,
                            shape.data(), shape.size(), *deviceAddr);
  return 0;
}

int main() {
  // 1. (Boilerplate) Initialize the device/stream. See the ACL API manual.
  // Set deviceId based on the actual device.
  int32_t deviceId = 0;
  aclrtStream stream;
  auto ret = Init(deviceId, &stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

  // 2. Construct the input and output. Custom construction is required based on the API.
  std::vector<int64_t> selfShape = {2, 3};
  std::vector<int64_t> repeatsShape = {2};
  std::vector<int64_t> outShape = {3, 3};
  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 = {3, 4, 5, -3, -4, -5};
  std::vector<int64_t> repeatsHostData = {1, 2};
  std::vector<int64_t> outHostData = {0, 0, 0, 0, 0, 0, 0, 0, 0};

  // Create the self aclTensor.
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_INT64, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // Create the repeats aclTensor.
  ret = CreateAclTensor(repeatsHostData, repeatsShape, &repeatsDeviceAddr, aclDataType::ACL_INT64, &repeats);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // Create the out aclTensor.
  ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_INT64, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3. Call the CANN operator library API. Replace with the actual API name.
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // Call the first-phase API of 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);
  // Apply for device memory based on the workspaceSize calculated by the first-phase API.
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) {
    ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret);
  }
  // Call the second-phase API of aclnnRepeatInterleaveWithDim.
  ret = aclnnRepeatInterleaveWithDim(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnRepeatInterleaveWithDim failed. ERROR: %d\n", ret); return ret);

  // 4. (Boilerplate) Synchronize and wait for task execution to complete.
  ret = aclrtSynchronizeStream(stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);

  // 5. Obtain the output value and copy the result from the device memory to the host memory. Modify based on the specific API definition.
  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++) {
    LOG_PRINT("result[%ld] is: %ld\n", i, resultData[i]);
  }

  // 6. Release aclTensor and aclScalar. Modify based on the specific API definition.
  aclDestroyTensor(self);
  aclDestroyTensor(repeats);
  aclDestroyTensor(out);

  // 7. Release device resources. Modify based on the specific API definition.
  aclrtFree(selfDeviceAddr);
  aclrtFree(repeatsDeviceAddr);
  aclrtFree(outDeviceAddr);
  if (workspaceSize > 0) {
    aclrtFree(workspaceAddr);
  }
  aclrtDestroyStream(stream);
  aclrtResetDevice(deviceId);
  aclFinalize();
  return 0;
}
This site uses cookies to improve your browsing experience. By continuing to browse this site, you agree to our use of cookies.View Details