aclnnAdd

aclnnAdaptiveAvgPool2dBackward

接口原型

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

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

功能描述

算子功能：aclnnAdaptiveAvgPool2d的反向传播。

aclnnAdaptiveAvgPool2dBackwardGetWorkspaceSize

接口定义：

aclnnStatus aclnnAdaptiveAvgPool2dBackwardGetWorkspaceSize(const aclTensor *gradOutput, const aclTensor *self, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- gradOutput：正向运算结果，Device侧的aclTensor，数据类型支持FLOAT16、FLOAT32数据类型，且数据类型与self一致。支持非连续的Tensor，数据格式支持NCHW、CHW，且数据格式需要与self一致。
- self：正向输入，Device侧的aclTensor，数据类型支持FLOAT16、FLOAT32数据类型。支持非连续的Tensor，数据格式支持NCHW、CHW。
- out：输出张量，Device侧的aclTensor，数据类型支持FLOAT16、FLOAT32数据类型，shape与self一致，数据格式支持NCHW、CHW，且数据格式与self一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnAdaptiveAvgPool2dBackward

接口定义：

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

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

调用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_adaptive_avg_pool2d_backward.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, aclrtContext* context, aclrtStream* stream) { // 固定写法，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; } template <typename T> int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType, aclTensor** tensor) { auto size = GetShapeSize(shape) * sizeof(T); // 调用aclrtMalloc申请device侧内存 auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret); // 调用aclrtMemcpy将Host侧数据拷贝到device侧内存上 ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret); // 计算连续tensor的strides std::vector<int64_t> strides(shape.size(), 1); for (int64_t i = shape.size() - 2; i >= 0; i--) { strides[i] = shape[i + 1] * strides[i + 1]; } // 调用aclCreateTensor接口创建aclTensor *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(), *deviceAddr); return 0; } int main() { // 1. （固定写法）device/context/stream初始化, 参考AscendCL对外接口列表 // 根据自己的实际device填写deviceId int32_t deviceId = 0; aclrtContext context; aclrtStream stream; auto ret = Init(deviceId, &context, &stream); // check根据自己的需要处理 CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret); // 2. 构造输入与输出，需要根据API的接口自定义构造 std::vector<int64_t> gradOutputShape = {1, 1, 3, 2}; std::vector<int64_t> selfShape = {1, 1, 4, 2}; std::vector<int64_t> outShape = {1, 1, 4, 2}; void* gradOutputDeviceAddr = nullptr; void* selfDeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* gradOutput = nullptr; aclTensor* self = nullptr; aclTensor* out = nullptr; std::vector<float> gradOutputHostData = {1, 2, 3, 4, 5, 6}; std::vector<float> selfHostData = {0, 1, 2, 3, 4, 5, 6, 7}; std::vector<float> outHostData(8, 0); // 创建gradOutput aclTensor ret = CreateAclTensor(gradOutputHostData, gradOutputShape, &gradOutputDeviceAddr, aclDataType::ACL_FLOAT, &gradOutput); // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建out aclTensor ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out); CHECK_RET(ret == ACL_SUCCESS, return ret); // 3.调用CANN算子库API，需要修改为具体的算子接口 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnAdaptiveAvgPool2dBackward第一段接口 ret = aclnnAdaptiveAvgPool2dBackwardGetWorkspaceSize(gradOutput, self, out, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAdaptiveAvgPool2dBackwardGetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; if (workspaceSize > 0) { ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret); } // 调用aclnnAdaptiveAvgPool2dBackward二段接口 ret = aclnnAdaptiveAvgPool2dBackward(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAdaptiveAvgPool2dBackward 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++) { LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]); } // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(gradOutput); aclDestroyTensor(self); aclDestroyTensor(out); return 0; }

父主题： NN类算子接口

aclnnAdaptiveMaxPool2d

接口原型

**第一段接口：**aclnnStatus aclnnAdaptiveMaxPool2dGetWorkspaceSize(const aclTensor* self, const aclIntArray* outputSize, aclTensor* outputOut, aclTensor* indicesOut, uint64_t* workspaceSize, aclOpExecutor** executor)
**第二段接口：**aclnnStatus aclnnAdaptiveMaxPool2d(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream)

功能描述

算子功能：对输入张量实现2D自适应最大池化操作。

aclnnAdaptiveMaxPool2dGetWorkspaceSize

接口定义：

aclnnStatus aclnnAdaptiveMaxPool2dGetWorkspaceSize(const aclTensor* self, const aclIntArray* outputSize, aclTensor* outputOut, aclTensor* indicesOut, uint64_t* workspaceSize, aclOpExecutor** executor)
参数说明：
- self：Device侧的aclTensor，输入张量，shape仅支持3D或4D。数据类型支持FLOAT16、FLOAT32和DOUBLE，支持非连续的Tensor，数据格式支持CHW和NCHW。
- outputSize：Host侧的aclIntArray，size大小为2。表示输出结果在H和W维度上的空间大小。
- outputOut：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT32和DOUBLE，且数据类型与self需满足数据类型推导规则，shape与indicesOut一致。支持非连续的Tensor，数据格式支持CHW和NCHW。
- indicesOut：Device侧的aclTensor，表示outputOut元素在输入self中的索引位置。数据类型支持INT64，且shape与outputOut一致，支持非连续的Tenosr，数据格式支持CHW和NCHW。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、outputSize、outputOut或indicesOut是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self的数据类型不在支持的范围内。
  - self和outputOut不满足数据类型推导规则。
  - indicesOut的数据类型不为INT64。
  - self的shape不是3维或者4维。
  - self在非第一维度上的size小于1。
  - outputOut和indicesOut的shape不一致。
  - outputSize的size大小不等于2。
  - outputSize中元素值≤0。 :::

aclnnAdaptiveMaxPool2d

接口定义：

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

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

调用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 cpp #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_adaptive_max_pool2d.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 shape_size = 1; for (auto i : shape) { shape_size *= i; } return shape_size; } int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) { // 固定写法，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; } template <typename T> int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType, aclTensor** tensor) { auto size = GetShapeSize(shape) * sizeof(T); // 调用aclrtMalloc申请device侧内存 auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret); // 调用aclrtMemcpy将Host侧数据拷贝到device侧内存上 ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret); // 计算连续tensor的strides std::vector<int64_t> strides(shape.size(), 1); for (int64_t i = shape.size() - 2; i >= 0; i--) { strides[i] = shape[i + 1] * strides[i + 1]; } // 调用aclCreateTensor接口创建aclTensor *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_NCHW, shape.data(), shape.size(), *deviceAddr); return 0; } int main() { // 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 = {1, 1, 4, 4}; std::vector<int64_t> outShape = {1, 1, 2, 2}; void* selfDeviceAddr = nullptr; void* outDeviceAddr = nullptr; void* indDeviceAddr = nullptr; aclTensor* self = nullptr; aclTensor* out = nullptr; aclTensor* indices = nullptr; std::vector<float> selfHostData = {0, 1, 2, 3, 4.1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; std::vector<float> outHostData = {0, 0, 0, 0.0}; std::vector<int64_t> indicesHostData = {0, 0, 0, 0}; float alphaValue = 1.2f; // 创建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); // 创建out aclTensor ret = CreateAclTensor(indicesHostData, outShape, &indDeviceAddr, aclDataType::ACL_INT64, &indices); CHECK_RET(ret == ACL_SUCCESS, return ret); std::vector<int64_t> arraySize = {2, 2}; const aclIntArray *outputSize = aclCreateIntArray(arraySize.data(), arraySize.size()); CHECK_RET(outputSize != nullptr, return ACL_ERROR_INTERNAL_ERROR); // 3.调用CANN算子库API，需要修改为具体的算子接口 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnAdaptiveMaxPool2d第一段接口 ret = aclnnAdaptiveMaxPool2dGetWorkspaceSize(self, outputSize, out, indices, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAdaptiveMaxPool2dGetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; if (workspaceSize > 0) { ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret;); } // 调用aclnnAdaptiveMaxPool2d第二段接口 ret = aclnnAdaptiveMaxPool2d(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAdaptiveMaxPool2dfailed. 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> outData(size, 0); std::vector<int64_t> indicesData(size, 0); ret = aclrtMemcpy(outData.data(), outData.size() * sizeof(outData[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); ret = aclrtMemcpy(indicesData.data(), indicesData.size() * sizeof(indicesData[0]), indDeviceAddr, size * sizeof(int64_t), 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("out[%ld] is: %f\n", i, outData[i]); } for (int64_t i = 0; i < size; i++) { LOG_PRINT("indices[%ld] is: %ld\n", i, indicesData[i]); } // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(self); aclDestroyTensor(out); aclDestroyTensor(indices); aclDestroyIntArray(outputSize); return 0; }

父主题： NN类算子接口

aclnnAdd

接口原型

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

功能描述

算子功能：完成张量self与张量other的加法计算。
计算公式：

aclnnAddGetWorkspaceSize

接口定义：

aclnnStatus aclnnAddGetWorkspaceSize(const aclTensor *self, const aclTensor *other, const aclScalar *alpha, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self(aclTensor*, 计算输入)：公式中的输入self，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型与other的数据类型需满足数据类型推导规则，shape需要与other满足broadcast关系。支持非连续的Tensor，数据格式支持ND。
- other(aclTensor*，计算输入)：公式中的输入other，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型与self的数据类型需满足数据类型推导规则，shape需要与self满足broadcast关系。支持非连续的Tensor，数据格式支持ND。
- alpha(aclScalar*, 计算输入)：公式中的alpha，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要可转换成self与other推导后的数据类型。
- out(aclTensor*, 计算输出)：公式中的out，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要是self与other推导之后可转换的数据类型，shape需要是self与other broadcast之后的shape。支持非连续的Tensor，数据格式支持ND。
- workspaceSize(uint64_t*, 出参)：返回用户需要在Device侧申请的workspace大小。
- executor(aclOpExecutor**, 出参)：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnAdd

接口定义：

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

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

调用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_add.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 shape_size = 1; for (auto i : shape) { shape_size *= i; } return shape_size; } int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) { // 固定写法，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; } template <typename T> int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType, aclTensor** tensor) { auto size = GetShapeSize(shape) * sizeof(T); // 调用aclrtMalloc申请device侧内存 auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret); // 调用aclrtMemcpy将Host侧数据拷贝到device侧内存上 ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret); // 计算连续tensor的strides std::vector<int64_t> strides(shape.size(), 1); for (int64_t i = shape.size() - 2; i >= 0; i--) { strides[i] = shape[i + 1] * strides[i + 1]; } // 调用aclCreateTensor接口创建aclTensor *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(), *deviceAddr); return 0; } int main() { // 1. （固定写法）device/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 = {4, 2}; std::vector<int64_t> otherShape = {4, 2}; std::vector<int64_t> outShape = {4, 2}; void* selfDeviceAddr = nullptr; void* otherDeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* self = nullptr; aclTensor* other = nullptr; aclScalar* alpha = nullptr; aclTensor* out = nullptr; std::vector<float> selfHostData = {0, 1, 2, 3, 4, 5, 6, 7}; std::vector<float> otherHostData = {1, 1, 1, 2, 2, 2, 3, 3}; std::vector<float> outHostData = {0, 0, 0, 0, 0, 0, 0, 0}; float alphaValue = 1.2f; // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建other aclTensor ret = CreateAclTensor(otherHostData, otherShape, &otherDeviceAddr, aclDataType::ACL_FLOAT, &other); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建alpha aclScalar alpha = aclCreateScalar(&alphaValue, aclDataType::ACL_FLOAT); CHECK_RET(alpha != 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; // 调用aclnnAdd第一段接口 ret = aclnnAddGetWorkspaceSize(self, other, alpha, out, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAddGetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; if (workspaceSize > 0) { ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret;); } // 调用aclnnAdd第二段接口 ret = aclnnAdd(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAdd 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++) { LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]); } // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(self); aclDestroyTensor(other); aclDestroyScalar(alpha); aclDestroyTensor(out); // 7. 释放device资源，需要根据具体API的接口定义修改 aclrtFree(selfDeviceAddr); aclrtFree(otherDeviceAddr); aclrtFree(outDeviceAddr); if (workspaceSize > 0) { aclrtFree(workspaceAddr); } aclrtDestroyStream(stream); aclrtDestroyContext(context); aclrtResetDevice(deviceId); aclFinalize(); return 0; }

父主题： NN类算子接口

aclnnAddbmm/aclnnInplaceAddbmm

接口原型

:::note 说明

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

功能描述

算子功能：首先进行batch1、batch2的矩阵乘计算，然后将结果按照第一维（batch维度）批处理相加，将三维向量压缩为二维向量（shape大小为后两维的shape），然后该结果与α作乘积计算，再与β和self的乘积求和得到结果。
计算公式：

如果β为0，则self会被忽略，不参与计算。
示例：

假设self的shape是(3, 5)，batch1的shape是(10, 3, 4)，batch2的shape是(10, 4, 5)，计算输出out的shape是(3, 5)。

aclnnAddbmmGetWorkspaceSize

接口定义：

aclnnStatus aclnnAddbmmGetWorkSpaceSize(const aclTensor *self, const aclTensor *batch1, const aclTensor *batch2, const aclScalar *beta, const aclScalar *alpha, aclTensor *out, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT，数据类型与batch1@batch2的数据类型需满足数据类型推导规则，shape需要与batch1@batch2的后两维的shape满足broadcast关系。支持非连续的Tensor，支持空Tensor传入，数据格式支持ND。
  
  :::note 说明
  - 对于数据类型，只能batch1@batch2的dtype向self推导，不能反过来，因此若self为FLOAT16，batch1@batch2为FLOAT，会报错。
  - 对于shape，只能是self通过broadcast变成和batch1@batch2的后两维一样的shape，不可以是batch1@batch2的后两维shape通过broadcast变成和self一样。例如self的shape是(3, 5)， batch1@batch2的shape是(1, 1, 1)，执行会报错。 :::
- batch1：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16，数据类型与self、batch2的数据类型需满足数据类型推导规则，shape需要与batch2满足bmm输入约束条件。支持非连续的Tensor，支持空Tensor传入，数据格式支持ND。
- batch2：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16，数据类型与self、batch1的数据类型需满足数据类型推导规则，shape需要与batch1满足bmm输入约束条件。支持非连续的Tensor，支持空Tensor传入，数据格式支持ND。
- beta：Host侧的aclScalar，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL，数据类型需要可转换成self与batch1@batch2推导后的数据类型。
- alpha：Host侧的aclScalar，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL，数据类型需要可转换成self与batch1@batch2推导后的数据类型。
- out：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16，数据类型需要与self保持一致，shape要求与batch1@batch2的后两维shape保持一致。支持非连续的Tensor，支持空Tensor传入，数据格式支持ND。
- cubeMathType：Host侧的整型，判断Cube单元应该使用哪种计算逻辑进行运算，支持INT8类型的枚举值，枚举值如下：
  - 0：KEPP_DTYPE，保持输入的数据类型进行计算。
  - 1：ALLOW_FP32_DOWN_PRECISION，允许转换输入数据类型降低精度计算。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、batch1、batch2或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self、batch1、batch2或out的数据类型和数据格式不在支持的范围之内
  - self与out的数据类型不一致。
  - self不能与batch1@batch2的后两维shape做broadcast操作。
  - self与batch1的dtype不同且self为FLOAT16、batch1为FLOAT。
  - batch1和batch2的第一维度不相等。
  - batch1和batch2的维度不是三维。
  - batch1的最后一维和batch2的倒数第二维不相等。 :::

aclnnAddbmm

接口定义：

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

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

aclnnInplaceAddbmmGetWorkspaceSize

接口定义：

aclnnStatus aclnnInplaceAddbmmGetWorkSpaceSize(const aclTensor *selfRef, const aclTensor *batch1, const aclTensor *batch2, const aclScalar *beta, const aclScalar *alpha, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- selfRef：Device侧的aclTensor，数据类型支持FLOAT16，FLOAT，数据类型与batch1@batch2的数据类型需满足数据类型推导规则，shape需要与batch1@batch2的后两维的shape满足broadcast关系。支持非连续的Tensor，支持空Tensor传入，数据格式支持ND。
  
  :::note 说明
  - 对于数据类型，只能batch1@batch2的dtype向selfRef推导，不能反过来，因此若selfRef为FLOAT16，batch1@batch2为FLOAT，会报错。
  - 对于shape，只能是selfRef通过broadcast变成和batch1@batch2的后两维一样的shape，不可以是batch1@batch2的后两维shape通过broadcast变成和selfRef一样。例如selfRef的shape是(3, 5)， batch1@batch2的shape是(1, 1, 1)，执行会报错。 :::
- batch1：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16，数据类型与selfRef、batch2的数据类型需满足数据类型推导规则，shape需要与batch2满足bmm输入约束条件。支持非连续的Tensor，支持空Tensor传入，数据格式支持ND。
- batch2：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16，数据类型与selfRef、batch1的数据类型需满足数据类型推导规则，shape需要与batch1满足bmm输入约束条件。支持非连续的Tensor，支持空Tensor传入，数据格式支持ND。
- beta：Host侧的aclScalar，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL，数据类型需要可转换成selfRef与batch1@batch2推导后的数据类型。
- alpha：Host侧的aclScalar，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL，数据类型需要可转换成selfRef与batch1@batch2推导后的数据类型。
- cubeMathType：Host侧的整型，判断Cube单元应该使用哪种计算逻辑进行运算，支持INT8类型的枚举值，枚举值如下：
  - 0：KEPP_DTYPE，保持输入的数据类型进行计算。
  - 1：ALLOW_FP32_DOWN_PRECISION，允许转换输入数据类型降低精度计算。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的selfRef、batch1、batch2是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - selfRef、batch1、batch2的数据类型和数据格式不在支持的范围之内。
  - selfRef不能与batch1@batch2的后两维shape做broadcast操作。
  - selfRef与batch1的dtype不同且selfRef为FLOAT16、batch1为FLOAT。
  - batch1和batch2的第一维度不相等。
  - batch1和batch2的维度不是三维。
  - batch1的最后一维和batch2的倒数第二维不相等。 :::

aclnnInplaceAddbmm

接口定义：

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

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

调用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_addbmm.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, aclrtContext* context, aclrtStream* stream) { // 固定写法，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; } template <typename T> int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType, aclTensor** tensor) { auto size = GetShapeSize(shape) * sizeof(T); // 调用aclrtMalloc申请device侧内存 auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret); // 调用aclrtMemcpy将Host侧数据拷贝到device侧内存上 ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret); // 计算连续tensor的strides std::vector<int64_t> strides(shape.size(), 1); for (int64_t i = shape.size() - 2; i >= 0; i--) { strides[i] = shape[i + 1] * strides[i + 1]; } // 调用aclCreateTensor接口创建aclTensor *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(), *deviceAddr); return 0; } int main() { // 1. （固定写法）device/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 = {2, 4}; std::vector<int64_t> batch1Shape = {1, 2, 3}; std::vector<int64_t> batch2Shape = {1, 3, 4}; std::vector<int64_t> outShape = {2, 4}; void* selfDeviceAddr = nullptr; void* batch1DeviceAddr = nullptr; void* batch2DeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* self = nullptr; aclTensor* batch1 = nullptr; aclTensor* batch2 = nullptr; aclScalar* alpha = nullptr; aclScalar* beta = nullptr; aclTensor* out = nullptr; std::vector<float> selfHostData = {0, 1, 2, 3, 4, 5, 6, 7}; std::vector<float> batch1HostData = {1, 1, 1, 2, 2, 2}; std::vector<float> batch2HostData = {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4}; std::vector<float> outHostData(8, 0); int8_t cubeMathType = 1; float alphaValue = 1.2f; float betaValue = 1.0f; // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建batch1 aclTensor ret = CreateAclTensor(batch1HostData, batch1Shape, &batch1DeviceAddr, aclDataType::ACL_FLOAT, &batch1); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建batch2 aclTensor ret = CreateAclTensor(batch2HostData, batch2Shape, &batch2DeviceAddr, aclDataType::ACL_FLOAT, &batch2); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建alpha aclScalar alpha = aclCreateScalar(&alphaValue,aclDataType::ACL_FLOAT); CHECK_RET(alpha != nullptr, return ret); // 创建beta aclScalar beta = aclCreateScalar(&betaValue,aclDataType::ACL_FLOAT); CHECK_RET(beta != nullptr, 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; // 调用aclnnAddbmm第一段接口 ret = aclnnAddbmmGetWorkspaceSize(self, batch1, batch2, alpha, beta, out, cubeMathType, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAddbmmGetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; if (workspaceSize > 0) { ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret); } // 调用aclnnAddbmm第二段接口 ret = aclnnAddbmm(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAddbmm 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++) { LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]); } // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(self); aclDestroyTensor(batch1); aclDestroyTensor(batch2); aclDestroyScalar(alpha); aclDestroyScalar(beta); aclDestroyTensor(out); return 0; }

父主题： NN类算子接口

aclnnAddcdiv/aclnnInplaceAddcdiv

接口原型

:::note 说明

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

功能描述

算子功能：完成tensor1与tensor2元素除法运算，将结果乘以标量value并将其添加到self中。
计算公式：

aclnnAddcdivGetWorkspaceSize

接口定义：

aclnnStatus aclnnAddcdivGetWorkspaceSize(const aclTensor *self, const aclTensor *tensor1, const aclTensor *tensor2, const aclScalar *value, const aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：需要累加的张量，Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、DOUBLE、INT64、BFLOAT16（仅Atlas A2训练系列产品支持），数据类型要和tensor1、tensor2支持可推导关系，shape要与tensor1、tensor2除过之后的tensor满足broadcast关系，支持非连续的Tensor，数据格式支持ND。
- tensor1：分子张量，Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、DOUBLE、INT64、BFLOAT16（仅Atlas A2训练系列产品支持），数据类型要和self、tensor2支持可推导关系，shape要与tensor2满足broadcast关系，支持非连续的Tensor，数据格式支持ND。
- tensor2：分母张量，Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、DOUBLE、INT64、BFLOAT16（仅Atlas A2训练系列产品支持），数据类型要和self、tensor1支持可推导关系，shape要与tensor1满足broadcast关系，支持非连续的Tensor，数据格式支持ND。
- value：Host侧的aclScalar，数据类型与self、tensor1、tensor2数据类型保持一致，不一致时需要强转成一致。
- out：输出张量，Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、DOUBLE、INT64、BFLOAT16（仅Atlas A2训练系列产品支持），数据类型要满足和self、tensor1、tensor2推导关系，shape是self、tensor1、tensor2 broadcast之后的shape，支持非连续Tensor，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnAddcdiv

接口定义：

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

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

aclnnInplaceAddcdivGetWorkspaceSize

接口定义：

aclnnStatus aclnnInplaceAddcdivGetWorkspaceSize(const aclTensor *selfRef, const aclTensor *tensor1, const aclTensor *tensor2, const aclScalar *value, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- selfRef：需要累加的张量，Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、DOUBLE、INT64、BFLOAT16（仅Atlas A2训练系列产品支持），数据类型要和tensor1、tensor2支持可推导关系，shape要与tensor1、tensor2除过之后的tensor满足broadcast关系，支持非连续的Tensor，数据格式支持ND。
- tensor1：分子张量，Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、DOUBLE、INT64、BFLOAT16（仅Atlas A2训练系列产品支持），数据类型要和self、tensor2支持可推导关系，shape要与tensor2满足broadcast关系，支持非连续的Tensor，数据格式支持ND。
- tensor2：分母张量，Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、DOUBLE、INT64、BFLOAT16（仅Atlas A2训练系列产品支持），数据类型要和self、tensor1支持可推导关系，shape要与tensor1满足broadcast关系，支持非连续的Tensor，数据格式支持ND。
- value：Host侧的aclScalar，数据类型与self、tensor1、tensor2数据类型保持一致，不一致时需要强转成一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnInplaceAddcdiv

接口定义：

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

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

调用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_addcdiv.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, aclrtContext* context, aclrtStream* stream) { // 固定写法，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; } template <typename T> int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType, aclTensor** tensor) { auto size = GetShapeSize(shape) * sizeof(T); // 调用aclrtMalloc申请device侧内存 auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret); // 调用aclrtMemcpy将Host侧数据拷贝到device侧内存上 ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret); // 计算连续tensor的strides std::vector<int64_t> strides(shape.size(), 1); for (int64_t i = shape.size() - 2; i >= 0; i--) { strides[i] = shape[i + 1] * strides[i + 1]; } // 调用aclCreateTensor接口创建aclTensor *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(), *deviceAddr); return 0; } int main() { // 1. （固定写法）device/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 = {4, 2}; std::vector<int64_t> tensor1Shape = {4, 2}; std::vector<int64_t> tensor2Shape = {4, 2}; std::vector<int64_t> outShape = {4, 2}; void* selfDeviceAddr = nullptr; void* tensor1DeviceAddr = nullptr; void* tensor2DeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* self = nullptr; aclTensor* tensor1 = nullptr; aclTensor* tensor2 = nullptr; aclScalar* value = nullptr; aclTensor* out = nullptr; std::vector<float> selfHostData = {0, 1, 2, 3, 4, 5, 6, 7}; std::vector<float> tensor1HostData = {2, 2, 2, 2, 2, 2, 2, 2}; std::vector<float> tensor2HostData = {2, 2, 2, 2, 2, 2, 2, 2}; std::vector<float> outHostData = {0, 0, 0, 0, 0, 0, 0, 0}; float scalarValue = 1.2f; // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建tensor1 aclTensor ret = CreateAclTensor(tensor1HostData, tensor1Shape, &tensor1DeviceAddr, aclDataType::ACL_INT64, &tensor1); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建tensor2 aclTensor ret = CreateAclTensor(tensor2HostData, tensor2Shape, &tensor2DeviceAddr, aclDataType::ACL_INT64, &tensor2); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建value aclScalar value = aclCreateScalar(&scalarValue, aclDataType::ACL_FLOAT); // 创建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; // 调用aclnnAddcdiv第一段接口 ret = aclnnAddcdivGetWorkspaceSize(self, tensor1, tensor2, value, out, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEmbeddingDenseBackwardGetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; if (workspaceSize > 0) { 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); } // 调用aclnnAddcdiv第二段接口 ret = aclnnAddcdiv(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAddcdiv failed. ERROR: %d\n", ret); return ret); // 4. （固定写法）同步等待任务执行结束 ret = aclrtSynchronizeStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret); // 5. 获取输出的值，将device侧内存上的结果拷贝至Host侧，需要根据具体API的接口定义修改 auto size = GetShapeSize(outShape); std::vector<float> resultData(size, 0); ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr, size * sizeof(resultData[0]), ACL_MEMCPY_DEVICE_TO_HOST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy resultData from device to host failed. ERROR: %d\n", ret); return ret); for (int64_t i = 0; i < size; i++) { LOG_PRINT("resultData[%ld] is: %f\n", i, resultData[i]); } // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(self); aclDestroyTensor(tensor1); aclDestroyTensor(tensor2); aclDestroyTensor(out); aclDestroyScalar(value); return 0; }

父主题： NN类算子接口

aclnnAddcmul/aclnnInplaceAddcmul

接口原型

:::note 说明

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

功能描述

算子功能：张量tensor1和张量tensor2逐元素相乘，结果乘以标量value后将其添加到输入张量self中。
计算公式：

aclnnAddcmulGetWorkspaceSize

接口定义：

aclnnStatus aclnnAddcmulGetWorkspaceSize(const aclTensor *self, const aclTensor *tensor1, const aclTensor *tensor2, const aclScalar *value, const aclTensor *out, uint64_t *workspaceSize, aclOpExecutor** executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、INT32、INT64、INT16、INT8、UINT8、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要与tensor1、tensor2相乘的结果构成互推导关系，shape需要与tensor1、tensor2满足broadcast关系。支持非连续的Tensor，数据格式支持ND，且数据格式需要与tensor1、tensor2一致。
- tensor1：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、INT32、INT64、INT16、INT8、UINT8、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要与self、tensor2构成互推导关系，shape需要与self、tensor2满足broadcast关系。支持非连续的Tensor，数据格式支持ND，且数据格式需要与self、tensor2一致。
- tensor2：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、INT32、INT64、INT16、INT8、UINT8、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要与self、tensor1构成互推导关系，shape需要与self、tensor1满足broadcast关系。支持非连续的Tensor，数据格式支持ND，且数据格式需要与self、tensor1一致。
- value：Host侧的aclScalar，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT8、UINT8、BOOL、BFLOAT16（仅Atlas A2训练系列产品支持），数据类型需要可转换成self与tensor1、tensor2推导后的数据类型。
- out ：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、INT32、INT64、INT16、INT8、UINT8、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要是self与tensor1、tensor2推导之后可转换的数据类型，shape需要是self与tensor1、tensor2 broadcast之后的shape，支持非连续的Tensor，数据格式支持ND，且数据格式需要与self一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnAddcmul

接口定义：

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

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

aclnnInplaceAddcmulGetWorkspaceSize

接口定义：

aclnnStatus aclnnInplaceAddcmulGetWorkspaceSize(const aclTensor *self, const aclTensor *tensor1, const aclTensor *tensor2, const aclScalar *value, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、INT32、INT64、INT16、INT8、UINT8、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要与tensor1、tensor2相乘的结果构成互推导关系，shape需要与tensor1、tensor2满足broadcast关系。支持非连续的Tensor，数据格式支持ND，且数据格式需要与tensor1、tensor2一致。
- tensor1：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、INT32、INT64、INT16、INT8、UINT8、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要与self、tensor2构成互推导关系，shape需要与self、tensor2满足broadcast关系。支持非连续的Tensor，数据格式支持ND，且数据格式需要与self、tensor2一致。
- tensor2：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、INT32、INT64、INT16、INT8、UINT8、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要与self、tensor1构成互推导关系，shape需要与self、tensor1满足broadcast关系。支持非连续的Tensor，数据格式支持ND，且数据格式需要与self、tensor1一致。
- value：Host侧的aclScalar，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT8、UINT8、BOOL、BFLOAT16（仅Atlas A2训练系列产品支持），数据类型需要可转换成self与tensor1、tensor2推导后的数据类型。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnInplaceAddcmul

接口定义：

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

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

调用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_addcmul.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 shape_size = 1; for (auto i : shape) { shape_size *= i; } return shape_size; } int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) { // 固定写法，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; } template <typename T> int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType, aclTensor** tensor) { auto size = GetShapeSize(shape) * sizeof(T); // 调用aclrtMalloc申请device侧内存 auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret); // 调用aclrtMemcpy将Host侧数据拷贝到device侧内存上 ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret); // 计算连续tensor的strides std::vector<int64_t> strides(shape.size(), 1); for (int64_t i = shape.size() - 2; i >= 0; i--) { strides[i] = shape[i + 1] * strides[i + 1]; } // 调用aclCreateTensor接口创建aclTensor *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(), *deviceAddr); return 0; } int main() { // 1. （固定写法）device/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 = {4, 2}; std::vector<int64_t> other1Shape = {4, 2}; std::vector<int64_t> other2Shape = {4, 2}; std::vector<int64_t> outShape = {4, 2}; void* selfDeviceAddr = nullptr; void* other1DeviceAddr = nullptr; void* other2DeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* self = nullptr; aclTensor* other1 = nullptr; aclTensor* other2 = nullptr; aclScalar* value= nullptr; aclTensor* out = nullptr; std::vector<float> selfHostData = {0, 1, 2, 3, 4, 5, 6, 7}; std::vector<float> other1HostData = {1, 1, 1, 2, 2, 2, 3, 3}; std::vector<float> other2HostData = {1, 1, 1, 2, 2, 2, 3, 3}; std::vector<float> outHostData = {0, 0, 0, 0, 0, 0, 0, 0}; float valueNum = 1.2f; // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建other1 aclTensor ret = CreateAclTensor(other1HostData, other1Shape, &other1DeviceAddr, aclDataType::ACL_FLOAT, &other1); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建other2 aclTensor ret = CreateAclTensor(other2HostData, other2Shape, &other2DeviceAddr, aclDataType::ACL_FLOAT, &other2); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建value aclScalar value = aclCreateScalar(&valueNum, aclDataType::ACL_FLOAT); CHECK_RET(value != 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; // 调用aclnnAddcmul第一段接口 ret = aclnnAddcmulGetWorkspaceSize(self, other1, other2, value, out, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAddcmulGetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; if (workspaceSize > 0) { ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret;); } // 调用aclnnAddcmul第二段接口 ret = aclnnAddcmul(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAddcmul 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++) { LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]); } // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(self); aclDestroyTensor(other1); aclDestroyTensor(other2); aclDestroyScalar(value); aclDestroyTensor(out); return 0; }

父主题： NN类算子接口

在线提单

aclnnAdaptiveAvgPool2dBackward​

接口原型​

功能描述​

aclnnAdaptiveAvgPool2dBackwardGetWorkspaceSize​

aclnnAdaptiveAvgPool2dBackward​

调用示例​

aclnnAdaptiveMaxPool2d​

接口原型​

功能描述​

aclnnAdaptiveMaxPool2dGetWorkspaceSize​

aclnnAdaptiveMaxPool2d​

调用示例​

aclnnAdd​

接口原型​

功能描述​

aclnnAddGetWorkspaceSize​

aclnnAdd​

调用示例​

aclnnAddbmm/aclnnInplaceAddbmm​

接口原型​

功能描述​

aclnnAddbmmGetWorkspaceSize​

aclnnAddbmm​

aclnnInplaceAddbmmGetWorkspaceSize​

aclnnInplaceAddbmm​

调用示例​

aclnnAddcdiv/aclnnInplaceAddcdiv​

接口原型​

功能描述​

aclnnAddcdivGetWorkspaceSize​

aclnnAddcdiv​

aclnnInplaceAddcdivGetWorkspaceSize​

aclnnInplaceAddcdiv​

调用示例​

aclnnAddcmul/aclnnInplaceAddcmul​

接口原型​

功能描述​

aclnnAddcmulGetWorkspaceSize​

aclnnAddcmul​

aclnnInplaceAddcmulGetWorkspaceSize​

aclnnInplaceAddcmul​

调用示例​

aclnnAdaptiveAvgPool2dBackward

接口原型

功能描述

aclnnAdaptiveAvgPool2dBackwardGetWorkspaceSize

aclnnAdaptiveAvgPool2dBackward

调用示例

aclnnAdaptiveMaxPool2d

接口原型

功能描述

aclnnAdaptiveMaxPool2dGetWorkspaceSize

aclnnAdaptiveMaxPool2d

调用示例

aclnnAdd

接口原型

功能描述

aclnnAddGetWorkspaceSize

aclnnAdd

调用示例

aclnnAddbmm/aclnnInplaceAddbmm

接口原型

功能描述

aclnnAddbmmGetWorkspaceSize

aclnnAddbmm

aclnnInplaceAddbmmGetWorkspaceSize

aclnnInplaceAddbmm

调用示例

aclnnAddcdiv/aclnnInplaceAddcdiv

接口原型

功能描述

aclnnAddcdivGetWorkspaceSize

aclnnAddcdiv

aclnnInplaceAddcdivGetWorkspaceSize

aclnnInplaceAddcdiv

调用示例

aclnnAddcmul/aclnnInplaceAddcmul

接口原型

功能描述

aclnnAddcmulGetWorkspaceSize

aclnnAddcmul

aclnnInplaceAddcmulGetWorkspaceSize

aclnnInplaceAddcmul

调用示例