剥离math下op_host/op_api到op

Mclassify_rule.yaml+21-21

Mmath/affine_grid/CMakeLists.txt+3-10

	@@ -1,18 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11		10
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE affine_grid ACLNNTYPE aclnn_exclude)
13	list(REMOVE_ITEM CURRENT_DIRS tests)
14	foreach(SUB_DIR ${CURRENT_DIRS})
15	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
16	add_subdirectory(${SUB_DIR})
17	endif()
18	endforeach()

Amath/affine_grid/op_api/aclnn_affine_grid.cpp+202-0

@@ -0,0 +1,202 @@
	1	/**
	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10
	11	/*!
	12	* \file aclnn_affine_grid.cpp
	13	* \brief
	14	*/
	15
	16	#include "aclnn_affine_grid.h"
	17	#include "aclnn_kernels/contiguous.h"
	18	#include "affine_grid.h"
	19	#include "aclnn_kernels/reshape.h"
	20	#include "aclnn_kernels/common/op_error_check.h"
	21	#include "opdev/common_types.h"
	22	#include "opdev/data_type_utils.h"
	23	#include "opdev/format_utils.h"
	24	#include "opdev/op_dfx.h"
	25	#include "opdev/op_executor.h"
	26	#include "opdev/make_op_executor.h"
	27	#include "opdev/op_log.h"
	28	#include "opdev/shape_utils.h"
	29	#include "opdev/tensor_view_utils.h"
	30
	31	using namespace op;
	32	#ifdef __cplusplus
	33	extern "C" {
	34	#endif
	35
	36	static const size_t DIM_LEN = 3;
	37	static const int64_t DIM_N = 0;
	38	static const int64_t DIM_C = 1;
	39	static const int64_t DIM_D = 2;
	40	static const int64_t DIM_H = 3;
	41	static const int64_t DIM_W = 4;
	42	static const int64_t DIM_H_2D = 2;
	43	static const int64_t DIM_W_2D = 3;
	44	static const int64_t AXIS_2D = 2;
	45	static const int64_t AXIS = 3;
	46	static const int64_t SECOND_DIM = 2;
	47
	48	// 根据API定义，需要列出所能支持的所有dtype，算子只支持AICPU
	49	static const std::initializer_list<op::DataType> ASCEND910_DTYPE_SUPPORT_LIST = {op::DataType::DT_FLOAT,
	50	op::DataType::DT_FLOAT16};
	51
	52	static const std::initializer_list<op::DataType> ASCEND910B_DTYPE_SUPPORT_LIST = {
	53	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};
	54
	55	static inline bool CheckNotNull(const aclTensor* theta, const aclIntArray* size, const aclTensor* out)
	56	{
	57	OP_CHECK_NULL(theta, return false);
	58	OP_CHECK_NULL(size, return false);
	59	OP_CHECK_NULL(out, return false);
	60	return true;
	61	}
	62
	63	static inline bool CheckDtypeValid(const aclTensor* theta, const aclTensor* out)
	64	{
	65	// 根据芯片类型获取数据类型支持列表
	66	bool isAscend910BSocVersion = (GetCurrentPlatformInfo().GetSocVersion() >= SocVersion::ASCEND910B &&
	67	GetCurrentPlatformInfo().GetSocVersion() <= SocVersion::ASCEND910E);
	68	const std::initializer_list<op::DataType> dtypeSupportList = isAscend910BSocVersion ?
	69	ASCEND910B_DTYPE_SUPPORT_LIST :
	70	ASCEND910_DTYPE_SUPPORT_LIST;
	71	// 检查theta的数据类型是否在算子的支持列表内
	72	OP_CHECK_DTYPE_NOT_SUPPORT(theta, dtypeSupportList, return false);
	73	// 检查out的数据类型是否与self一致
	74	OP_CHECK_DTYPE_NOT_MATCH(out, theta->GetDataType(), return false);
	75	return true;
	76	}
	77
	78	static bool CheckShape(const aclTensor* theta, const aclIntArray* size, const aclTensor* out)
	79	{
	80	if (theta->IsEmpty()) {
	81	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Expected theta to be not null tensor.");
	82	return false;
	83	}
	84	// size的大小是4或者5
	85	if (size->Size() == 4) { // size的大小是4时，theta的维度为(N, 2, 3)
	86	if (theta->GetViewShape().GetDimNum() != DIM_LEN \|\| theta->GetViewShape().GetDim(1) != DIM_H_2D \|\|
	87	theta->GetViewShape().GetDim(SECOND_DIM) != DIM_W_2D \|\|
	88	theta->GetViewShape().GetDim(DIM_N) != (*size)[DIM_N]) {
	89	OP_LOGE(ACLNN_ERR_PARAM_INVALID,
	90	"Expected a batch of 2D affine matrices of shape Nx2x3 for size "
	91	"[%ld, %ld, %ld, %ld]. Got %s.",
	92	(size)[DIM_N], (size)[DIM_C], (size)[DIM_H_2D], (size)[DIM_W_2D],
	93	op::ToString(theta->GetViewShape()).GetString());
	94	return false;
	95	}
	96	op::Shape outShape;
	97	outShape.AppendDim((*size)[DIM_N]);
	98	outShape.AppendDim((*size)[DIM_H_2D]);
	99	outShape.AppendDim((*size)[DIM_W_2D]);
	100	outShape.AppendDim(AXIS_2D);
	101	OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(out, outShape, return false);
	102	} else if (size->Size() == 5) { // size的大小是5时，theta的维度为(N, 3, 4)
	103	if (theta->GetViewShape().GetDimNum() != DIM_LEN \|\| theta->GetViewShape().GetDim(1) != DIM_H \|\|
	104	theta->GetViewShape().GetDim(SECOND_DIM) != DIM_W \|\|
	105	theta->GetViewShape().GetDim(DIM_N) != (*size)[DIM_N]) {
	106	OP_LOGE(ACLNN_ERR_PARAM_INVALID,
	107	"Expected a batch of 3D affine matrices of shape Nx3x4 for size "
	108	"[%ld, %ld, %ld, %ld, %ld]. Got %s.",
	109	(size)[DIM_N], (size)[DIM_C], (size)[DIM_D], (size)[DIM_H], (*size)[DIM_W],
	110	op::ToString(theta->GetViewShape()).GetString());
	111	return false;
	112	}
	113	op::Shape outShape;
	114	outShape.AppendDim((*size)[DIM_N]);
	115	outShape.AppendDim((*size)[DIM_D]);
	116	outShape.AppendDim((*size)[DIM_H]);
	117	outShape.AppendDim((*size)[DIM_W]);
	118	outShape.AppendDim(AXIS);
	119	OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(out, outShape, return false);
	120	} else {
	121	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "AffineGridGenerator needs 4d or 5d size(input).");
	122	return false;
	123	}
	124	return true;
	125	}
	126
	127	static void CheckFormat(const aclTensor* theta)
	128	{
	129	ge::Format thetaStorageFormat = theta->GetStorageFormat();
	130	if (thetaStorageFormat == ge::Format::FORMAT_FRACTAL_NZ) {
	131	OP_LOGW("aclnnAffineGrid doesn't support format NZ.");
	132	}
	133	}
	134
	135	static inline aclnnStatus CheckParams(const aclTensor* theta, const aclIntArray* size, const aclTensor* out)
	136	{
	137	// 1. 检查参数是否为空指针
	138	CHECK_RET(CheckNotNull(theta, size, out), ACLNN_ERR_PARAM_NULLPTR);
	139
	140	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验
	141	CHECK_RET(CheckDtypeValid(theta, out), ACLNN_ERR_PARAM_INVALID);
	142
	143	// 3. 检查tensor的维度
	144	CHECK_RET(CheckShape(theta, size, out), ACLNN_ERR_PARAM_INVALID);
	145
	146	return ACLNN_SUCCESS;
	147	}
	148
	149	aclnnStatus aclnnAffineGridGetWorkspaceSize(const aclTensor* theta, const aclIntArray* size, bool alignCorners,
	150	aclTensor* out, uint64_t* workspaceSize, aclOpExecutor** executor)
	151	{
	152	OP_CHECK_COMM_INPUT(workspaceSize, executor);
	153
	154	L2_DFX_PHASE_1(aclnnAffineGrid, DFX_IN(theta, size, alignCorners), DFX_OUT(out));
	155	// 固定写法，创建OpExecutor
	156	auto uniqueExecutor = CREATE_EXECUTOR();
	157	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
	158
	159	// 固定写法，参数检查
	160	auto ret = CheckParams(theta, size, out);
	161	CHECK_RET(ret == ACLNN_SUCCESS, ret);
	162
	163	// 检查格式
	164	CheckFormat(theta);
	165
	166	// 固定写法，将输入theta转换成连续的tensor
	167	auto thetaContiguous = l0op::Contiguous(theta, uniqueExecutor.get());
	168	CHECK_RET(thetaContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
	169
	170	// 进行AffineGrid计算
	171	const aclTensor* affineGridOut = l0op::AffineGrid(thetaContiguous, size, alignCorners, uniqueExecutor.get());
	172	CHECK_RET(affineGridOut != nullptr, ACLNN_ERR_PARAM_NULLPTR);
	173
	174	// size的大小是4时，输出的维度为(N, H, W, 2);size的大小是5时，输出的维度为(N, D, H, W, 3)
	175	const int64_t dim5Shape[] = {(size)[DIM_N], (size)[DIM_D], (size)[DIM_H], (size)[DIM_W], AXIS};
	176	const int64_t dim4Shape[] = {(size)[DIM_N], (size)[DIM_H_2D], (*size)[DIM_W_2D], AXIS_2D};
	177
	178	auto outReshape = l0op::Reshape(
	179	affineGridOut, uniqueExecutor.get()->AllocIntArray((size->Size() == 4) ? dim4Shape : dim5Shape, size->Size()),
	180	uniqueExecutor.get());
	181	CHECK_RET(outReshape != nullptr, ACLNN_ERR_INNER_NULLPTR);
	182
	183	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor
	184	auto viewCopyMinResult = l0op::ViewCopy(outReshape, out, uniqueExecutor.get());
	185	CHECK_RET(viewCopyMinResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
	186
	187	// 固定写法，获取计算过程中需要使用的workspace大小
	188	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
	189	uniqueExecutor.ReleaseTo(executor);
	190	return ACLNN_SUCCESS;
	191	}
	192
	193	aclnnStatus aclnnAffineGrid(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
	194	{
	195	L2_DFX_PHASE_2(aclnnAffineGrid);
	196	// 固定写法，调用框架能力，完成计算
	197	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
	198	}
	199
	200	#ifdef __cplusplus
	201	}
	202	#endif

Rmath/affine_grid/op_host/op_api/aclnn_affine_grid.h→math/affine_grid/op_api/aclnn_affine_grid.h+1-1

	@@ -55,4 +55,4 @@ ACLNN_API aclnnStatus aclnnAffineGrid(void* workspace, uint64_t workspaceSize, a
55	}	55	}
56	#endif	56	#endif
57		57
58	#endif // OP_API_INC_AFFINE_GRID_H_	58	#endif // OP_API_INC_AFFINE_GRID_H_

Rmath/affine_grid/op_host/op_api/affine_grid.cpp→math/affine_grid/op_api/affine_grid.cpp+21-19

	@@ -30,27 +30,29 @@ namespace l0op {
30	OP_TYPE_REGISTER(AffineGrid);	30	OP_TYPE_REGISTER(AffineGrid);
31		31
32	// AICPU算子kernel	32	// AICPU算子kernel
33	static const aclTensor* AffineGridAiCpu(const aclTensor theta, const aclTensor size, bool alignCorners,	33	static const aclTensor* AffineGridAiCpu(const aclTensor* theta, const aclTensor* size, bool alignCorners,
34	aclTensor* out, aclOpExecutor* executor) {	34	aclTensor* out, aclOpExecutor* executor)
35	L0_DFX(AffineGridAiCpu, theta, size, alignCorners, out);	35	{
36	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICPU，将AiCpu Arange算子加入任务队列	36	L0_DFX(AffineGridAiCpu, theta, size, alignCorners, out);
37	static internal::AicpuTaskSpace space("AffineGrid");	37	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICPU，将AiCpu Arange算子加入任务队列
38	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(AffineGrid, OP_ATTR_NAMES({"align_corners"}), OP_INPUT(theta, size),	38	static internal::AicpuTaskSpace space("AffineGrid");
39	OP_OUTPUT(out), OP_ATTR(alignCorners));	39	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(AffineGrid, OP_ATTR_NAMES({"align_corners"}), OP_INPUT(theta, size),
40	OP_CHECK(ret == ACL_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "AffineGridAiCpu ADD_TO_LAUNCHER_LIST_AICPU failed."), return nullptr);	40	OP_OUTPUT(out), OP_ATTR(alignCorners));
41	return out;	41	OP_CHECK(ret == ACL_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "AffineGridAiCpu ADD_TO_LAUNCHER_LIST_AICPU failed."),
		42	return nullptr);
		43	return out;
42	}	44	}
43		45
44	const aclTensor AffineGrid(const aclTensor theta, const aclIntArray *size, bool alignCorners,	46	const aclTensor* AffineGrid(const aclTensor* theta, const aclIntArray* size, bool alignCorners, aclOpExecutor* executor)
45	aclOpExecutor *executor) {	47	{
46	auto sizeTensor = executor->ConvertToTensor(size, DataType::DT_INT32);	48	auto sizeTensor = executor->ConvertToTensor(size, DataType::DT_INT32);
47		49
48	op::Shape outShape;	50	op::Shape outShape;
49	outShape.AppendDim((*size)[0]);	51	outShape.AppendDim((*size)[0]);
50	outShape.AppendDim(size->Size() == 4 ? (size)[2] (size)[3] : (size)[2] * (size)[3] (*size)[4]);	52	outShape.AppendDim(size->Size() == 4 ? (size)[2] (size)[3] : (size)[2] * (size)[3] (*size)[4]);
51	outShape.AppendDim(size->Size() == 4 ? 2 : 3);	53	outShape.AppendDim(size->Size() == 4 ? 2 : 3);
52	auto out = executor->AllocTensor(outShape, theta->GetDataType());	54	auto out = executor->AllocTensor(outShape, theta->GetDataType());
53		55
54	return AffineGridAiCpu(theta, sizeTensor, alignCorners, out, executor);	56	return AffineGridAiCpu(theta, sizeTensor, alignCorners, out, executor);
55	}	57	}
56	} // namespace l0op	58	} // namespace l0op

Rmath/affine_grid/op_host/op_api/affine_grid.h→math/affine_grid/op_api/affine_grid.h+4-4

	@@ -19,8 +19,8 @@
19	#include "opdev/op_executor.h"	19	#include "opdev/op_executor.h"
20		20
21	namespace l0op {	21	namespace l0op {
22	const aclTensor AffineGrid(const aclTensor theta, const aclIntArray *size, bool alignCorners,	22	const aclTensor* AffineGrid(const aclTensor* theta, const aclIntArray* size, bool alignCorners,
23	aclOpExecutor *executor);	23	aclOpExecutor* executor);
24	} // l0op	24	} // namespace l0op
25		25
26	#endif // OP_API_INC_LEVEL0_AFFINE_GRID_H_	26	#endif // OP_API_INC_LEVEL0_AFFINE_GRID_H_

Dmath/affine_grid/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources()

Dmath/affine_grid/op_host/op_api/aclnn_affine_grid.cpp+0-188

	@@ -1,188 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10
11	/*!
12	* \file aclnn_affine_grid.cpp
13	* \brief
14	*/
15
16	#include "aclnn_affine_grid.h"
17	#include "aclnn_kernels/contiguous.h"
18	#include "affine_grid.h"
19	#include "aclnn_kernels/reshape.h"
20	#include "aclnn_kernels/common/op_error_check.h"
21	#include "opdev/common_types.h"
22	#include "opdev/data_type_utils.h"
23	#include "opdev/format_utils.h"
24	#include "opdev/op_dfx.h"
25	#include "opdev/op_executor.h"
26	#include "opdev/make_op_executor.h"
27	#include "opdev/op_log.h"
28	#include "opdev/shape_utils.h"
29	#include "opdev/tensor_view_utils.h"
30
31	using namespace op;
32	#ifdef __cplusplus
33	extern "C" {
34	#endif
35
36	static const size_t DIM_LEN = 3;
37	static const int64_t DIM_N = 0;
38	static const int64_t DIM_C = 1;
39	static const int64_t DIM_D = 2;
40	static const int64_t DIM_H = 3;
41	static const int64_t DIM_W = 4;
42	static const int64_t DIM_H_2D = 2;
43	static const int64_t DIM_W_2D = 3;
44	static const int64_t AXIS_2D = 2;
45	static const int64_t AXIS = 3;
46	static const int64_t SECOND_DIM = 2;
47
48	// 根据API定义，需要列出所能支持的所有dtype，算子只支持AICPU
49	static const std::initializer_list<op::DataType> ASCEND910_DTYPE_SUPPORT_LIST = {
50	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16};
51
52	static const std::initializer_list<op::DataType> ASCEND910B_DTYPE_SUPPORT_LIST = {
53	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};
54
55	static inline bool CheckNotNull(const aclTensor theta, const aclIntArray size, const aclTensor *out) {
56	OP_CHECK_NULL(theta, return false);
57	OP_CHECK_NULL(size, return false);
58	OP_CHECK_NULL(out, return false);
59	return true;
60	}
61
62	static inline bool CheckDtypeValid(const aclTensor theta, const aclTensor out) {
63	// 根据芯片类型获取数据类型支持列表
64	bool isAscend910BSocVersion = (GetCurrentPlatformInfo().GetSocVersion() >= SocVersion::ASCEND910B &&
65	GetCurrentPlatformInfo().GetSocVersion() <= SocVersion::ASCEND910E);
66	const std::initializer_list<op::DataType> dtypeSupportList =
67	isAscend910BSocVersion ? ASCEND910B_DTYPE_SUPPORT_LIST : ASCEND910_DTYPE_SUPPORT_LIST;
68	// 检查theta的数据类型是否在算子的支持列表内
69	OP_CHECK_DTYPE_NOT_SUPPORT(theta, dtypeSupportList, return false);
70	// 检查out的数据类型是否与self一致
71	OP_CHECK_DTYPE_NOT_MATCH(out, theta->GetDataType(), return false);
72	return true;
73	}
74
75	static bool CheckShape(const aclTensor theta, const aclIntArray size, const aclTensor *out) {
76	if (theta->IsEmpty()) {
77	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Expected theta to be not null tensor.");
78	return false;
79	}
80	// size的大小是4或者5
81	if (size->Size() == 4) { // size的大小是4时，theta的维度为(N, 2, 3)
82	if (theta->GetViewShape().GetDimNum() != DIM_LEN \|\| theta->GetViewShape().GetDim(1) != DIM_H_2D \|\|
83	theta->GetViewShape().GetDim(SECOND_DIM) != DIM_W_2D \|\| theta->GetViewShape().GetDim(DIM_N) != (*size)[DIM_N]) {
84	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Expected a batch of 2D affine matrices of shape Nx2x3 for size "
85	"[%ld, %ld, %ld, %ld]. Got %s.", (size)[DIM_N], (size)[DIM_C],
86	(size)[DIM_H_2D], (size)[DIM_W_2D], op::ToString(theta->GetViewShape()).GetString());
87	return false;
88	}
89	op::Shape outShape;
90	outShape.AppendDim((*size)[DIM_N]);
91	outShape.AppendDim((*size)[DIM_H_2D]);
92	outShape.AppendDim((*size)[DIM_W_2D]);
93	outShape.AppendDim(AXIS_2D);
94	OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(out, outShape, return false);
95	} else if (size->Size() == 5) { // size的大小是5时，theta的维度为(N, 3, 4)
96	if (theta->GetViewShape().GetDimNum() != DIM_LEN \|\| theta->GetViewShape().GetDim(1) != DIM_H \|\|
97	theta->GetViewShape().GetDim(SECOND_DIM) != DIM_W \|\| theta->GetViewShape().GetDim(DIM_N) != (*size)[DIM_N]) {
98	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Expected a batch of 3D affine matrices of shape Nx3x4 for size "
99	"[%ld, %ld, %ld, %ld, %ld]. Got %s.", (size)[DIM_N], (size)[DIM_C],
100	(size)[DIM_D], (size)[DIM_H], (*size)[DIM_W], op::ToString(theta->GetViewShape()).GetString());
101	return false;
102	}
103	op::Shape outShape;
104	outShape.AppendDim((*size)[DIM_N]);
105	outShape.AppendDim((*size)[DIM_D]);
106	outShape.AppendDim((*size)[DIM_H]);
107	outShape.AppendDim((*size)[DIM_W]);
108	outShape.AppendDim(AXIS);
109	OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(out, outShape, return false);
110	} else {
111	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "AffineGridGenerator needs 4d or 5d size(input).");
112	return false;
113	}
114	return true;
115	}
116
117	static void CheckFormat(const aclTensor* theta) {
118	ge::Format thetaStorageFormat = theta->GetStorageFormat();
119	if (thetaStorageFormat == ge::Format::FORMAT_FRACTAL_NZ) {
120	OP_LOGW("aclnnAffineGrid doesn't support format NZ.");
121	}
122	}
123
124	static inline aclnnStatus CheckParams(const aclTensor theta, const aclIntArray size, const aclTensor *out) {
125	// 1. 检查参数是否为空指针
126	CHECK_RET(CheckNotNull(theta, size, out), ACLNN_ERR_PARAM_NULLPTR);
127
128	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验
129	CHECK_RET(CheckDtypeValid(theta, out), ACLNN_ERR_PARAM_INVALID);
130
131	// 3. 检查tensor的维度
132	CHECK_RET(CheckShape(theta, size, out), ACLNN_ERR_PARAM_INVALID);
133
134	return ACLNN_SUCCESS;
135	}
136
137	aclnnStatus aclnnAffineGridGetWorkspaceSize(const aclTensor theta, const aclIntArray size, bool alignCorners,
138	aclTensor out, uint64_t workspaceSize, aclOpExecutor **executor) {
139	OP_CHECK_COMM_INPUT(workspaceSize, executor);
140
141	L2_DFX_PHASE_1(aclnnAffineGrid, DFX_IN(theta, size, alignCorners), DFX_OUT(out));
142	// 固定写法，创建OpExecutor
143	auto uniqueExecutor = CREATE_EXECUTOR();
144	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
145
146	// 固定写法，参数检查
147	auto ret = CheckParams(theta, size, out);
148	CHECK_RET(ret == ACLNN_SUCCESS, ret);
149
150	// 检查格式
151	CheckFormat(theta);
152
153	// 固定写法，将输入theta转换成连续的tensor
154	auto thetaContiguous = l0op::Contiguous(theta, uniqueExecutor.get());
155	CHECK_RET(thetaContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
156
157	// 进行AffineGrid计算
158	const aclTensor *affineGridOut = l0op::AffineGrid(thetaContiguous, size, alignCorners, uniqueExecutor.get());
159	CHECK_RET(affineGridOut != nullptr, ACLNN_ERR_PARAM_NULLPTR);
160
161	// size的大小是4时，输出的维度为(N, H, W, 2);size的大小是5时，输出的维度为(N, D, H, W, 3)
162	const int64_t dim5Shape[] = {(size)[DIM_N], (size)[DIM_D], (size)[DIM_H], (size)[DIM_W], AXIS};
163	const int64_t dim4Shape[] = {(size)[DIM_N], (size)[DIM_H_2D], (*size)[DIM_W_2D], AXIS_2D};
164
165	auto outReshape = l0op::Reshape(affineGridOut, uniqueExecutor.get()->AllocIntArray((size->Size() == 4) ? dim4Shape :
166	dim5Shape, size->Size()),
167	uniqueExecutor.get());
168	CHECK_RET(outReshape != nullptr, ACLNN_ERR_INNER_NULLPTR);
169
170	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor
171	auto viewCopyMinResult = l0op::ViewCopy(outReshape, out, uniqueExecutor.get());
172	CHECK_RET(viewCopyMinResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
173
174	// 固定写法，获取计算过程中需要使用的workspace大小
175	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
176	uniqueExecutor.ReleaseTo(executor);
177	return ACLNN_SUCCESS;
178	}
179
180	aclnnStatus aclnnAffineGrid(void workspace, uint64_t workspaceSize, aclOpExecutor executor, aclrtStream stream) {
181	L2_DFX_PHASE_2(aclnnAffineGrid);
182	// 固定写法，调用框架能力，完成计算
183	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
184	}
185
186	#ifdef __cplusplus
187	}
188	#endif

Mmath/amp_update_scale/CMakeLists.txt+1-9

	@@ -8,12 +8,4 @@
8	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
10		10
11	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE amp_update_scale ACLNNTYPE aclnn)
12	if(NOT ENABLE_TEST)
13	list(REMOVE_ITEM CURRENT_DIRS tests)
14	endif()
15	foreach(SUB_DIR ${CURRENT_DIRS})
16	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
17	add_subdirectory(${SUB_DIR})
18	endif()
19	endforeach()

Dmath/amp_update_scale/op_host/CMakeLists.txt+0-11

	@@ -1,11 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# Copyright (c) 2026 Huawei Technologies Co., Ltd.
3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	# CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------
10
11	add_modules_sources(OPTYPE amp_update_scale ACLNNTYPE aclnn)

Dmath/amp_update_scale/tests/ut/CMakeLists.txt+0-16

	@@ -1,16 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# Copyright (c) 2026 Huawei Technologies Co., Ltd.
3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	# CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------
10
11	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
12	foreach(SUB_DIR ${CURRENT_DIRS})
13	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
14	add_subdirectory(${SUB_DIR})
15	endif()
16	endforeach()

Mmath/amp_update_scale/tests/ut/op_host/test_amp_update_scale_tiling.cpp+53-70

	@@ -16,45 +16,36 @@
16		16
17	using namespace std;	17	using namespace std;
18	using namespace ge;	18	using namespace ge;
19	using optiling::AmpUpdateScaleCompileInfo;	19
		20	struct AmpUpdateScaleCompileInfo {};
20		21
21	class AmpUpdateScaleTilingTest : public testing::Test {	22	class AmpUpdateScaleTilingTest : public testing::Test {
22	protected:	23	protected:
23	static void SetUpTestCase()	24	static void SetUpTestCase() { std::cout << "AmpUpdateScaleTiling SetUp" << std::endl; }
24	{
25	std::cout << "AmpUpdateScaleTiling SetUp" << std::endl;
26	}
27		25
28	static void TearDownTestCase()	26	static void TearDownTestCase() { std::cout << "AmpUpdateScaleTiling TearDown" << std::endl; }
29	{
30	std::cout << "AmpUpdateScaleTiling TearDown" << std::endl;
31	}
32	};	27	};
33		28
34	TEST_F(AmpUpdateScaleTilingTest, amp_update_scale_fp32_basic)	29	TEST_F(AmpUpdateScaleTilingTest, amp_update_scale_fp32_basic)
35	{	30	{
36	AmpUpdateScaleCompileInfo compileInfo;	31	AmpUpdateScaleCompileInfo compileInfo;
37		32
38	gert::TilingContextPara tilingContextPara(	33	gert::TilingContextPara tilingContextPara("AmpUpdateScale",
39	"AmpUpdateScale",	34	{
40	{	35	{{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
41	{{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},	36	{{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},
42	{{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},	37	{{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
43	{{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},	38	},
44	},	39	{
45	{	40	{{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
46	{{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},	41	{{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},
47	{{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},	42	},
48	},	43	{
49	{	44	{"growth_factor", Ops::Math::AnyValue::CreateFrom<float>(2.0f)},
50	{"growth_factor", ge::AnyValue::CreateFrom<ge::AnyValue::FLOAT>(2.0f)},	45	{"backoff_factor", Ops::Math::AnyValue::CreateFrom<float>(0.5f)},
51	{"backoff_factor", ge::AnyValue::CreateFrom<ge::AnyValue::FLOAT>(0.5f)},	46	{"growth_interval", Ops::Math::AnyValue::CreateFrom<int64_t>(5)},
52	{"growth_interval", ge::AnyValue::CreateFrom<ge::AnyValue::INT>(5)},	47	},
53	},	48	&compileInfo, 40, 196608, 4096);
54	&compileInfo,
55	40,
56	196608,
57	4096);
58		49
59	uint64_t expectTilingKey = 0;	50	uint64_t expectTilingKey = 0;
60	std::vector<size_t> expectWorkspaces = {0};	51	std::vector<size_t> expectWorkspaces = {0};
	@@ -65,26 +56,22 @@ TEST_F(AmpUpdateScaleTilingTest, amp_update_scale_fp16_basic)
65	{	56	{
66	AmpUpdateScaleCompileInfo compileInfo;	57	AmpUpdateScaleCompileInfo compileInfo;
67		58
68	gert::TilingContextPara tilingContextPara(	59	gert::TilingContextPara tilingContextPara("AmpUpdateScale",
69	"AmpUpdateScale",	60	{
70	{	61	{{{1}, {1}}, ge::DT_FLOAT16, ge::FORMAT_ND},
71	{{{1}, {1}}, ge::DT_FLOAT16, ge::FORMAT_ND},	62	{{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},
72	{{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},	63	{{{1}, {1}}, ge::DT_FLOAT16, ge::FORMAT_ND},
73	{{{1}, {1}}, ge::DT_FLOAT16, ge::FORMAT_ND},	64	},
74	},	65	{
75	{	66	{{{1}, {1}}, ge::DT_FLOAT16, ge::FORMAT_ND},
76	{{{1}, {1}}, ge::DT_FLOAT16, ge::FORMAT_ND},	67	{{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},
77	{{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},	68	},
78	},	69	{
79	{	70	{"growth_factor", Ops::Math::AnyValue::CreateFrom<float>(2.0f)},
80	{"growth_factor", ge::AnyValue::CreateFrom<ge::AnyValue::FLOAT>(2.0f)},	71	{"backoff_factor", Ops::Math::AnyValue::CreateFrom<float>(0.5f)},
81	{"backoff_factor", ge::AnyValue::CreateFrom<ge::AnyValue::FLOAT>(0.5f)},	72	{"growth_interval", Ops::Math::AnyValue::CreateFrom<int64_t>(3)},
82	{"growth_interval", ge::AnyValue::CreateFrom<ge::AnyValue::INT>(3)},	73	},
83	},	74	&compileInfo, 40, 196608, 4096);
84	&compileInfo,
85	40,
86	196608,
87	4096);
88		75
89	uint64_t expectTilingKey = 1;	76	uint64_t expectTilingKey = 1;
90	std::vector<size_t> expectWorkspaces = {0};	77	std::vector<size_t> expectWorkspaces = {0};
	@@ -95,28 +82,24 @@ TEST_F(AmpUpdateScaleTilingTest, amp_update_scale_bf16_basic)
95	{	82	{
96	AmpUpdateScaleCompileInfo compileInfo;	83	AmpUpdateScaleCompileInfo compileInfo;
97		84
98	gert::TilingContextPara tilingContextPara(	85	gert::TilingContextPara tilingContextPara("AmpUpdateScale",
99	"AmpUpdateScale",	86	{
100	{	87	{{{1}, {1}}, ge::DT_BF16, ge::FORMAT_ND},
101	{{{1}, {1}}, ge::DT_BF16, ge::FORMAT_ND},	88	{{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},
102	{{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},	89	{{{1}, {1}}, ge::DT_BF16, ge::FORMAT_ND},
103	{{{1}, {1}}, ge::DT_BF16, ge::FORMAT_ND},	90	},
104	},	91	{
105	{	92	{{{1}, {1}}, ge::DT_BF16, ge::FORMAT_ND},
106	{{{1}, {1}}, ge::DT_BF16, ge::FORMAT_ND},	93	{{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},
107	{{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},	94	},
108	},	95	{
109	{	96	{"growth_factor", Ops::Math::AnyValue::CreateFrom<float>(2.0f)},
110	{"growth_factor", ge::AnyValue::CreateFrom<ge::AnyValue::FLOAT>(2.0f)},	97	{"backoff_factor", Ops::Math::AnyValue::CreateFrom<float>(0.5f)},
111	{"backoff_factor", ge::AnyValue::CreateFrom<ge::AnyValue::FLOAT>(0.5f)},	98	{"growth_interval", Ops::Math::AnyValue::CreateFrom<int64_t>(10)},
112	{"growth_interval", ge::AnyValue::CreateFrom<ge::AnyValue::INT>(10)},	99	},
113	},	100	&compileInfo, 40, 196608, 4096);
114	&compileInfo,
115	40,
116	196608,
117	4096);
118		101
119	uint64_t expectTilingKey = 2;	102	uint64_t expectTilingKey = 2;
120	std::vector<size_t> expectWorkspaces = {0};	103	std::vector<size_t> expectWorkspaces = {0};
121	ExecuteTestCase(tilingContextPara, ge::GRAPH_SUCCESS, expectTilingKey, expectWorkspaces);	104	ExecuteTestCase(tilingContextPara, ge::GRAPH_SUCCESS, expectTilingKey, expectWorkspaces);
122	}	105	}

Mmath/angle_v2/CMakeLists.txt+3-12

	@@ -1,20 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11		10
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE angle_v2 ACLNNTYPE aclnn)
13	if(NOT ENABLE_TEST)
14	list(REMOVE_ITEM CURRENT_DIRS tests)
15	endif()
16	foreach(SUB_DIR ${CURRENT_DIRS})
17	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
18	add_subdirectory(${SUB_DIR})
19	endif()
20	endforeach()

Dmath/angle_v2/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources(OPTYPE angle_v2 ACLNNTYPE aclnn)

Dmath/angle_v2/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/angle_v2/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/angle_v2/tests/ut/op_host/CMakeLists.txt+0-22

	@@ -1,22 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	if(UT_TEST_ALL OR OP_HOST_UT)
13	add_modules_ut_sources(UT_NAME ${OP_TILING_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
14	add_modules_ut_sources(UT_NAME ${OP_INFERSHAPE_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
15	endif()
16
17	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
18	foreach(SUB_DIR ${CURRENT_DIRS})
19	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
20	add_subdirectory(${SUB_DIR})
21	endif()
22	endforeach()

Rmath/asin/tests/ut/op_host/op_api/test_asin.cpp→math/asin/tests/ut/op_api/test_asin.cpp+2-2

	@@ -11,7 +11,7 @@
11	#include <array>	11	#include <array>
12	#include "gtest/gtest.h"	12	#include "gtest/gtest.h"
13		13
14	#include "../../../../op_api/aclnn_asin.h"	14	#include "../../../op_api/aclnn_asin.h"
15		15
16	#include "op_api_ut_common/op_api_ut.h"	16	#include "op_api_ut_common/op_api_ut.h"
17	#include "op_api_ut_common/scalar_desc.h"	17	#include "op_api_ut_common/scalar_desc.h"
	@@ -420,4 +420,4 @@ TEST_F(l2_asin_test, case_33)
420	uint64_t workspaceSize = 0;	420	uint64_t workspaceSize = 0;
421	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);	421	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
422	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);	422	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
423	}	423	}

Dmath/asinh/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/asinh/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Amath/asinh/tests/ut/op_api/test_asinh.cpp+157-0

@@ -0,0 +1,157 @@
	1	/**
	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10	#include <array>
	11	#include <vector>
	12	#include "gtest/gtest.h"
	13
	14	#include "../../../../op_api/aclnn_asinh.h"
	15
	16	#include "op_api_ut_common/inner/types.h"
	17	#include "op_api_ut_common/op_api_ut.h"
	18	#include "op_api_ut_common/scalar_desc.h"
	19	#include "op_api_ut_common/tensor_desc.h"
	20
	21	using namespace std;
	22
	23	class l2_asinh_test : public testing::Test {
	24	protected:
	25	static void SetUpTestCase() { cout << "l2_asinh_test SetUp" << endl; }
	26
	27	static void TearDownTestCase() { cout << "l2_asinh_test TearDown" << endl; }
	28	};
	29
	30	TEST_F(l2_asinh_test, ascend910B2_asinh_dtype_all)
	31	{
	32	vector<aclDataType> INPUT_VALID_DTYPE_LIST{ACL_INT8, ACL_INT32, ACL_UINT8, ACL_INT16,
	33	ACL_INT64, ACL_BOOL, ACL_FLOAT, ACL_FLOAT16,
	34	ACL_DOUBLE, ACL_COMPLEX64, ACL_COMPLEX128, ACL_BF16};
	35	vector<aclDataType> OUTPUT__VALID_DTYPE_LIST{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE,
	36	ACL_COMPLEX64, ACL_COMPLEX128, ACL_BF16};
	37
	38	for (auto dtype1 : INPUT_VALID_DTYPE_LIST) {
	39	auto self_tensor_desc = TensorDesc({3, 5}, dtype1, ACL_FORMAT_ND).ValueRange(-2, 2);
	40	for (auto dtype2 : OUTPUT__VALID_DTYPE_LIST) {
	41	if ((dtype1 == ACL_COMPLEX64 \|\| dtype1 == ACL_COMPLEX128) &&
	42	(dtype2 != ACL_COMPLEX64 \|\| dtype2 != ACL_COMPLEX128)) {
	43	continue;
	44	}
	45
	46	auto out_tensor_desc = TensorDesc({3, 5}, dtype2, ACL_FORMAT_ND).Precision(0.001, 0.001);
	47	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	48	uint64_t workspace_size = 0;
	49	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	50	EXPECT_EQ(aclRet, ACL_SUCCESS);
	51	}
	52	}
	53	}
	54
	55	TEST_F(l2_asinh_test, asinh_different_shape)
	56	{
	57	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	58	auto out_tensor_desc = TensorDesc({2, 5}, ACL_FLOAT, ACL_FORMAT_ND);
	59
	60	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	61	uint64_t workspace_size = 0;
	62	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	63	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	64	}
	65
	66	TEST_F(l2_asinh_test, asinh_nullptr)
	67	{
	68	auto ut = OP_API_UT(aclnnAsinh, INPUT((aclTensor)nullptr), OUTPUT((aclTensor)nullptr));
	69	uint64_t workspace_size = 0;
	70	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	71	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	72	}
	73
	74	TEST_F(l2_asinh_test, asinh_out_nullptr)
	75	{
	76	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	77	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(nullptr));
	78	uint64_t workspaceSize = 0;
	79	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	80	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	81	}
	82
	83	TEST_F(l2_asinh_test, asinh_precision)
	84	{
	85	auto self_tensor_desc = TensorDesc({3, 6, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	86	auto out_tensor_desc = TensorDesc({3, 6, 9}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.0001, 0.0001);
	87
	88	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	89	uint64_t workspace_size = 0;
	90	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	91	EXPECT_EQ(aclRet, ACL_SUCCESS);
	92	}
	93
	94	TEST_F(l2_asinh_test, ascend910B2_asinh_bf16_precision)
	95	{
	96	auto self_tensor_desc = TensorDesc({3, 6, 9}, ACL_BF16, ACL_FORMAT_ND).ValueRange(-2, 2);
	97	auto out_tensor_desc = TensorDesc({3, 6, 9}, ACL_BF16, ACL_FORMAT_ND).Precision(0.0001, 0.0001);
	98
	99	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	100	uint64_t workspace_size = 0;
	101	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	102	EXPECT_EQ(aclRet, ACL_SUCCESS);
	103	}
	104
	105	TEST_F(l2_asinh_test, asinh_empty_tensor)
	106	{
	107	auto self_tensor_desc = TensorDesc({13, 0, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	108	auto out_tensor_desc = TensorDesc({13, 0, 9}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	109
	110	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	111	uint64_t workspace_size = 0;
	112	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	113	EXPECT_EQ(aclRet, ACL_SUCCESS);
	114	}
	115
	116	TEST_F(l2_asinh_test, asinh_non_contiguous)
	117	{
	118	auto self_tensor_desc = TensorDesc({5, 3}, ACL_FLOAT, ACL_FORMAT_ND, {1, 5}, 0, {3, 5}).ValueRange(-2, 2);
	119	auto out_tensor_desc = TensorDesc({5, 3}, ACL_FLOAT, ACL_FORMAT_ND, {1, 5}, 0, {3, 5}).Precision(0.001, 0.001);
	120
	121	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	122	uint64_t workspace_size = 0;
	123	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	124	EXPECT_EQ(aclRet, ACL_SUCCESS);
	125	}
	126
	127	TEST_F(l2_asinh_test, asinh_lessDim)
	128	{
	129	auto self_tensor_desc = TensorDesc({2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	130	auto out_tensor_desc = TensorDesc({2}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	131
	132	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	133	uint64_t workspace_size = 0;
	134	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	135	EXPECT_EQ(aclRet, ACL_SUCCESS);
	136	}
	137
	138	TEST_F(l2_asinh_test, asinh_bigDim)
	139	{
	140	auto self_tensor_desc = TensorDesc({2, 2, 2, 2, 2, 2, 2, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	141	auto out_tensor_desc = TensorDesc({2, 2, 2, 2, 2, 2, 2, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
	142
	143	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	144	uint64_t workspace_size = 0;
	145	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	146	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	147	}
	148
	149	TEST_F(l2_asinh_test, asinh_inplace)
	150	{
	151	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	152	auto ut = OP_API_UT(aclnnInplaceAsinh, INPUT(self_tensor_desc), OUTPUT());
	153
	154	uint64_t workspace_size = 0;
	155	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	156	EXPECT_EQ(aclRet, ACL_SUCCESS);
	157	}

Dmath/asinh/tests/ut/op_host/CMakeLists.txt+0-20

	@@ -1,20 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()
18
19	if(OP_API_UT OR (UT_TEST_ALL AND NOT AICPU_ONLY))
20	endif()

Dmath/asinh/tests/ut/op_host/op_api/CMakeLists.txt+0-10

	@@ -1,10 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------

Dmath/asinh/tests/ut/op_host/op_api/test_asinh.cpp+0-148

	@@ -1,148 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10	#include <array>
11	#include <vector>
12	#include "gtest/gtest.h"
13
14	#include "../../../../op_api/aclnn_asinh.h"
15
16	#include "op_api_ut_common/inner/types.h"
17	#include "op_api_ut_common/op_api_ut.h"
18	#include "op_api_ut_common/scalar_desc.h"
19	#include "op_api_ut_common/tensor_desc.h"
20
21	using namespace std;
22
23	class l2_asinh_test : public testing::Test {
24	protected:
25	static void SetUpTestCase() {
26	cout << "l2_asinh_test SetUp" << endl;
27	}
28
29	static void TearDownTestCase() {
30	cout << "l2_asinh_test TearDown" << endl;
31	}
32	};
33
34	TEST_F(l2_asinh_test, ascend910B2_asinh_dtype_all) {
35	vector<aclDataType> INPUT_VALID_DTYPE_LIST{ACL_INT8, ACL_INT32, ACL_UINT8, ACL_INT16, ACL_INT64, ACL_BOOL,
36	ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_COMPLEX64, ACL_COMPLEX128, ACL_BF16};
37	vector<aclDataType> OUTPUT__VALID_DTYPE_LIST{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_COMPLEX64, ACL_COMPLEX128, ACL_BF16};
38
39	for (auto dtype1 : INPUT_VALID_DTYPE_LIST) {
40	auto self_tensor_desc = TensorDesc({3, 5}, dtype1, ACL_FORMAT_ND).ValueRange(-2, 2);
41	for (auto dtype2 : OUTPUT__VALID_DTYPE_LIST) {
42	if ((dtype1 == ACL_COMPLEX64 \|\| dtype1 == ACL_COMPLEX128) &&
43	(dtype2 != ACL_COMPLEX64 \|\| dtype2 != ACL_COMPLEX128)) {
44	continue;
45	}
46
47	auto out_tensor_desc = TensorDesc({3, 5}, dtype2, ACL_FORMAT_ND).Precision(0.001, 0.001);
48	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
49	uint64_t workspace_size = 0;
50	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
51	EXPECT_EQ(aclRet, ACL_SUCCESS);
52	}
53	}
54	}
55
56	TEST_F(l2_asinh_test, asinh_different_shape) {
57	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
58	auto out_tensor_desc = TensorDesc({2, 5}, ACL_FLOAT, ACL_FORMAT_ND);
59
60	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
61	uint64_t workspace_size = 0;
62	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
63	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
64	}
65
66	TEST_F(l2_asinh_test, asinh_nullptr) {
67	auto ut = OP_API_UT(aclnnAsinh, INPUT((aclTensor)nullptr), OUTPUT((aclTensor)nullptr));
68	uint64_t workspace_size = 0;
69	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
70	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
71	}
72
73	TEST_F(l2_asinh_test, asinh_out_nullptr) {
74	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
75	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(nullptr));
76	uint64_t workspaceSize = 0;
77	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
78	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
79	}
80
81	TEST_F(l2_asinh_test, asinh_precision) {
82	auto self_tensor_desc = TensorDesc({3, 6, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
83	auto out_tensor_desc = TensorDesc({3, 6, 9}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.0001, 0.0001);
84
85	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
86	uint64_t workspace_size = 0;
87	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
88	EXPECT_EQ(aclRet, ACL_SUCCESS);
89	}
90
91	TEST_F(l2_asinh_test, ascend910B2_asinh_bf16_precision) {
92	auto self_tensor_desc = TensorDesc({3, 6, 9}, ACL_BF16, ACL_FORMAT_ND).ValueRange(-2, 2);
93	auto out_tensor_desc = TensorDesc({3, 6, 9}, ACL_BF16, ACL_FORMAT_ND).Precision(0.0001, 0.0001);
94
95	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
96	uint64_t workspace_size = 0;
97	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
98	EXPECT_EQ(aclRet, ACL_SUCCESS);
99	}
100
101	TEST_F(l2_asinh_test, asinh_empty_tensor) {
102	auto self_tensor_desc = TensorDesc({13, 0, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
103	auto out_tensor_desc = TensorDesc({13, 0, 9}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
104
105	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
106	uint64_t workspace_size = 0;
107	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
108	EXPECT_EQ(aclRet, ACL_SUCCESS);
109	}
110
111	TEST_F(l2_asinh_test, asinh_non_contiguous) {
112	auto self_tensor_desc = TensorDesc({5, 3}, ACL_FLOAT, ACL_FORMAT_ND, {1, 5}, 0, {3, 5}).ValueRange(-2, 2);
113	auto out_tensor_desc = TensorDesc({5, 3}, ACL_FLOAT, ACL_FORMAT_ND, {1, 5}, 0, {3, 5}).Precision(0.001, 0.001);
114
115	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
116	uint64_t workspace_size = 0;
117	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
118	EXPECT_EQ(aclRet, ACL_SUCCESS);
119	}
120
121	TEST_F(l2_asinh_test, asinh_lessDim) {
122	auto self_tensor_desc = TensorDesc({2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
123	auto out_tensor_desc = TensorDesc({2}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
124
125	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
126	uint64_t workspace_size = 0;
127	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
128	EXPECT_EQ(aclRet, ACL_SUCCESS);
129	}
130
131	TEST_F(l2_asinh_test, asinh_bigDim) {
132	auto self_tensor_desc = TensorDesc({2, 2, 2, 2, 2, 2, 2, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
133	auto out_tensor_desc = TensorDesc({2, 2, 2, 2, 2, 2, 2, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
134
135	auto ut = OP_API_UT(aclnnAsinh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
136	uint64_t workspace_size = 0;
137	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
138	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
139	}
140
141	TEST_F(l2_asinh_test, asinh_inplace) {
142	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
143	auto ut = OP_API_UT(aclnnInplaceAsinh, INPUT(self_tensor_desc), OUTPUT());
144
145	uint64_t workspace_size = 0;
146	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
147	EXPECT_EQ(aclRet, ACL_SUCCESS);
148	}

Amath/atan2/tests/ut/op_api/test_atan2.cpp+594-0

@@ -0,0 +1,594 @@
	1	/**
	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10	#include <array>
	11	#include <vector>
	12	#include "gtest/gtest.h"
	13
	14	#include "../../../op_api/aclnn_atan2.h"
	15
	16	#include "op_api_ut_common/op_api_ut.h"
	17	#include "op_api_ut_common/scalar_desc.h"
	18	#include "op_api_ut_common/tensor_desc.h"
	19	#include <cstdlib>
	20	#include <ctime>
	21
	22	using namespace op;
	23	using namespace std;
	24
	25	class l2_atan2_test : public testing::Test {
	26	protected:
	27	static void SetUpTestCase() { std::cout << "atan2_test SetUp" << std::endl; }
	28
	29	static void TearDownTestCase() { std::cout << "atan2_test TearDown" << std::endl; }
	30	};
	31
	32	// 基础用例
	33	TEST_F(l2_atan2_test, ascend910B2_aclnnAtan2_base_case_1)
	34	{
	35	// self input
	36	const vector<int64_t>& selfShape = {2, 4};
	37	aclDataType selfDtype = ACL_FLOAT;
	38	aclFormat selfFormat = ACL_FORMAT_ND;
	39	// other input
	40	const vector<int64_t>& otherShape = {2, 4};
	41	aclDataType otherDtype = ACL_FLOAT;
	42	aclFormat otherFormat = ACL_FORMAT_ND;
	43	// output
	44	const vector<int64_t>& outShape = {2, 4};
	45	aclDataType outDtype = ACL_FLOAT;
	46	aclFormat outFormat = ACL_FORMAT_ND;
	47
	48	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8});
	49	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<float>{8, 7, 6, 5, 4, 3, 2, 1});
	50	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat).Value(vector<float>{0, 0, 0, 0, 0, 0, 0, 0});
	51
	52	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	53
	54	uint64_t workspaceSize = 0;
	55	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	56	EXPECT_EQ(aclRet, ACL_SUCCESS);
	57	}
	58
	59	TEST_F(l2_atan2_test, ascend910B2_aclnnAtan2_base_case_2)
	60	{
	61	// self input
	62	const vector<int64_t>& selfShape = {2, 4};
	63	aclDataType selfDtype = ACL_INT32;
	64	aclFormat selfFormat = ACL_FORMAT_ND;
	65	// other input
	66	const vector<int64_t>& otherShape = {2, 4};
	67	aclDataType otherDtype = ACL_FLOAT;
	68	aclFormat otherFormat = ACL_FORMAT_ND;
	69	// output
	70	const vector<int64_t>& outShape = {2, 4};
	71	aclDataType outDtype = ACL_DOUBLE;
	72	aclFormat outFormat = ACL_FORMAT_ND;
	73
	74	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8});
	75	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<float>{8, 7, 6, 5, 4, 3, 2, 1});
	76	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat).Value(vector<float>{0, 0, 0, 0, 0, 0, 0, 0});
	77
	78	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	79
	80	uint64_t workspaceSize = 0;
	81	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	82	EXPECT_EQ(aclRet, ACL_SUCCESS);
	83	}
	84
	85	/* 各元素基本类型覆盖用例
	86	* 维度：1-8维
	87	* float16,bfloat16,float,float64,int8,int16,int32,int64,uint8,bool
	88	* 数据格式：ND、NCHW、NHWC、HWCN、NDHWC、NCDHW
	89	*/
	90
	91	TEST_F(l2_atan2_test, aclnnAtan2_1_2_3_4_5_6_7_8_float_nd)
	92	{
	93	// self input
	94	const vector<int64_t>& selfShape = {1, 2, 3, 4, 5, 6, 7, 8};
	95	aclDataType selfDtype = ACL_FLOAT;
	96	aclFormat selfFormat = ACL_FORMAT_ND;
	97	// other input
	98	const vector<int64_t>& otherShape = {1, 2, 3, 4, 5, 6, 7, 8};
	99	aclDataType otherDtype = ACL_FLOAT;
	100	aclFormat otherFormat = ACL_FORMAT_ND;
	101	// output
	102	const vector<int64_t>& outShape = selfShape;
	103	aclDataType outDtype = selfDtype;
	104	aclFormat outFormat = ACL_FORMAT_ND;
	105
	106	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	107	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	108	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	109
	110	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	111
	112	uint64_t workspaceSize = 0;
	113	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	114	EXPECT_EQ(aclRet, ACL_SUCCESS);
	115	}
	116
	117	TEST_F(l2_atan2_test, aclnnAtan2_1_2_3_4_5_6_7_float16_nd)
	118	{
	119	// self input
	120	const vector<int64_t>& selfShape = {1, 2, 3, 4, 5, 6, 7};
	121	aclDataType selfDtype = ACL_FLOAT16;
	122	aclFormat selfFormat = ACL_FORMAT_ND;
	123	// other input
	124	const vector<int64_t>& otherShape = {1, 2, 3, 4, 5, 6, 7};
	125	aclDataType otherDtype = ACL_FLOAT16;
	126	aclFormat otherFormat = ACL_FORMAT_ND;
	127	// output
	128	const vector<int64_t>& outShape = selfShape;
	129	aclDataType outDtype = selfDtype;
	130	aclFormat outFormat = ACL_FORMAT_ND;
	131
	132	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	133	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	134	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	135
	136	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	137	uint64_t workspaceSize = 0;
	138	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	139	EXPECT_EQ(aclRet, ACL_SUCCESS);
	140	}
	141
	142	TEST_F(l2_atan2_test, aclnnAtan2_1_2_3_4_int32_nchw)
	143	{
	144	// self input
	145	const vector<int64_t>& selfShape = {1, 2, 3, 4};
	146	aclDataType selfDtype = ACL_INT32;
	147	aclFormat selfFormat = ACL_FORMAT_NCHW;
	148	// other input
	149	const vector<int64_t>& otherShape = {1, 2, 3, 4};
	150	aclDataType otherDtype = ACL_INT32;
	151	aclFormat otherFormat = ACL_FORMAT_NCHW;
	152	// output
	153	const vector<int64_t>& outShape = selfShape;
	154	aclDataType outDtype = ACL_FLOAT;
	155	aclFormat outFormat = ACL_FORMAT_NCHW;
	156
	157	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).ValueRange(-1, 1);
	158	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	159	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	160
	161	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	162	uint64_t workspaceSize = 0;
	163	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	164	EXPECT_EQ(aclRet, ACL_SUCCESS);
	165	}
	166
	167	TEST_F(l2_atan2_test, aclnnAtan2_1_2_3_4_int8_float_nchw)
	168	{
	169	// self input
	170	const vector<int64_t>& selfShape = {1, 2, 3, 4};
	171	aclDataType selfDtype = ACL_INT8;
	172	aclFormat selfFormat = ACL_FORMAT_NCHW;
	173	// other input
	174	const vector<int64_t>& otherShape = {1, 2, 3, 4};
	175	aclDataType otherDtype = ACL_FLOAT;
	176	aclFormat otherFormat = ACL_FORMAT_NCHW;
	177	// output
	178	const vector<int64_t>& outShape = selfShape;
	179	aclDataType outDtype = ACL_FLOAT;
	180	aclFormat outFormat = ACL_FORMAT_NCHW;
	181
	182	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	183	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	184	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	185
	186	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	187	uint64_t workspaceSize = 0;
	188	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	189	EXPECT_EQ(aclRet, ACL_SUCCESS);
	190	}
	191
	192	TEST_F(l2_atan2_test, aclnnAtan2_1_2_3_4_double_uint8_nhwc)
	193	{
	194	// self input
	195	const vector<int64_t>& selfShape = {1, 2, 3, 4};
	196	aclDataType selfDtype = ACL_DOUBLE;
	197	aclFormat selfFormat = ACL_FORMAT_NHWC;
	198	// other input
	199	const vector<int64_t>& otherShape = {4};
	200	aclDataType otherDtype = ACL_UINT8;
	201	aclFormat otherFormat = ACL_FORMAT_NHWC;
	202	// output
	203	const vector<int64_t>& outShape = selfShape;
	204	aclDataType outDtype = selfDtype;
	205	aclFormat outFormat = ACL_FORMAT_NHWC;
	206
	207	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	208	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{3, 2, 1, 0});
	209	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	210
	211	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	212
	213	uint64_t workspaceSize = 0;
	214	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	215	EXPECT_EQ(aclRet, ACL_SUCCESS);
	216	}
	217
	218	TEST_F(l2_atan2_test, ascend910B2_aclnnAtan2_1_bool_nhwc)
	219	{
	220	// self input
	221	const vector<int64_t>& selfShape = {3};
	222	aclDataType selfDtype = ACL_BOOL;
	223	aclFormat selfFormat = ACL_FORMAT_NHWC;
	224	// other input
	225	const vector<int64_t>& otherShape = {3};
	226	aclDataType otherDtype = ACL_BOOL;
	227	aclFormat otherFormat = ACL_FORMAT_NHWC;
	228	// output
	229	const vector<int64_t>& outShape = selfShape;
	230	aclDataType outDtype = ACL_FLOAT;
	231	aclFormat outFormat = ACL_FORMAT_NHWC;
	232
	233	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	234	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	235	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	236
	237	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	238
	239	uint64_t workspaceSize = 0;
	240	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	241	EXPECT_EQ(aclRet, ACL_SUCCESS);
	242	}
	243
	244	TEST_F(l2_atan2_test, aclnnAtan2_1_2_3_4_int8_int32_hwcn)
	245	{
	246	// self input
	247	const vector<int64_t>& selfShape = {1, 2, 3};
	248	aclDataType selfDtype = ACL_INT8;
	249	aclFormat selfFormat = ACL_FORMAT_HWCN;
	250	// other input
	251	const vector<int64_t>& otherShape = {1, 2, 3};
	252	aclDataType otherDtype = ACL_INT32;
	253	aclFormat otherFormat = ACL_FORMAT_HWCN;
	254	// output
	255	const vector<int64_t>& outShape = selfShape;
	256	aclDataType outDtype = ACL_FLOAT16;
	257	aclFormat outFormat = ACL_FORMAT_HWCN;
	258
	259	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	260	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	261	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	262
	263	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	264
	265	uint64_t workspaceSize = 0;
	266	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	267	EXPECT_EQ(aclRet, ACL_SUCCESS);
	268	}
	269
	270	// 各元素特殊类型覆盖用例
	271	// 空tensor
	272	TEST_F(l2_atan2_test, aclnnAtan2_float_nd_empty_tensor)
	273	{
	274	// self input
	275	const vector<int64_t>& selfShape = {0};
	276	aclDataType selfDtype = ACL_FLOAT;
	277	aclFormat selfFormat = ACL_FORMAT_ND;
	278	// other input
	279	const vector<int64_t>& otherShape = {0};
	280
	281	aclDataType otherDtype = ACL_INT64;
	282	aclFormat otherFormat = ACL_FORMAT_ND;
	283	// output
	284	const vector<int64_t>& outShape = {0};
	285	aclDataType outDtype = selfDtype;
	286	aclFormat outFormat = ACL_FORMAT_ND;
	287
	288	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	289	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	290	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	291
	292	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	293
	294	uint64_t workspaceSize = 0;
	295	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	296	EXPECT_EQ(aclRet, ACL_SUCCESS);
	297	}
	298
	299	// 边界值
	300	TEST_F(l2_atan2_test, aclnnAtan2_float32_nd_boundary_value)
	301	{
	302	// self input
	303	const vector<int64_t>& selfShape = {1, 2};
	304	aclDataType selfDtype = ACL_FLOAT;
	305	aclFormat selfFormat = ACL_FORMAT_ND;
	306	// other input
	307	const vector<int64_t>& otherShape = {1, 2};
	308	aclDataType otherDtype = ACL_INT64;
	309	aclFormat otherFormat = ACL_FORMAT_ND;
	310	// output3
	311	const vector<int64_t>& outShape = selfShape;
	312	aclDataType outDtype = selfDtype;
	313	aclFormat outFormat = ACL_FORMAT_ND;
	314
	315	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).Value(vector<float>{65504.0, -65504.0});
	316	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{1, 0});
	317	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	318
	319	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	320
	321	uint64_t workspaceSize = 0;
	322	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	323	EXPECT_EQ(aclRet, ACL_SUCCESS);
	324	}
	325
	326	// 不连续
	327	TEST_F(l2_atan2_test, aclnnAtan2_5_4_float_nd_not_contiguous)
	328	{
	329	// self input
	330	const vector<int64_t>& selfShape = {5, 4};
	331	aclDataType selfDtype = ACL_FLOAT;
	332	aclFormat selfFormat = ACL_FORMAT_ND;
	333	const vector<int64_t>& selfViewDim = {1, 5};
	334	int64_t selfOffset = 0;
	335	const vector<int64_t>& selfStorageDim = {4, 5};
	336	// other input
	337	const vector<int64_t>& otherShape = {5, 4};
	338	aclDataType otherDtype = ACL_FLOAT;
	339	aclFormat otherFormat = ACL_FORMAT_ND;
	340	const vector<int64_t>& otherViewDim = {1, 5};
	341	int64_t otherOffset = 0;
	342	const vector<int64_t>& otherStorageDim = {4, 5};
	343	// output
	344	const vector<int64_t>& outShape = {5, 4};
	345	aclDataType outDtype = selfDtype;
	346	aclFormat outFormat = ACL_FORMAT_ND;
	347	const vector<int64_t>& outViewDim = {1, 5};
	348	int64_t sourceOffset = 0;
	349	const vector<int64_t>& outStorageDim = {4, 5};
	350
	351	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat, selfViewDim, selfOffset, selfStorageDim)
	352	.ValueRange(-2, 2);
	353
	354	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat, otherViewDim, otherOffset, otherStorageDim);
	355
	356	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat, outViewDim, sourceOffset, outStorageDim);
	357
	358	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	359
	360	uint64_t workspaceSize = 0;
	361	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	362	EXPECT_EQ(aclRet, ACL_SUCCESS);
	363	}
	364
	365	// 报错类型覆盖用例
	366	// 空指针
	367	TEST_F(l2_atan2_test, aclnnAtan2_input_nullptr)
	368	{
	369	auto tensor_desc = TensorDesc({10}, ACL_FLOAT, ACL_FORMAT_ND);
	370
	371	auto ut_self_nullptr = OP_API_UT(aclnnAtan2, INPUT((aclTensor*)nullptr, tensor_desc), OUTPUT(tensor_desc));
	372
	373	uint64_t workspaceSize = 0;
	374	aclnnStatus aclRet = ut_self_nullptr.TestGetWorkspaceSize(&workspaceSize);
	375	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	376
	377	auto ut_index_nullptr = OP_API_UT(aclnnAtan2, INPUT(tensor_desc, (aclTensor*)nullptr), OUTPUT(tensor_desc));
	378
	379	aclRet = ut_index_nullptr.TestGetWorkspaceSize(&workspaceSize);
	380	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	381
	382	auto ut_source_nullptr = OP_API_UT(aclnnAtan2, INPUT(tensor_desc, tensor_desc), OUTPUT((aclTensor*)nullptr));
	383
	384	aclRet = ut_source_nullptr.TestGetWorkspaceSize(&workspaceSize);
	385	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	386	}
	387
	388	// self类型不满足
	389	TEST_F(l2_atan2_test, aclnnAtan2_self_dtype_error)
	390	{
	391	// self input
	392	const vector<int64_t>& selfShape = {2, 4};
	393	aclDataType selfDtype = ACL_COMPLEX64;
	394	aclFormat selfFormat = ACL_FORMAT_ND;
	395	// other input
	396	const vector<int64_t>& otherShape = {2, 4};
	397	aclDataType otherDtype = ACL_INT64;
	398	aclFormat otherFormat = ACL_FORMAT_ND;
	399	// output
	400	const vector<int64_t>& outShape = selfShape;
	401	aclDataType outDtype = ACL_FLOAT;
	402	aclFormat outFormat = ACL_FORMAT_ND;
	403
	404	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	405	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	406	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	407
	408	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	409
	410	uint64_t workspaceSize = 0;
	411	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	412	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	413	}
	414
	415	// index类型不满足
	416	TEST_F(l2_atan2_test, aclnnAtan2_index_dtype_error)
	417	{
	418	// self input
	419	const vector<int64_t>& selfShape = {2, 4};
	420	aclDataType selfDtype = ACL_INT64;
	421	aclFormat selfFormat = ACL_FORMAT_ND;
	422	// other input
	423	const vector<int64_t>& otherShape = {2, 4};
	424	aclDataType otherDtype = ACL_COMPLEX64;
	425	aclFormat otherFormat = ACL_FORMAT_ND;
	426	// output
	427	const vector<int64_t>& outShape = selfShape;
	428	aclDataType outDtype = ACL_FLOAT;
	429	aclFormat outFormat = ACL_FORMAT_ND;
	430
	431	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	432	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	433	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	434
	435	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	436
	437	uint64_t workspaceSize = 0;
	438	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	439	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	440	}
	441
	442	// 形状大于8
	443	TEST_F(l2_atan2_test, aclnnAtan2_self_shape_out_of_8)
	444	{
	445	auto out_shape_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, ACL_FLOAT, ACL_FORMAT_ND);
	446	auto normal_tensor_desc = TensorDesc({10}, ACL_FLOAT, ACL_FORMAT_ND);
	447
	448	// self形状大于8
	449	auto self_out_of_shape_ut = OP_API_UT(aclnnAtan2, INPUT(out_shape_tensor_desc, normal_tensor_desc),
	450	OUTPUT(normal_tensor_desc));
	451
	452	uint64_t workspaceSize = 0;
	453	aclnnStatus aclRet = self_out_of_shape_ut.TestGetWorkspaceSize(&workspaceSize);
	454	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	455
	456	// other形状大于8
	457	auto other_out_of_shape_ut = OP_API_UT(aclnnAtan2, INPUT(normal_tensor_desc, out_shape_tensor_desc),
	458	OUTPUT(normal_tensor_desc));
	459	aclRet = other_out_of_shape_ut.TestGetWorkspaceSize(&workspaceSize);
	460	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	461	}
	462
	463	TEST_F(l2_atan2_test, ascend910B2_aclnnAtan2_bf16_nhwc)
	464	{
	465	// self input
	466	const vector<int64_t>& selfShape = {1, 2, 3, 4};
	467	aclDataType selfDtype = ACL_BF16;
	468	aclFormat selfFormat = ACL_FORMAT_NHWC;
	469	// other input
	470	const vector<int64_t>& otherShape = {4};
	471	aclDataType otherDtype = ACL_BF16;
	472	aclFormat otherFormat = ACL_FORMAT_NHWC;
	473	// output
	474	const vector<int64_t>& outShape = selfShape;
	475	aclDataType outDtype = selfDtype;
	476	aclFormat outFormat = ACL_FORMAT_NHWC;
	477
	478	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	479	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{3, 2, 1, 0});
	480	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	481
	482	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	483
	484	uint64_t workspaceSize = 0;
	485	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	486	EXPECT_EQ(aclRet, ACL_SUCCESS);
	487	}
	488
	489	TEST_F(l2_atan2_test, aclnnAtan2_bf16_nhwc)
	490	{
	491	// self input
	492	const vector<int64_t>& selfShape = {1, 2, 3, 4};
	493	aclDataType selfDtype = ACL_BF16;
	494	aclFormat selfFormat = ACL_FORMAT_NHWC;
	495	// other input
	496	const vector<int64_t>& otherShape = {4};
	497	aclDataType otherDtype = ACL_BF16;
	498	aclFormat otherFormat = ACL_FORMAT_NHWC;
	499	// output
	500	const vector<int64_t>& outShape = selfShape;
	501	aclDataType outDtype = selfDtype;
	502	aclFormat outFormat = ACL_FORMAT_NHWC;
	503
	504	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	505	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{3, 2, 1, 0});
	506	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	507
	508	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	509
	510	uint64_t workspaceSize = 0;
	511	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	512	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	513	}
	514
	515	// TEST BROADCAST
	516	TEST_F(l2_atan2_test, ascend910B2_atan2_self_broadcast)
	517	{
	518	// self input
	519	const vector<int64_t>& selfShape = {2};
	520	aclDataType selfDtype = ACL_FLOAT;
	521	aclFormat selfFormat = ACL_FORMAT_ND;
	522	// other input
	523	const vector<int64_t>& otherShape = {4, 2};
	524	aclDataType otherDtype = ACL_FLOAT;
	525	aclFormat otherFormat = ACL_FORMAT_ND;
	526	// output
	527	const vector<int64_t>& outShape = {4, 2};
	528	aclDataType outDtype = ACL_FLOAT;
	529	aclFormat outFormat = ACL_FORMAT_ND;
	530
	531	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	532	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	533	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	534
	535	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	536
	537	uint64_t workspaceSize = 0;
	538	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	539	EXPECT_EQ(aclRet, ACL_SUCCESS);
	540	}
	541
	542	// 形状大于8
	543	TEST_F(l2_atan2_test, ascend910B2_atan2_inferdtype_test)
	544	{
	545	// self input
	546	const vector<int64_t>& selfShape = {2};
	547	aclDataType selfDtype = ACL_COMPLEX64;
	548	aclFormat selfFormat = ACL_FORMAT_ND;
	549	// other input
	550	const vector<int64_t>& otherShape = {4, 2};
	551	aclDataType otherDtype = ACL_INT32;
	552	aclFormat otherFormat = ACL_FORMAT_ND;
	553	// output
	554	const vector<int64_t>& outShape = {4, 2};
	555	aclDataType outDtype = ACL_COMPLEX64;
	556	aclFormat outFormat = ACL_FORMAT_ND;
	557
	558	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	559	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	560	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	561
	562	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	563
	564	uint64_t workspaceSize = 0;
	565	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	566	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	567	}
	568
	569	// TEST Cast
	570	TEST_F(l2_atan2_test, ascend910B2_atan2_self_int16_other_int64_out_bool)
	571	{
	572	// self input
	573	const vector<int64_t>& selfShape = {2};
	574	aclDataType selfDtype = ACL_INT64;
	575	aclFormat selfFormat = ACL_FORMAT_ND;
	576	// other input
	577	const vector<int64_t>& otherShape = {4, 2};
	578	aclDataType otherDtype = ACL_INT16;
	579	aclFormat otherFormat = ACL_FORMAT_ND;
	580	// output
	581	const vector<int64_t>& outShape = {4, 2};
	582	aclDataType outDtype = ACL_BOOL;
	583	aclFormat outFormat = ACL_FORMAT_ND;
	584
	585	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	586	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	587	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
	588
	589	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
	590
	591	uint64_t workspaceSize = 0;
	592	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	593	EXPECT_EQ(aclRet, ACL_SUCCESS);
	594	}

Amath/atan2/tests/ut/op_api/test_inplace_atan2.cpp+467-0

@@ -0,0 +1,467 @@
	1	/**
	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10	#include <array>
	11	#include <vector>
	12	#include "gtest/gtest.h"
	13
	14	#include "../../../op_api/aclnn_atan2.h"
	15
	16	#include "op_api_ut_common/op_api_ut.h"
	17	#include "op_api_ut_common/scalar_desc.h"
	18	#include "op_api_ut_common/tensor_desc.h"
	19	#include <cstdlib>
	20	#include <ctime>
	21
	22	using namespace op;
	23	using namespace std;
	24
	25	class l2_inplace_atan2_test : public testing::Test {
	26	protected:
	27	static void SetUpTestCase() { std::cout << "inplace_atan2_test SetUp" << std::endl; }
	28
	29	static void TearDownTestCase() { std::cout << "inplace_atan2_test TearDown" << std::endl; }
	30	};
	31
	32	// 基础用例
	33	TEST_F(l2_inplace_atan2_test, ascend910B2_aclnnInplaceAtan2_base_case_1)
	34	{
	35	// self input
	36	const vector<int64_t>& selfShape = {2, 4};
	37	aclDataType selfDtype = ACL_FLOAT;
	38	aclFormat selfFormat = ACL_FORMAT_ND;
	39	// other input
	40	const vector<int64_t>& otherShape = {2, 4};
	41	aclDataType otherDtype = ACL_FLOAT;
	42	aclFormat otherFormat = ACL_FORMAT_ND;
	43
	44	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8});
	45	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<float>{8, 7, 6, 5, 4, 3, 2, 1});
	46
	47	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	48
	49	uint64_t workspaceSize = 0;
	50	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	51	EXPECT_EQ(aclRet, ACL_SUCCESS);
	52	}
	53
	54	TEST_F(l2_inplace_atan2_test, ascend910B2_aclnnInplaceAtan2_base_case_2)
	55	{
	56	// self input
	57	const vector<int64_t>& selfShape = {2, 4};
	58	aclDataType selfDtype = ACL_INT32;
	59	aclFormat selfFormat = ACL_FORMAT_ND;
	60	// other input
	61	const vector<int64_t>& otherShape = {2, 4};
	62	aclDataType otherDtype = ACL_FLOAT;
	63	aclFormat otherFormat = ACL_FORMAT_ND;
	64
	65	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8});
	66	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<float>{8, 7, 6, 5, 4, 3, 2, 1});
	67
	68	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	69
	70	uint64_t workspaceSize = 0;
	71	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	72	EXPECT_EQ(aclRet, ACL_SUCCESS);
	73	}
	74
	75	/* 各元素基本类型覆盖用例
	76	* 维度：1-8维
	77	* float16,bfloat16,float,float64,int8,int16,int32,int64,uint8,bool
	78	* 数据格式：ND、NCHW、NHWC、HWCN、NDHWC、NCDHW
	79	*/
	80
	81	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_1_2_3_4_5_6_7_8_float_nd)
	82	{
	83	// self input
	84	const vector<int64_t>& selfShape = {1, 2, 3, 4, 5, 6, 7, 8};
	85	aclDataType selfDtype = ACL_FLOAT;
	86	aclFormat selfFormat = ACL_FORMAT_ND;
	87	// other input
	88	const vector<int64_t>& otherShape = {1, 2, 3, 4, 5, 6, 7, 8};
	89	aclDataType otherDtype = ACL_FLOAT;
	90	aclFormat otherFormat = ACL_FORMAT_ND;
	91
	92	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	93	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	94	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	95
	96	uint64_t workspaceSize = 0;
	97	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	98	EXPECT_EQ(aclRet, ACL_SUCCESS);
	99	}
	100
	101	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_1_2_3_4_5_6_7_float16_nd)
	102	{
	103	// self input
	104	const vector<int64_t>& selfShape = {1, 2, 3, 4, 5, 6, 7};
	105	aclDataType selfDtype = ACL_FLOAT16;
	106	aclFormat selfFormat = ACL_FORMAT_ND;
	107	// other input
	108	const vector<int64_t>& otherShape = {1, 2, 3, 4, 5, 6, 7};
	109	aclDataType otherDtype = ACL_FLOAT16;
	110	aclFormat otherFormat = ACL_FORMAT_ND;
	111
	112	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	113	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	114
	115	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	116	uint64_t workspaceSize = 0;
	117	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	118	EXPECT_EQ(aclRet, ACL_SUCCESS);
	119	}
	120
	121	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_1_2_3_4_int32_nchw)
	122	{
	123	// self input
	124	const vector<int64_t>& selfShape = {1, 2, 3, 4};
	125	aclDataType selfDtype = ACL_INT32;
	126	aclFormat selfFormat = ACL_FORMAT_NCHW;
	127	// other input
	128	const vector<int64_t>& otherShape = {1, 2, 3, 4};
	129	aclDataType otherDtype = ACL_INT32;
	130	aclFormat otherFormat = ACL_FORMAT_NCHW;
	131
	132	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).ValueRange(-1, 1);
	133	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	134
	135	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	136	uint64_t workspaceSize = 0;
	137	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	138	EXPECT_EQ(aclRet, ACL_SUCCESS);
	139	}
	140
	141	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_1_2_3_4_int8_float_nchw)
	142	{
	143	// self input
	144	const vector<int64_t>& selfShape = {1, 2, 3, 4};
	145	aclDataType selfDtype = ACL_INT8;
	146	aclFormat selfFormat = ACL_FORMAT_NCHW;
	147	// other input
	148	const vector<int64_t>& otherShape = {1, 2, 3, 4};
	149	aclDataType otherDtype = ACL_FLOAT;
	150	aclFormat otherFormat = ACL_FORMAT_NCHW;
	151
	152	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	153	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	154
	155	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	156	uint64_t workspaceSize = 0;
	157	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	158	EXPECT_EQ(aclRet, ACL_SUCCESS);
	159	}
	160
	161	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_1_2_3_4_double_uint8_nhwc)
	162	{
	163	// self input
	164	const vector<int64_t>& selfShape = {1, 2, 3, 4};
	165	aclDataType selfDtype = ACL_DOUBLE;
	166	aclFormat selfFormat = ACL_FORMAT_NHWC;
	167	// other input
	168	const vector<int64_t>& otherShape = {4};
	169	aclDataType otherDtype = ACL_UINT8;
	170	aclFormat otherFormat = ACL_FORMAT_NHWC;
	171
	172	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	173	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{3, 2, 1, 0});
	174
	175	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	176
	177	uint64_t workspaceSize = 0;
	178	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	179	EXPECT_EQ(aclRet, ACL_SUCCESS);
	180	}
	181
	182	TEST_F(l2_inplace_atan2_test, ascend910B2_aclnnInplaceAtan2_1_bool_nhwc)
	183	{
	184	// self input
	185	const vector<int64_t>& selfShape = {3};
	186	aclDataType selfDtype = ACL_BOOL;
	187	aclFormat selfFormat = ACL_FORMAT_NHWC;
	188	// other input
	189	const vector<int64_t>& otherShape = {3};
	190	aclDataType otherDtype = ACL_BOOL;
	191	aclFormat otherFormat = ACL_FORMAT_NHWC;
	192
	193	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	194	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	195
	196	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	197
	198	uint64_t workspaceSize = 0;
	199	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	200	EXPECT_EQ(aclRet, ACL_SUCCESS);
	201	}
	202
	203	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_1_2_3_4_int8_int32_hwcn)
	204	{
	205	// self input
	206	const vector<int64_t>& selfShape = {1, 2, 3};
	207	aclDataType selfDtype = ACL_INT8;
	208	aclFormat selfFormat = ACL_FORMAT_HWCN;
	209	// other input
	210	const vector<int64_t>& otherShape = {1, 2, 3};
	211	aclDataType otherDtype = ACL_INT32;
	212	aclFormat otherFormat = ACL_FORMAT_HWCN;
	213
	214	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	215	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	216
	217	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	218
	219	uint64_t workspaceSize = 0;
	220	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	221	EXPECT_EQ(aclRet, ACL_SUCCESS);
	222	}
	223
	224	// 各元素特殊类型覆盖用例
	225	// 空tensor
	226	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_float_nd_empty_tensor)
	227	{
	228	// self input
	229	const vector<int64_t>& selfShape = {0};
	230	aclDataType selfDtype = ACL_FLOAT;
	231	aclFormat selfFormat = ACL_FORMAT_ND;
	232	// other input
	233	const vector<int64_t>& otherShape = {0};
	234
	235	aclDataType otherDtype = ACL_INT64;
	236	aclFormat otherFormat = ACL_FORMAT_ND;
	237
	238	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	239	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	240
	241	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	242
	243	uint64_t workspaceSize = 0;
	244	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	245	EXPECT_EQ(aclRet, ACL_SUCCESS);
	246	}
	247
	248	// 边界值
	249	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_float32_nd_boundary_value)
	250	{
	251	// self input
	252	const vector<int64_t>& selfShape = {1, 2};
	253	aclDataType selfDtype = ACL_FLOAT;
	254	aclFormat selfFormat = ACL_FORMAT_ND;
	255	// other input
	256	const vector<int64_t>& otherShape = {1, 2};
	257	aclDataType otherDtype = ACL_INT64;
	258	aclFormat otherFormat = ACL_FORMAT_ND;
	259
	260	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).Value(vector<float>{65504.0, -65504.0});
	261	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{1, 0});
	262
	263	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	264
	265	uint64_t workspaceSize = 0;
	266	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	267	EXPECT_EQ(aclRet, ACL_SUCCESS);
	268	}
	269
	270	// 不连续
	271	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_5_4_float_nd_not_contiguous)
	272	{
	273	// self input
	274	const vector<int64_t>& selfShape = {5, 4};
	275	aclDataType selfDtype = ACL_FLOAT;
	276	aclFormat selfFormat = ACL_FORMAT_ND;
	277	const vector<int64_t>& selfViewDim = {1, 5};
	278	int64_t selfOffset = 0;
	279	const vector<int64_t>& selfStorageDim = {4, 5};
	280	// other input
	281	const vector<int64_t>& otherShape = {5, 4};
	282	aclDataType otherDtype = ACL_FLOAT;
	283	aclFormat otherFormat = ACL_FORMAT_ND;
	284	const vector<int64_t>& otherViewDim = {1, 5};
	285	int64_t otherOffset = 0;
	286	const vector<int64_t>& otherStorageDim = {4, 5};
	287
	288	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat, selfViewDim, selfOffset, selfStorageDim)
	289	.ValueRange(-2, 2);
	290
	291	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat, otherViewDim, otherOffset, otherStorageDim);
	292
	293	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	294
	295	uint64_t workspaceSize = 0;
	296	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	297	EXPECT_EQ(aclRet, ACL_SUCCESS);
	298	}
	299
	300	// 报错类型覆盖用例
	301	// 空指针
	302	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_input_nullptr)
	303	{
	304	auto tensor_desc = TensorDesc({10}, ACL_FLOAT, ACL_FORMAT_ND);
	305
	306	auto ut_self_nullptr = OP_API_UT(aclnnInplaceAtan2, INPUT((aclTensor*)nullptr, tensor_desc), OUTPUT());
	307
	308	uint64_t workspaceSize = 0;
	309	aclnnStatus aclRet = ut_self_nullptr.TestGetWorkspaceSize(&workspaceSize);
	310	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	311
	312	auto ut_index_nullptr = OP_API_UT(aclnnInplaceAtan2, INPUT(tensor_desc, (aclTensor*)nullptr), OUTPUT());
	313
	314	aclRet = ut_index_nullptr.TestGetWorkspaceSize(&workspaceSize);
	315	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	316	}
	317
	318	// self类型不满足
	319	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_self_dtype_error)
	320	{
	321	// self input
	322	const vector<int64_t>& selfShape = {2, 4};
	323	aclDataType selfDtype = ACL_COMPLEX64;
	324	aclFormat selfFormat = ACL_FORMAT_ND;
	325	// other input
	326	const vector<int64_t>& otherShape = {2, 4};
	327	aclDataType otherDtype = ACL_INT64;
	328	aclFormat otherFormat = ACL_FORMAT_ND;
	329
	330	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	331	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	332
	333	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	334
	335	uint64_t workspaceSize = 0;
	336	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	337	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	338	}
	339
	340	// index类型不满足
	341	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_index_dtype_error)
	342	{
	343	// self input
	344	const vector<int64_t>& selfShape = {2, 4};
	345	aclDataType selfDtype = ACL_INT64;
	346	aclFormat selfFormat = ACL_FORMAT_ND;
	347	// other input
	348	const vector<int64_t>& otherShape = {2, 4};
	349	aclDataType otherDtype = ACL_COMPLEX64;
	350	aclFormat otherFormat = ACL_FORMAT_ND;
	351
	352	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	353	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	354
	355	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	356
	357	uint64_t workspaceSize = 0;
	358	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	359	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	360	}
	361
	362	// 形状大于8
	363	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_self_shape_out_of_8)
	364	{
	365	auto out_shape_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, ACL_FLOAT, ACL_FORMAT_ND);
	366	auto normal_tensor_desc = TensorDesc({10}, ACL_FLOAT, ACL_FORMAT_ND);
	367
	368	// self形状大于8
	369	auto self_out_of_shape_ut = OP_API_UT(aclnnInplaceAtan2, INPUT(out_shape_tensor_desc, normal_tensor_desc),
	370	OUTPUT());
	371
	372	uint64_t workspaceSize = 0;
	373	aclnnStatus aclRet = self_out_of_shape_ut.TestGetWorkspaceSize(&workspaceSize);
	374	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	375
	376	// other形状大于8
	377	auto other_out_of_shape_ut = OP_API_UT(aclnnInplaceAtan2, INPUT(normal_tensor_desc, out_shape_tensor_desc),
	378	OUTPUT());
	379	aclRet = other_out_of_shape_ut.TestGetWorkspaceSize(&workspaceSize);
	380	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	381	}
	382
	383	TEST_F(l2_inplace_atan2_test, ascend910B2_aclnnInplaceAtan2_bf16_nhwc)
	384	{
	385	// self input
	386	const vector<int64_t>& selfShape = {1, 2, 3, 4};
	387	aclDataType selfDtype = ACL_BF16;
	388	aclFormat selfFormat = ACL_FORMAT_NHWC;
	389	// other input
	390	const vector<int64_t>& otherShape = {4};
	391	aclDataType otherDtype = ACL_BF16;
	392	aclFormat otherFormat = ACL_FORMAT_NHWC;
	393
	394	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	395	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{3, 2, 1, 0});
	396
	397	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	398
	399	uint64_t workspaceSize = 0;
	400	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	401	EXPECT_EQ(aclRet, ACL_SUCCESS);
	402	}
	403
	404	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_bf16_nhwc)
	405	{
	406	// self input
	407	const vector<int64_t>& selfShape = {1, 2, 3, 4};
	408	aclDataType selfDtype = ACL_BF16;
	409	aclFormat selfFormat = ACL_FORMAT_NHWC;
	410	// other input
	411	const vector<int64_t>& otherShape = {4};
	412	aclDataType otherDtype = ACL_BF16;
	413	aclFormat otherFormat = ACL_FORMAT_NHWC;
	414
	415	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	416	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{3, 2, 1, 0});
	417
	418	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	419
	420	uint64_t workspaceSize = 0;
	421	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	422	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	423	}
	424
	425	// TEST BROADCAST
	426	TEST_F(l2_inplace_atan2_test, ascend910B2_atan2_self_broadcast)
	427	{
	428	// self input
	429	const vector<int64_t>& selfShape = {2};
	430	aclDataType selfDtype = ACL_FLOAT;
	431	aclFormat selfFormat = ACL_FORMAT_ND;
	432	// other input
	433	const vector<int64_t>& otherShape = {4, 2};
	434	aclDataType otherDtype = ACL_FLOAT;
	435	aclFormat otherFormat = ACL_FORMAT_ND;
	436
	437	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	438	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	439
	440	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	441
	442	uint64_t workspaceSize = 0;
	443	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	444	EXPECT_EQ(aclRet, ACL_SUCCESS);
	445	}
	446
	447	// 形状大于8
	448	TEST_F(l2_inplace_atan2_test, ascend910B2_atan2_inferdtype_test)
	449	{
	450	// self input
	451	const vector<int64_t>& selfShape = {2};
	452	aclDataType selfDtype = ACL_COMPLEX64;
	453	aclFormat selfFormat = ACL_FORMAT_ND;
	454	// other input
	455	const vector<int64_t>& otherShape = {4, 2};
	456	aclDataType otherDtype = ACL_INT32;
	457	aclFormat otherFormat = ACL_FORMAT_ND;
	458
	459	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
	460	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
	461
	462	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
	463
	464	uint64_t workspaceSize = 0;
	465	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	466	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	467	}

Dmath/atan2/tests/ut/op_host/op_api/test_atan2.cpp+0-585

	@@ -1,585 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10	#include <array>
11	#include <vector>
12	#include "gtest/gtest.h"
13
14	#include "../../../../op_host/op_api/aclnn_atan2.h"
15
16	#include "op_api_ut_common/op_api_ut.h"
17	#include "op_api_ut_common/scalar_desc.h"
18	#include "op_api_ut_common/tensor_desc.h"
19	#include <cstdlib>
20	#include <ctime>
21
22	using namespace op;
23	using namespace std;
24
25	class l2_atan2_test : public testing::Test {
26	protected:
27	static void SetUpTestCase() {
28	std::cout << "atan2_test SetUp" << std::endl;
29	}
30
31	static void TearDownTestCase() {
32	std::cout << "atan2_test TearDown" << std::endl;
33	}
34	};
35
36	// 基础用例
37	TEST_F(l2_atan2_test, ascend910B2_aclnnAtan2_base_case_1) {
38	// self input
39	const vector<int64_t>& selfShape = {2, 4};
40	aclDataType selfDtype = ACL_FLOAT;
41	aclFormat selfFormat = ACL_FORMAT_ND;
42	// other input
43	const vector<int64_t>& otherShape = {2, 4};
44	aclDataType otherDtype = ACL_FLOAT;
45	aclFormat otherFormat = ACL_FORMAT_ND;
46	// output
47	const vector<int64_t>& outShape = {2, 4};
48	aclDataType outDtype = ACL_FLOAT;
49	aclFormat outFormat = ACL_FORMAT_ND;
50
51	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8});
52	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<float>{8, 7, 6, 5, 4, 3, 2, 1});
53	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat).Value(vector<float>{0, 0, 0, 0, 0, 0, 0, 0});
54
55	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
56
57	uint64_t workspaceSize = 0;
58	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
59	EXPECT_EQ(aclRet, ACL_SUCCESS);
60
61	}
62
63	TEST_F(l2_atan2_test, ascend910B2_aclnnAtan2_base_case_2) {
64	// self input
65	const vector<int64_t>& selfShape = {2, 4};
66	aclDataType selfDtype = ACL_INT32;
67	aclFormat selfFormat = ACL_FORMAT_ND;
68	// other input
69	const vector<int64_t>& otherShape = {2, 4};
70	aclDataType otherDtype = ACL_FLOAT;
71	aclFormat otherFormat = ACL_FORMAT_ND;
72	// output
73	const vector<int64_t>& outShape = {2, 4};
74	aclDataType outDtype = ACL_DOUBLE;
75	aclFormat outFormat = ACL_FORMAT_ND;
76
77	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8});
78	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<float>{8, 7, 6, 5, 4, 3, 2, 1});
79	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat).Value(vector<float>{0, 0, 0, 0, 0, 0, 0, 0});
80
81	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
82
83	uint64_t workspaceSize = 0;
84	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
85	EXPECT_EQ(aclRet, ACL_SUCCESS);
86
87	}
88
89	/* 各元素基本类型覆盖用例
90	* 维度：1-8维
91	* float16,bfloat16,float,float64,int8,int16,int32,int64,uint8,bool
92	* 数据格式：ND、NCHW、NHWC、HWCN、NDHWC、NCDHW
93	*/
94
95	TEST_F(l2_atan2_test, aclnnAtan2_1_2_3_4_5_6_7_8_float_nd) {
96	// self input
97	const vector<int64_t>& selfShape = {1, 2, 3, 4, 5, 6, 7, 8};
98	aclDataType selfDtype = ACL_FLOAT;
99	aclFormat selfFormat = ACL_FORMAT_ND;
100	// other input
101	const vector<int64_t>& otherShape = {1, 2, 3, 4, 5, 6, 7, 8};
102	aclDataType otherDtype = ACL_FLOAT;
103	aclFormat otherFormat = ACL_FORMAT_ND;
104	// output
105	const vector<int64_t>& outShape = selfShape;
106	aclDataType outDtype = selfDtype;
107	aclFormat outFormat = ACL_FORMAT_ND;
108
109	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
110	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
111	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
112
113	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
114
115	uint64_t workspaceSize = 0;
116	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
117	EXPECT_EQ(aclRet, ACL_SUCCESS);
118	}
119
120	TEST_F(l2_atan2_test, aclnnAtan2_1_2_3_4_5_6_7_float16_nd) {
121	// self input
122	const vector<int64_t>& selfShape = {1, 2, 3, 4, 5, 6, 7};
123	aclDataType selfDtype = ACL_FLOAT16;
124	aclFormat selfFormat = ACL_FORMAT_ND;
125	// other input
126	const vector<int64_t>& otherShape = {1, 2, 3, 4, 5, 6, 7};
127	aclDataType otherDtype = ACL_FLOAT16;
128	aclFormat otherFormat = ACL_FORMAT_ND;
129	// output
130	const vector<int64_t>& outShape = selfShape;
131	aclDataType outDtype = selfDtype;
132	aclFormat outFormat = ACL_FORMAT_ND;
133
134	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
135	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
136	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
137
138	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
139	uint64_t workspaceSize = 0;
140	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
141	EXPECT_EQ(aclRet, ACL_SUCCESS);
142	}
143
144	TEST_F(l2_atan2_test, aclnnAtan2_1_2_3_4_int32_nchw) {
145	// self input
146	const vector<int64_t>& selfShape = {1, 2, 3, 4};
147	aclDataType selfDtype = ACL_INT32;
148	aclFormat selfFormat = ACL_FORMAT_NCHW;
149	// other input
150	const vector<int64_t>& otherShape = {1, 2, 3, 4};
151	aclDataType otherDtype = ACL_INT32;
152	aclFormat otherFormat = ACL_FORMAT_NCHW;
153	// output
154	const vector<int64_t>& outShape = selfShape;
155	aclDataType outDtype = ACL_FLOAT;
156	aclFormat outFormat = ACL_FORMAT_NCHW;
157
158	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).ValueRange(-1, 1);
159	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
160	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
161
162	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
163	uint64_t workspaceSize = 0;
164	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
165	EXPECT_EQ(aclRet, ACL_SUCCESS);
166	}
167
168	TEST_F(l2_atan2_test, aclnnAtan2_1_2_3_4_int8_float_nchw) {
169	// self input
170	const vector<int64_t>& selfShape = {1, 2, 3, 4};
171	aclDataType selfDtype = ACL_INT8;
172	aclFormat selfFormat = ACL_FORMAT_NCHW;
173	// other input
174	const vector<int64_t>& otherShape = {1, 2, 3, 4};
175	aclDataType otherDtype = ACL_FLOAT;
176	aclFormat otherFormat = ACL_FORMAT_NCHW;
177	// output
178	const vector<int64_t>& outShape = selfShape;
179	aclDataType outDtype = ACL_FLOAT;
180	aclFormat outFormat = ACL_FORMAT_NCHW;
181
182	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
183	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
184	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
185
186	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
187	uint64_t workspaceSize = 0;
188	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
189	EXPECT_EQ(aclRet, ACL_SUCCESS);
190	}
191
192	TEST_F(l2_atan2_test, aclnnAtan2_1_2_3_4_double_uint8_nhwc) {
193	// self input
194	const vector<int64_t>& selfShape = {1, 2, 3, 4};
195	aclDataType selfDtype = ACL_DOUBLE;
196	aclFormat selfFormat = ACL_FORMAT_NHWC;
197	// other input
198	const vector<int64_t>& otherShape = {4};
199	aclDataType otherDtype = ACL_UINT8;
200	aclFormat otherFormat = ACL_FORMAT_NHWC;
201	// output
202	const vector<int64_t>& outShape = selfShape;
203	aclDataType outDtype = selfDtype;
204	aclFormat outFormat = ACL_FORMAT_NHWC;
205
206	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
207	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{3, 2, 1, 0});
208	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
209
210	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
211
212	uint64_t workspaceSize = 0;
213	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
214	EXPECT_EQ(aclRet, ACL_SUCCESS);
215
216	}
217
218	TEST_F(l2_atan2_test, ascend910B2_aclnnAtan2_1_bool_nhwc) {
219	// self input
220	const vector<int64_t>& selfShape = {3};
221	aclDataType selfDtype = ACL_BOOL;
222	aclFormat selfFormat = ACL_FORMAT_NHWC;
223	// other input
224	const vector<int64_t>& otherShape = {3};
225	aclDataType otherDtype = ACL_BOOL;
226	aclFormat otherFormat = ACL_FORMAT_NHWC;
227	// output
228	const vector<int64_t>& outShape = selfShape;
229	aclDataType outDtype = ACL_FLOAT;
230	aclFormat outFormat = ACL_FORMAT_NHWC;
231
232	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
233	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
234	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
235
236	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
237
238	uint64_t workspaceSize = 0;
239	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
240	EXPECT_EQ(aclRet, ACL_SUCCESS);
241
242	}
243
244	TEST_F(l2_atan2_test, aclnnAtan2_1_2_3_4_int8_int32_hwcn) {
245	// self input
246	const vector<int64_t>& selfShape = {1, 2, 3};
247	aclDataType selfDtype = ACL_INT8;
248	aclFormat selfFormat = ACL_FORMAT_HWCN;
249	// other input
250	const vector<int64_t>& otherShape = {1, 2, 3};
251	aclDataType otherDtype = ACL_INT32;
252	aclFormat otherFormat = ACL_FORMAT_HWCN;
253	// output
254	const vector<int64_t>& outShape = selfShape;
255	aclDataType outDtype = ACL_FLOAT16;
256	aclFormat outFormat = ACL_FORMAT_HWCN;
257
258	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
259	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
260	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
261
262	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
263
264	uint64_t workspaceSize = 0;
265	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
266	EXPECT_EQ(aclRet, ACL_SUCCESS);
267	}
268
269	// 各元素特殊类型覆盖用例
270	// 空tensor
271	TEST_F(l2_atan2_test, aclnnAtan2_float_nd_empty_tensor) {
272	// self input
273	const vector<int64_t>& selfShape = {0};
274	aclDataType selfDtype = ACL_FLOAT;
275	aclFormat selfFormat = ACL_FORMAT_ND;
276	// other input
277	const vector<int64_t>& otherShape = {0};
278
279	aclDataType otherDtype = ACL_INT64;
280	aclFormat otherFormat = ACL_FORMAT_ND;
281	// output
282	const vector<int64_t>& outShape = {0};
283	aclDataType outDtype = selfDtype;
284	aclFormat outFormat = ACL_FORMAT_ND;
285
286	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
287	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
288	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
289
290	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
291
292	uint64_t workspaceSize = 0;
293	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
294	EXPECT_EQ(aclRet, ACL_SUCCESS);
295
296	}
297
298	// 边界值
299	TEST_F(l2_atan2_test, aclnnAtan2_float32_nd_boundary_value) {
300	// self input
301	const vector<int64_t>& selfShape = {1, 2};
302	aclDataType selfDtype = ACL_FLOAT;
303	aclFormat selfFormat = ACL_FORMAT_ND;
304	// other input
305	const vector<int64_t>& otherShape = {1, 2};
306	aclDataType otherDtype = ACL_INT64;
307	aclFormat otherFormat = ACL_FORMAT_ND;
308	// output3
309	const vector<int64_t>& outShape = selfShape;
310	aclDataType outDtype = selfDtype;
311	aclFormat outFormat = ACL_FORMAT_ND;
312
313	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).Value(vector<float>{65504.0, -65504.0});
314	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{1, 0});
315	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
316
317	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
318
319	uint64_t workspaceSize = 0;
320	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
321	EXPECT_EQ(aclRet, ACL_SUCCESS);
322
323	}
324
325	// 不连续
326	TEST_F(l2_atan2_test, aclnnAtan2_5_4_float_nd_not_contiguous) {
327	// self input
328	const vector<int64_t>& selfShape = {5, 4};
329	aclDataType selfDtype = ACL_FLOAT;
330	aclFormat selfFormat = ACL_FORMAT_ND;
331	const vector<int64_t>& selfViewDim = {1, 5};
332	int64_t selfOffset = 0;
333	const vector<int64_t>& selfStorageDim = {4, 5};
334	// other input
335	const vector<int64_t>& otherShape = {5, 4};
336	aclDataType otherDtype = ACL_FLOAT;
337	aclFormat otherFormat = ACL_FORMAT_ND;
338	const vector<int64_t>& otherViewDim = {1, 5};
339	int64_t otherOffset = 0;
340	const vector<int64_t>& otherStorageDim = {4, 5};
341	// output
342	const vector<int64_t>& outShape = {5, 4};
343	aclDataType outDtype = selfDtype;
344	aclFormat outFormat = ACL_FORMAT_ND;
345	const vector<int64_t>& outViewDim = {1, 5};
346	int64_t sourceOffset = 0;
347	const vector<int64_t>& outStorageDim = {4, 5};
348
349	auto selfTensorDesc =
350	TensorDesc(selfShape, selfDtype, selfFormat, selfViewDim, selfOffset, selfStorageDim).ValueRange(-2, 2);
351
352	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat, otherViewDim, otherOffset, otherStorageDim);
353
354	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat, outViewDim, sourceOffset, outStorageDim);
355
356	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
357
358	uint64_t workspaceSize = 0;
359	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
360	EXPECT_EQ(aclRet, ACL_SUCCESS);
361	}
362
363	// 报错类型覆盖用例
364	// 空指针
365	TEST_F(l2_atan2_test, aclnnAtan2_input_nullptr) {
366	auto tensor_desc = TensorDesc({10}, ACL_FLOAT, ACL_FORMAT_ND);
367
368	auto ut_self_nullptr = OP_API_UT(aclnnAtan2, INPUT((aclTensor*)nullptr, tensor_desc), OUTPUT(tensor_desc));
369
370	uint64_t workspaceSize = 0;
371	aclnnStatus aclRet = ut_self_nullptr.TestGetWorkspaceSize(&workspaceSize);
372	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
373
374	auto ut_index_nullptr = OP_API_UT(aclnnAtan2, INPUT(tensor_desc, (aclTensor*)nullptr), OUTPUT(tensor_desc));
375
376	aclRet = ut_index_nullptr.TestGetWorkspaceSize(&workspaceSize);
377	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
378
379	auto ut_source_nullptr = OP_API_UT(aclnnAtan2, INPUT(tensor_desc, tensor_desc), OUTPUT((aclTensor*)nullptr));
380
381	aclRet = ut_source_nullptr.TestGetWorkspaceSize(&workspaceSize);
382	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
383	}
384
385	// self类型不满足
386	TEST_F(l2_atan2_test, aclnnAtan2_self_dtype_error) {
387	// self input
388	const vector<int64_t>& selfShape = {2, 4};
389	aclDataType selfDtype = ACL_COMPLEX64;
390	aclFormat selfFormat = ACL_FORMAT_ND;
391	// other input
392	const vector<int64_t>& otherShape = {2, 4};
393	aclDataType otherDtype = ACL_INT64;
394	aclFormat otherFormat = ACL_FORMAT_ND;
395	// output
396	const vector<int64_t>& outShape = selfShape;
397	aclDataType outDtype = ACL_FLOAT;
398	aclFormat outFormat = ACL_FORMAT_ND;
399
400	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
401	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
402	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
403
404	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
405
406	uint64_t workspaceSize = 0;
407	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
408	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
409	}
410
411	// index类型不满足
412	TEST_F(l2_atan2_test, aclnnAtan2_index_dtype_error) {
413	// self input
414	const vector<int64_t>& selfShape = {2, 4};
415	aclDataType selfDtype = ACL_INT64;
416	aclFormat selfFormat = ACL_FORMAT_ND;
417	// other input
418	const vector<int64_t>& otherShape = {2, 4};
419	aclDataType otherDtype = ACL_COMPLEX64;
420	aclFormat otherFormat = ACL_FORMAT_ND;
421	// output
422	const vector<int64_t>& outShape = selfShape;
423	aclDataType outDtype = ACL_FLOAT;
424	aclFormat outFormat = ACL_FORMAT_ND;
425
426	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
427	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
428	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
429
430	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
431
432	uint64_t workspaceSize = 0;
433	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
434	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
435	}
436
437	// 形状大于8
438	TEST_F(l2_atan2_test, aclnnAtan2_self_shape_out_of_8) {
439	auto out_shape_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, ACL_FLOAT, ACL_FORMAT_ND);
440	auto normal_tensor_desc = TensorDesc({10}, ACL_FLOAT, ACL_FORMAT_ND);
441
442	// self形状大于8
443	auto self_out_of_shape_ut =
444	OP_API_UT(aclnnAtan2, INPUT(out_shape_tensor_desc, normal_tensor_desc), OUTPUT(normal_tensor_desc));
445
446	uint64_t workspaceSize = 0;
447	aclnnStatus aclRet = self_out_of_shape_ut.TestGetWorkspaceSize(&workspaceSize);
448	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
449
450	// other形状大于8
451	auto other_out_of_shape_ut =
452	OP_API_UT(aclnnAtan2, INPUT(normal_tensor_desc, out_shape_tensor_desc), OUTPUT(normal_tensor_desc));
453	aclRet = other_out_of_shape_ut.TestGetWorkspaceSize(&workspaceSize);
454	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
455	}
456
457	TEST_F(l2_atan2_test, ascend910B2_aclnnAtan2_bf16_nhwc) {
458	// self input
459	const vector<int64_t>& selfShape = {1, 2, 3, 4};
460	aclDataType selfDtype = ACL_BF16;
461	aclFormat selfFormat = ACL_FORMAT_NHWC;
462	// other input
463	const vector<int64_t>& otherShape = {4};
464	aclDataType otherDtype = ACL_BF16;
465	aclFormat otherFormat = ACL_FORMAT_NHWC;
466	// output
467	const vector<int64_t>& outShape = selfShape;
468	aclDataType outDtype = selfDtype;
469	aclFormat outFormat = ACL_FORMAT_NHWC;
470
471	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
472	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{3, 2, 1, 0});
473	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
474
475	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
476
477	uint64_t workspaceSize = 0;
478	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
479	EXPECT_EQ(aclRet, ACL_SUCCESS);
480	}
481
482	TEST_F(l2_atan2_test, aclnnAtan2_bf16_nhwc) {
483	// self input
484	const vector<int64_t>& selfShape = {1, 2, 3, 4};
485	aclDataType selfDtype = ACL_BF16;
486	aclFormat selfFormat = ACL_FORMAT_NHWC;
487	// other input
488	const vector<int64_t>& otherShape = {4};
489	aclDataType otherDtype = ACL_BF16;
490	aclFormat otherFormat = ACL_FORMAT_NHWC;
491	// output
492	const vector<int64_t>& outShape = selfShape;
493	aclDataType outDtype = selfDtype;
494	aclFormat outFormat = ACL_FORMAT_NHWC;
495
496	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
497	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{3, 2, 1, 0});
498	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
499
500	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
501
502	uint64_t workspaceSize = 0;
503	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
504	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
505	}
506
507	// TEST BROADCAST
508	TEST_F(l2_atan2_test, ascend910B2_atan2_self_broadcast) {
509	// self input
510	const vector<int64_t>& selfShape = {2};
511	aclDataType selfDtype = ACL_FLOAT;
512	aclFormat selfFormat = ACL_FORMAT_ND;
513	// other input
514	const vector<int64_t>& otherShape = {4, 2};
515	aclDataType otherDtype = ACL_FLOAT;
516	aclFormat otherFormat = ACL_FORMAT_ND;
517	// output
518	const vector<int64_t>& outShape = {4, 2};
519	aclDataType outDtype = ACL_FLOAT;
520	aclFormat outFormat = ACL_FORMAT_ND;
521
522	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
523	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
524	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
525
526	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
527
528	uint64_t workspaceSize = 0;
529	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
530	EXPECT_EQ(aclRet, ACL_SUCCESS);
531
532	}
533
534	// 形状大于8
535	TEST_F(l2_atan2_test, ascend910B2_atan2_inferdtype_test) {
536	// self input
537	const vector<int64_t>& selfShape = {2};
538	aclDataType selfDtype = ACL_COMPLEX64;
539	aclFormat selfFormat = ACL_FORMAT_ND;
540	// other input
541	const vector<int64_t>& otherShape = {4, 2};
542	aclDataType otherDtype = ACL_INT32;
543	aclFormat otherFormat = ACL_FORMAT_ND;
544	// output
545	const vector<int64_t>& outShape = {4, 2};
546	aclDataType outDtype = ACL_COMPLEX64;
547	aclFormat outFormat = ACL_FORMAT_ND;
548
549	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
550	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
551	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
552
553	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
554
555	uint64_t workspaceSize = 0;
556	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
557	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
558	}
559
560	// TEST Cast
561	TEST_F(l2_atan2_test, ascend910B2_atan2_self_int16_other_int64_out_bool) {
562	// self input
563	const vector<int64_t>& selfShape = {2};
564	aclDataType selfDtype = ACL_INT64;
565	aclFormat selfFormat = ACL_FORMAT_ND;
566	// other input
567	const vector<int64_t>& otherShape = {4, 2};
568	aclDataType otherDtype = ACL_INT16;
569	aclFormat otherFormat = ACL_FORMAT_ND;
570	// output
571	const vector<int64_t>& outShape = {4, 2};
572	aclDataType outDtype = ACL_BOOL;
573	aclFormat outFormat = ACL_FORMAT_ND;
574
575	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
576	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
577	auto outTensorDesc = TensorDesc(outShape, outDtype, outFormat);
578
579	auto ut = OP_API_UT(aclnnAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT(outTensorDesc));
580
581	uint64_t workspaceSize = 0;
582	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
583	EXPECT_EQ(aclRet, ACL_SUCCESS);
584
585	}

Dmath/atan2/tests/ut/op_host/op_api/test_inplace_atan2.cpp+0-459

	@@ -1,459 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10	#include <array>
11	#include <vector>
12	#include "gtest/gtest.h"
13
14	#include "../../../../op_host/op_api/aclnn_atan2.h"
15
16	#include "op_api_ut_common/op_api_ut.h"
17	#include "op_api_ut_common/scalar_desc.h"
18	#include "op_api_ut_common/tensor_desc.h"
19	#include <cstdlib>
20	#include <ctime>
21
22	using namespace op;
23	using namespace std;
24
25	class l2_inplace_atan2_test : public testing::Test {
26	protected:
27	static void SetUpTestCase() {
28	std::cout << "inplace_atan2_test SetUp" << std::endl;
29	}
30
31	static void TearDownTestCase() {
32	std::cout << "inplace_atan2_test TearDown" << std::endl;
33	}
34	};
35
36	// 基础用例
37	TEST_F(l2_inplace_atan2_test, ascend910B2_aclnnInplaceAtan2_base_case_1) {
38	// self input
39	const vector<int64_t>& selfShape = {2, 4};
40	aclDataType selfDtype = ACL_FLOAT;
41	aclFormat selfFormat = ACL_FORMAT_ND;
42	// other input
43	const vector<int64_t>& otherShape = {2, 4};
44	aclDataType otherDtype = ACL_FLOAT;
45	aclFormat otherFormat = ACL_FORMAT_ND;
46
47	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8});
48	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<float>{8, 7, 6, 5, 4, 3, 2, 1});
49
50	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
51
52	uint64_t workspaceSize = 0;
53	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
54	EXPECT_EQ(aclRet, ACL_SUCCESS);
55
56	}
57
58	TEST_F(l2_inplace_atan2_test, ascend910B2_aclnnInplaceAtan2_base_case_2) {
59	// self input
60	const vector<int64_t>& selfShape = {2, 4};
61	aclDataType selfDtype = ACL_INT32;
62	aclFormat selfFormat = ACL_FORMAT_ND;
63	// other input
64	const vector<int64_t>& otherShape = {2, 4};
65	aclDataType otherDtype = ACL_FLOAT;
66	aclFormat otherFormat = ACL_FORMAT_ND;
67
68	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8});
69	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<float>{8, 7, 6, 5, 4, 3, 2, 1});
70
71	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
72
73	uint64_t workspaceSize = 0;
74	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
75	EXPECT_EQ(aclRet, ACL_SUCCESS);
76
77	}
78
79	/* 各元素基本类型覆盖用例
80	* 维度：1-8维
81	* float16,bfloat16,float,float64,int8,int16,int32,int64,uint8,bool
82	* 数据格式：ND、NCHW、NHWC、HWCN、NDHWC、NCDHW
83	*/
84
85	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_1_2_3_4_5_6_7_8_float_nd) {
86	// self input
87	const vector<int64_t>& selfShape = {1, 2, 3, 4, 5, 6, 7, 8};
88	aclDataType selfDtype = ACL_FLOAT;
89	aclFormat selfFormat = ACL_FORMAT_ND;
90	// other input
91	const vector<int64_t>& otherShape = {1, 2, 3, 4, 5, 6, 7, 8};
92	aclDataType otherDtype = ACL_FLOAT;
93	aclFormat otherFormat = ACL_FORMAT_ND;
94
95	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
96	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
97	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
98
99	uint64_t workspaceSize = 0;
100	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
101	EXPECT_EQ(aclRet, ACL_SUCCESS);
102	}
103
104	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_1_2_3_4_5_6_7_float16_nd) {
105	// self input
106	const vector<int64_t>& selfShape = {1, 2, 3, 4, 5, 6, 7};
107	aclDataType selfDtype = ACL_FLOAT16;
108	aclFormat selfFormat = ACL_FORMAT_ND;
109	// other input
110	const vector<int64_t>& otherShape = {1, 2, 3, 4, 5, 6, 7};
111	aclDataType otherDtype = ACL_FLOAT16;
112	aclFormat otherFormat = ACL_FORMAT_ND;
113
114	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
115	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
116
117	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
118	uint64_t workspaceSize = 0;
119	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
120	EXPECT_EQ(aclRet, ACL_SUCCESS);
121	}
122
123	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_1_2_3_4_int32_nchw) {
124	// self input
125	const vector<int64_t>& selfShape = {1, 2, 3, 4};
126	aclDataType selfDtype = ACL_INT32;
127	aclFormat selfFormat = ACL_FORMAT_NCHW;
128	// other input
129	const vector<int64_t>& otherShape = {1, 2, 3, 4};
130	aclDataType otherDtype = ACL_INT32;
131	aclFormat otherFormat = ACL_FORMAT_NCHW;
132
133	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).ValueRange(-1, 1);
134	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
135
136	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
137	uint64_t workspaceSize = 0;
138	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
139	EXPECT_EQ(aclRet, ACL_SUCCESS);
140	}
141
142	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_1_2_3_4_int8_float_nchw) {
143	// self input
144	const vector<int64_t>& selfShape = {1, 2, 3, 4};
145	aclDataType selfDtype = ACL_INT8;
146	aclFormat selfFormat = ACL_FORMAT_NCHW;
147	// other input
148	const vector<int64_t>& otherShape = {1, 2, 3, 4};
149	aclDataType otherDtype = ACL_FLOAT;
150	aclFormat otherFormat = ACL_FORMAT_NCHW;
151
152	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
153	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
154
155	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
156	uint64_t workspaceSize = 0;
157	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
158	EXPECT_EQ(aclRet, ACL_SUCCESS);
159	}
160
161	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_1_2_3_4_double_uint8_nhwc) {
162	// self input
163	const vector<int64_t>& selfShape = {1, 2, 3, 4};
164	aclDataType selfDtype = ACL_DOUBLE;
165	aclFormat selfFormat = ACL_FORMAT_NHWC;
166	// other input
167	const vector<int64_t>& otherShape = {4};
168	aclDataType otherDtype = ACL_UINT8;
169	aclFormat otherFormat = ACL_FORMAT_NHWC;
170
171	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
172	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{3, 2, 1, 0});
173
174	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
175
176	uint64_t workspaceSize = 0;
177	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
178	EXPECT_EQ(aclRet, ACL_SUCCESS);
179
180	}
181
182	TEST_F(l2_inplace_atan2_test, ascend910B2_aclnnInplaceAtan2_1_bool_nhwc) {
183	// self input
184	const vector<int64_t>& selfShape = {3};
185	aclDataType selfDtype = ACL_BOOL;
186	aclFormat selfFormat = ACL_FORMAT_NHWC;
187	// other input
188	const vector<int64_t>& otherShape = {3};
189	aclDataType otherDtype = ACL_BOOL;
190	aclFormat otherFormat = ACL_FORMAT_NHWC;
191
192	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
193	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
194
195	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
196
197	uint64_t workspaceSize = 0;
198	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
199	EXPECT_EQ(aclRet, ACL_SUCCESS);
200
201	}
202
203	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_1_2_3_4_int8_int32_hwcn) {
204	// self input
205	const vector<int64_t>& selfShape = {1, 2, 3};
206	aclDataType selfDtype = ACL_INT8;
207	aclFormat selfFormat = ACL_FORMAT_HWCN;
208	// other input
209	const vector<int64_t>& otherShape = {1, 2, 3};
210	aclDataType otherDtype = ACL_INT32;
211	aclFormat otherFormat = ACL_FORMAT_HWCN;
212
213	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
214	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
215
216	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
217
218	uint64_t workspaceSize = 0;
219	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
220	EXPECT_EQ(aclRet, ACL_SUCCESS);
221	}
222
223	// 各元素特殊类型覆盖用例
224	// 空tensor
225	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_float_nd_empty_tensor) {
226	// self input
227	const vector<int64_t>& selfShape = {0};
228	aclDataType selfDtype = ACL_FLOAT;
229	aclFormat selfFormat = ACL_FORMAT_ND;
230	// other input
231	const vector<int64_t>& otherShape = {0};
232
233	aclDataType otherDtype = ACL_INT64;
234	aclFormat otherFormat = ACL_FORMAT_ND;
235
236	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
237	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
238
239	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
240
241	uint64_t workspaceSize = 0;
242	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
243	EXPECT_EQ(aclRet, ACL_SUCCESS);
244
245	}
246
247	// 边界值
248	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_float32_nd_boundary_value) {
249	// self input
250	const vector<int64_t>& selfShape = {1, 2};
251	aclDataType selfDtype = ACL_FLOAT;
252	aclFormat selfFormat = ACL_FORMAT_ND;
253	// other input
254	const vector<int64_t>& otherShape = {1, 2};
255	aclDataType otherDtype = ACL_INT64;
256	aclFormat otherFormat = ACL_FORMAT_ND;
257
258	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat).Value(vector<float>{65504.0, -65504.0});
259	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{1, 0});
260
261	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
262
263	uint64_t workspaceSize = 0;
264	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
265	EXPECT_EQ(aclRet, ACL_SUCCESS);
266
267	}
268
269	// 不连续
270	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_5_4_float_nd_not_contiguous) {
271	// self input
272	const vector<int64_t>& selfShape = {5, 4};
273	aclDataType selfDtype = ACL_FLOAT;
274	aclFormat selfFormat = ACL_FORMAT_ND;
275	const vector<int64_t>& selfViewDim = {1, 5};
276	int64_t selfOffset = 0;
277	const vector<int64_t>& selfStorageDim = {4, 5};
278	// other input
279	const vector<int64_t>& otherShape = {5, 4};
280	aclDataType otherDtype = ACL_FLOAT;
281	aclFormat otherFormat = ACL_FORMAT_ND;
282	const vector<int64_t>& otherViewDim = {1, 5};
283	int64_t otherOffset = 0;
284	const vector<int64_t>& otherStorageDim = {4, 5};
285
286	auto selfTensorDesc =
287	TensorDesc(selfShape, selfDtype, selfFormat, selfViewDim, selfOffset, selfStorageDim).ValueRange(-2, 2);
288
289	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat, otherViewDim, otherOffset, otherStorageDim);
290
291
292	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
293
294	uint64_t workspaceSize = 0;
295	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
296	EXPECT_EQ(aclRet, ACL_SUCCESS);
297	}
298
299	// 报错类型覆盖用例
300	// 空指针
301	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_input_nullptr) {
302	auto tensor_desc = TensorDesc({10}, ACL_FLOAT, ACL_FORMAT_ND);
303
304	auto ut_self_nullptr = OP_API_UT(aclnnInplaceAtan2, INPUT((aclTensor*)nullptr, tensor_desc), OUTPUT());
305
306	uint64_t workspaceSize = 0;
307	aclnnStatus aclRet = ut_self_nullptr.TestGetWorkspaceSize(&workspaceSize);
308	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
309
310	auto ut_index_nullptr = OP_API_UT(aclnnInplaceAtan2, INPUT(tensor_desc, (aclTensor*)nullptr), OUTPUT());
311
312	aclRet = ut_index_nullptr.TestGetWorkspaceSize(&workspaceSize);
313	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
314	}
315
316	// self类型不满足
317	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_self_dtype_error) {
318	// self input
319	const vector<int64_t>& selfShape = {2, 4};
320	aclDataType selfDtype = ACL_COMPLEX64;
321	aclFormat selfFormat = ACL_FORMAT_ND;
322	// other input
323	const vector<int64_t>& otherShape = {2, 4};
324	aclDataType otherDtype = ACL_INT64;
325	aclFormat otherFormat = ACL_FORMAT_ND;
326
327	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
328	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
329
330	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
331
332	uint64_t workspaceSize = 0;
333	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
334	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
335	}
336
337	// index类型不满足
338	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_index_dtype_error) {
339	// self input
340	const vector<int64_t>& selfShape = {2, 4};
341	aclDataType selfDtype = ACL_INT64;
342	aclFormat selfFormat = ACL_FORMAT_ND;
343	// other input
344	const vector<int64_t>& otherShape = {2, 4};
345	aclDataType otherDtype = ACL_COMPLEX64;
346	aclFormat otherFormat = ACL_FORMAT_ND;
347
348	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
349	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
350
351	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
352
353	uint64_t workspaceSize = 0;
354	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
355	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
356	}
357
358	// 形状大于8
359	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_self_shape_out_of_8) {
360	auto out_shape_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, ACL_FLOAT, ACL_FORMAT_ND);
361	auto normal_tensor_desc = TensorDesc({10}, ACL_FLOAT, ACL_FORMAT_ND);
362
363	// self形状大于8
364	auto self_out_of_shape_ut =
365	OP_API_UT(aclnnInplaceAtan2, INPUT(out_shape_tensor_desc, normal_tensor_desc), OUTPUT());
366
367	uint64_t workspaceSize = 0;
368	aclnnStatus aclRet = self_out_of_shape_ut.TestGetWorkspaceSize(&workspaceSize);
369	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
370
371	// other形状大于8
372	auto other_out_of_shape_ut =
373	OP_API_UT(aclnnInplaceAtan2, INPUT(normal_tensor_desc, out_shape_tensor_desc), OUTPUT());
374	aclRet = other_out_of_shape_ut.TestGetWorkspaceSize(&workspaceSize);
375	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
376	}
377
378	TEST_F(l2_inplace_atan2_test, ascend910B2_aclnnInplaceAtan2_bf16_nhwc) {
379	// self input
380	const vector<int64_t>& selfShape = {1, 2, 3, 4};
381	aclDataType selfDtype = ACL_BF16;
382	aclFormat selfFormat = ACL_FORMAT_NHWC;
383	// other input
384	const vector<int64_t>& otherShape = {4};
385	aclDataType otherDtype = ACL_BF16;
386	aclFormat otherFormat = ACL_FORMAT_NHWC;
387
388	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
389	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{3, 2, 1, 0});
390
391	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
392
393	uint64_t workspaceSize = 0;
394	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
395	EXPECT_EQ(aclRet, ACL_SUCCESS);
396	}
397
398	TEST_F(l2_inplace_atan2_test, aclnnInplaceAtan2_bf16_nhwc) {
399	// self input
400	const vector<int64_t>& selfShape = {1, 2, 3, 4};
401	aclDataType selfDtype = ACL_BF16;
402	aclFormat selfFormat = ACL_FORMAT_NHWC;
403	// other input
404	const vector<int64_t>& otherShape = {4};
405	aclDataType otherDtype = ACL_BF16;
406	aclFormat otherFormat = ACL_FORMAT_NHWC;
407
408	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
409	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat).Value(vector<int32_t>{3, 2, 1, 0});
410
411	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
412
413	uint64_t workspaceSize = 0;
414	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
415	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
416	}
417
418	// TEST BROADCAST
419	TEST_F(l2_inplace_atan2_test, ascend910B2_atan2_self_broadcast) {
420	// self input
421	const vector<int64_t>& selfShape = {2};
422	aclDataType selfDtype = ACL_FLOAT;
423	aclFormat selfFormat = ACL_FORMAT_ND;
424	// other input
425	const vector<int64_t>& otherShape = {4, 2};
426	aclDataType otherDtype = ACL_FLOAT;
427	aclFormat otherFormat = ACL_FORMAT_ND;
428
429	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
430	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
431
432	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
433
434	uint64_t workspaceSize = 0;
435	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
436	EXPECT_EQ(aclRet, ACL_SUCCESS);
437
438	}
439
440	// 形状大于8
441	TEST_F(l2_inplace_atan2_test, ascend910B2_atan2_inferdtype_test) {
442	// self input
443	const vector<int64_t>& selfShape = {2};
444	aclDataType selfDtype = ACL_COMPLEX64;
445	aclFormat selfFormat = ACL_FORMAT_ND;
446	// other input
447	const vector<int64_t>& otherShape = {4, 2};
448	aclDataType otherDtype = ACL_INT32;
449	aclFormat otherFormat = ACL_FORMAT_ND;
450
451	auto selfTensorDesc = TensorDesc(selfShape, selfDtype, selfFormat);
452	auto otherTensorDesc = TensorDesc(otherShape, otherDtype, otherFormat);
453
454	auto ut = OP_API_UT(aclnnInplaceAtan2, INPUT(selfTensorDesc, otherTensorDesc), OUTPUT());
455
456	uint64_t workspaceSize = 0;
457	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
458	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
459	}

Amath/atanh/tests/ut/op_api/test_atanh.cpp+165-0

@@ -0,0 +1,165 @@
	1	/**
	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10	#include <array>
	11	#include <vector>
	12	#include "gtest/gtest.h"
	13
	14	#include "../../../op_api/aclnn_atanh.h"
	15
	16	#include "op_api_ut_common/inner/types.h"
	17	#include "op_api_ut_common/op_api_ut.h"
	18	#include "op_api_ut_common/scalar_desc.h"
	19	#include "op_api_ut_common/tensor_desc.h"
	20
	21	using namespace std;
	22
	23	class l2_atanh_test : public testing::Test {
	24	protected:
	25	static void SetUpTestCase() { cout << "l2_atanh_test SetUp" << endl; }
	26
	27	static void TearDownTestCase() { cout << "l2_atanh_test TearDown" << endl; }
	28	};
	29
	30	TEST_F(l2_atanh_test, atanh_int_float)
	31	{
	32	auto self_tensor_desc = TensorDesc({3, 5}, ACL_INT16, ACL_FORMAT_ND).ValueRange(-1, 1);
	33	auto out_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	34
	35	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	36	uint64_t workspace_size = 0;
	37	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	38	EXPECT_EQ(aclRet, ACL_SUCCESS);
	39	}
	40
	41	TEST_F(l2_atanh_test, atanh_float_float16)
	42	{
	43	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	44	auto out_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT16, ACL_FORMAT_ND).Precision(0.001, 0.001);
	45
	46	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	47	uint64_t workspace_size = 0;
	48	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	49	EXPECT_EQ(aclRet, ACL_SUCCESS);
	50	}
	51
	52	TEST_F(l2_atanh_test, ascend910B2_atanh_bfloat16_bfloat16)
	53	{
	54	auto self_tensor_desc = TensorDesc({3, 5}, ACL_BF16, ACL_FORMAT_ND).ValueRange(-1, 1);
	55	auto out_tensor_desc = TensorDesc({3, 5}, ACL_BF16, ACL_FORMAT_ND).Precision(0.001, 0.001);
	56
	57	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	58	uint64_t workspace_size = 0;
	59	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	60	EXPECT_EQ(aclRet, ACL_SUCCESS);
	61	}
	62
	63	TEST_F(l2_atanh_test, atanh_float_int)
	64	{
	65	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	66	auto out_tensor_desc = TensorDesc({3, 5}, ACL_INT16, ACL_FORMAT_ND);
	67
	68	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	69	uint64_t workspace_size = 0;
	70	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	71	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	72	}
	73
	74	TEST_F(l2_atanh_test, atanh_different_shape)
	75	{
	76	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	77	auto out_tensor_desc = TensorDesc({2, 5}, ACL_FLOAT, ACL_FORMAT_ND);
	78
	79	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	80	uint64_t workspace_size = 0;
	81	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	82	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	83	}
	84
	85	TEST_F(l2_atanh_test, atanh_nullptr)
	86	{
	87	auto ut = OP_API_UT(aclnnAtanh, INPUT((aclTensor)nullptr), OUTPUT((aclTensor)nullptr));
	88	uint64_t workspace_size = 0;
	89	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	90	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	91	}
	92
	93	TEST_F(l2_atanh_test, atanh_out_nullptr)
	94	{
	95	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	96	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(nullptr));
	97	uint64_t workspaceSize = 0;
	98	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	99	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	100	}
	101
	102	TEST_F(l2_atanh_test, atanh_precision)
	103	{
	104	auto self_tensor_desc = TensorDesc({3, 6, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	105	auto out_tensor_desc = TensorDesc({3, 6, 9}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.0001, 0.0001);
	106
	107	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	108	uint64_t workspace_size = 0;
	109	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	110	EXPECT_EQ(aclRet, ACL_SUCCESS);
	111	}
	112
	113	TEST_F(l2_atanh_test, atanh_empty_tensor)
	114	{
	115	auto self_tensor_desc = TensorDesc({13, 0, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	116	auto out_tensor_desc = TensorDesc({13, 0, 9}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	117
	118	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	119	uint64_t workspace_size = 0;
	120	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	121	EXPECT_EQ(aclRet, ACL_SUCCESS);
	122	}
	123
	124	TEST_F(l2_atanh_test, atanh_non_contiguous)
	125	{
	126	auto self_tensor_desc = TensorDesc({5, 3}, ACL_FLOAT, ACL_FORMAT_ND, {1, 5}, 0, {3, 5}).ValueRange(-1, 1);
	127	auto out_tensor_desc = TensorDesc({5, 3}, ACL_FLOAT, ACL_FORMAT_ND, {1, 5}, 0, {3, 5}).Precision(0.001, 0.001);
	128
	129	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	130	uint64_t workspace_size = 0;
	131	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	132	EXPECT_EQ(aclRet, ACL_SUCCESS);
	133	}
	134
	135	TEST_F(l2_atanh_test, atanh_lessDim)
	136	{
	137	auto self_tensor_desc = TensorDesc({2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	138	auto out_tensor_desc = TensorDesc({2}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	139
	140	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	141	uint64_t workspace_size = 0;
	142	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	143	EXPECT_EQ(aclRet, ACL_SUCCESS);
	144	}
	145
	146	TEST_F(l2_atanh_test, atanh_bigDim)
	147	{
	148	auto self_tensor_desc = TensorDesc({2, 2, 2, 2, 2, 2, 2, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	149	auto out_tensor_desc = TensorDesc({2, 2, 2, 2, 2, 2, 2, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
	150
	151	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
	152	uint64_t workspace_size = 0;
	153	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	154	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	155	}
	156
	157	TEST_F(l2_atanh_test, atanh_inplace)
	158	{
	159	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	160	auto ut = OP_API_UT(aclnnInplaceAtanh, INPUT(self_tensor_desc), OUTPUT());
	161
	162	uint64_t workspace_size = 0;
	163	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	164	EXPECT_EQ(aclRet, ACL_SUCCESS);
	165	}

Dmath/atanh/tests/ut/op_host/CMakeLists.txt+0-20

	@@ -1,20 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()
18
19	if(OP_API_UT OR (UT_TEST_ALL AND NOT AICPU_ONLY))
20	endif()

Dmath/atanh/tests/ut/op_host/op_api/CMakeLists.txt+0-10

	@@ -1,10 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------

Dmath/atanh/tests/ut/op_host/op_api/test_atanh.cpp+0-156

	@@ -1,156 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10	#include <array>
11	#include <vector>
12	#include "gtest/gtest.h"
13
14	#include "../../../../op_host/op_api/aclnn_atanh.h"
15
16	#include "op_api_ut_common/inner/types.h"
17	#include "op_api_ut_common/op_api_ut.h"
18	#include "op_api_ut_common/scalar_desc.h"
19	#include "op_api_ut_common/tensor_desc.h"
20
21	using namespace std;
22
23	class l2_atanh_test : public testing::Test {
24	protected:
25	static void SetUpTestCase() {
26	cout << "l2_atanh_test SetUp" << endl;
27	}
28
29	static void TearDownTestCase() {
30	cout << "l2_atanh_test TearDown" << endl;
31	}
32	};
33
34	TEST_F(l2_atanh_test, atanh_int_float) {
35	auto self_tensor_desc = TensorDesc({3, 5}, ACL_INT16, ACL_FORMAT_ND).ValueRange(-1, 1);
36	auto out_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
37
38	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
39	uint64_t workspace_size = 0;
40	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
41	EXPECT_EQ(aclRet, ACL_SUCCESS);
42	}
43
44	TEST_F(l2_atanh_test, atanh_float_float16) {
45	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
46	auto out_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT16, ACL_FORMAT_ND).Precision(0.001, 0.001);
47
48	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
49	uint64_t workspace_size = 0;
50	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
51	EXPECT_EQ(aclRet, ACL_SUCCESS);
52	}
53
54	TEST_F(l2_atanh_test, ascend910B2_atanh_bfloat16_bfloat16) {
55	auto self_tensor_desc = TensorDesc({3, 5}, ACL_BF16, ACL_FORMAT_ND).ValueRange(-1, 1);
56	auto out_tensor_desc = TensorDesc({3, 5}, ACL_BF16, ACL_FORMAT_ND).Precision(0.001, 0.001);
57
58	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
59	uint64_t workspace_size = 0;
60	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
61	EXPECT_EQ(aclRet, ACL_SUCCESS);
62	}
63
64	TEST_F(l2_atanh_test, atanh_float_int) {
65	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
66	auto out_tensor_desc = TensorDesc({3, 5}, ACL_INT16, ACL_FORMAT_ND);
67
68	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
69	uint64_t workspace_size = 0;
70	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
71	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
72	}
73
74	TEST_F(l2_atanh_test, atanh_different_shape) {
75	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
76	auto out_tensor_desc = TensorDesc({2, 5}, ACL_FLOAT, ACL_FORMAT_ND);
77
78	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
79	uint64_t workspace_size = 0;
80	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
81	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
82	}
83
84	TEST_F(l2_atanh_test, atanh_nullptr) {
85	auto ut = OP_API_UT(aclnnAtanh, INPUT((aclTensor)nullptr), OUTPUT((aclTensor)nullptr));
86	uint64_t workspace_size = 0;
87	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
88	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
89	}
90
91	TEST_F(l2_atanh_test, atanh_out_nullptr) {
92	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
93	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(nullptr));
94	uint64_t workspaceSize = 0;
95	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
96	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
97	}
98
99	TEST_F(l2_atanh_test, atanh_precision) {
100	auto self_tensor_desc = TensorDesc({3, 6, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
101	auto out_tensor_desc = TensorDesc({3, 6, 9}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.0001, 0.0001);
102
103	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
104	uint64_t workspace_size = 0;
105	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
106	EXPECT_EQ(aclRet, ACL_SUCCESS);
107	}
108
109	TEST_F(l2_atanh_test, atanh_empty_tensor) {
110	auto self_tensor_desc = TensorDesc({13, 0, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
111	auto out_tensor_desc = TensorDesc({13, 0, 9}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
112
113	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
114	uint64_t workspace_size = 0;
115	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
116	EXPECT_EQ(aclRet, ACL_SUCCESS);
117	}
118
119	TEST_F(l2_atanh_test, atanh_non_contiguous) {
120	auto self_tensor_desc = TensorDesc({5, 3}, ACL_FLOAT, ACL_FORMAT_ND, {1, 5}, 0, {3, 5}).ValueRange(-1, 1);
121	auto out_tensor_desc = TensorDesc({5, 3}, ACL_FLOAT, ACL_FORMAT_ND, {1, 5}, 0, {3, 5}).Precision(0.001, 0.001);
122
123	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
124	uint64_t workspace_size = 0;
125	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
126	EXPECT_EQ(aclRet, ACL_SUCCESS);
127	}
128
129	TEST_F(l2_atanh_test, atanh_lessDim) {
130	auto self_tensor_desc = TensorDesc({2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
131	auto out_tensor_desc = TensorDesc({2}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
132
133	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
134	uint64_t workspace_size = 0;
135	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
136	EXPECT_EQ(aclRet, ACL_SUCCESS);
137	}
138
139	TEST_F(l2_atanh_test, atanh_bigDim) {
140	auto self_tensor_desc = TensorDesc({2, 2, 2, 2, 2, 2, 2, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
141	auto out_tensor_desc = TensorDesc({2, 2, 2, 2, 2, 2, 2, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
142
143	auto ut = OP_API_UT(aclnnAtanh, INPUT(self_tensor_desc), OUTPUT(out_tensor_desc));
144	uint64_t workspace_size = 0;
145	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
146	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
147	}
148
149	TEST_F(l2_atanh_test, atanh_inplace) {
150	auto self_tensor_desc = TensorDesc({3, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
151	auto ut = OP_API_UT(aclnnInplaceAtanh, INPUT(self_tensor_desc), OUTPUT());
152
153	uint64_t workspace_size = 0;
154	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
155	EXPECT_EQ(aclRet, ACL_SUCCESS);
156	}

Mmath/bitwise_not/CMakeLists.txt+3-10

	@@ -1,18 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11		10
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE bitwise_not ACLNNTYPE aclnn_exclude)
13	list(REMOVE_ITEM CURRENT_DIRS tests)
14	foreach(SUB_DIR ${CURRENT_DIRS})
15	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
16	add_subdirectory(${SUB_DIR})
17	endif()
18	endforeach()

Rmath/bitwise_not/op_host/op_api/aclnn_bitwise_not.cpp→math/bitwise_not/op_api/aclnn_bitwise_not.cpp+87-80

	@@ -58,112 +58,119 @@ static const std::initializer_list<op::DataType> DTYPE_SUPPORT_LIST = {op::DataT
58	op::DataType::DT_INT64, op::DataType::DT_INT8,	58	op::DataType::DT_INT64, op::DataType::DT_INT8,
59	op::DataType::DT_UINT8, op::DataType::DT_BOOL};	59	op::DataType::DT_UINT8, op::DataType::DT_BOOL};
60	static const std::initializer_list<op::DataType> DTYPE_SUPPORT_LIST_950 = {	60	static const std::initializer_list<op::DataType> DTYPE_SUPPORT_LIST_950 = {
61	op::DataType::DT_INT8, op::DataType::DT_INT16, op::DataType::DT_INT32, op::DataType::DT_INT64,	61	op::DataType::DT_INT8, op::DataType::DT_INT16, op::DataType::DT_INT32,
62	op::DataType::DT_UINT8, op::DataType::DT_UINT16, op::DataType::DT_UINT32, op::DataType::DT_UINT64,	62	op::DataType::DT_INT64, op::DataType::DT_UINT8, op::DataType::DT_UINT16,
63	op::DataType::DT_BOOL};	63	op::DataType::DT_UINT32, op::DataType::DT_UINT64, op::DataType::DT_BOOL};
64		64
65	static bool CheckNotNull(const aclTensor* self, const aclTensor* out) {	65	static bool CheckNotNull(const aclTensor* self, const aclTensor* out)
66	OP_CHECK_NULL(self, return false);	66	{
67	OP_CHECK_NULL(out, return false);	67	OP_CHECK_NULL(self, return false);
		68	OP_CHECK_NULL(out, return false);
68		69
69	return true;	70	return true;
70	}	71	}
71		72
72	static bool CheckDtypeValid(const aclTensor* self, const aclTensor* y) {	73	static bool CheckDtypeValid(const aclTensor* self, const aclTensor* y)
73	// 检查self的数据类型是否在bitwise_not算子的支持列表内	74	{
74	if (IsRegBase()) {	75	// 检查self的数据类型是否在bitwise_not算子的支持列表内
75	OP_CHECK_DTYPE_NOT_SUPPORT(self, DTYPE_SUPPORT_LIST_950, return false);	76	if (IsRegBase()) {
76	} else {	77	OP_CHECK_DTYPE_NOT_SUPPORT(self, DTYPE_SUPPORT_LIST_950, return false);
77	OP_CHECK_DTYPE_NOT_SUPPORT(self, DTYPE_SUPPORT_LIST, return false);	78	} else {
78	}	79	OP_CHECK_DTYPE_NOT_SUPPORT(self, DTYPE_SUPPORT_LIST, return false);
79		80	}
80	OP_CHECK_DTYPE_NOT_MATCH(self, y->GetDataType(), return false);
81		81
82	return true;	82	OP_CHECK_DTYPE_NOT_MATCH(self, y->GetDataType(), return false);
		83
		84	return true;
83	}	85	}
84		86
85	static bool CheckFormat(const aclTensor* self, const aclTensor* y) {	87	static bool CheckFormat(const aclTensor* self, const aclTensor* y)
86	// 如果输入格式是私有格式，记录日志，直接报错	88	{
87	if (op::IsPrivateFormat(self->GetStorageFormat()) \|\| op::IsPrivateFormat(y->GetStorageFormat())) {	89	// 如果输入格式是私有格式，记录日志，直接报错
88	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Format only support ND,NCHW,NHWC,HWCN,NDHWC,NCDHW.");	90	if (op::IsPrivateFormat(self->GetStorageFormat()) \|\| op::IsPrivateFormat(y->GetStorageFormat())) {
89	return false;	91	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Format only support ND,NCHW,NHWC,HWCN,NDHWC,NCDHW.");
90	}	92	return false;
91	return true;	93	}
		94	return true;
92	}	95	}
93		96
94	static bool CheckShape(const aclTensor* self, const aclTensor* y) {	97	static bool CheckShape(const aclTensor* self, const aclTensor* y)
95	OP_CHECK_MAX_DIM(self, MAX_SUPPORT_DIMS_NUMS, return false);	98	{
96	OP_CHECK_MAX_DIM(y, MAX_SUPPORT_DIMS_NUMS, return false);	99	OP_CHECK_MAX_DIM(self, MAX_SUPPORT_DIMS_NUMS, return false);
		100	OP_CHECK_MAX_DIM(y, MAX_SUPPORT_DIMS_NUMS, return false);
97		101
98	OP_CHECK_SHAPE_NOT_EQUAL(self, y, return false);	102	OP_CHECK_SHAPE_NOT_EQUAL(self, y, return false);
99		103
100	return true;	104	return true;
101	}	105	}
102		106
103	static aclnnStatus CheckParams(const aclTensor* self, const aclTensor* y) {	107	static aclnnStatus CheckParams(const aclTensor* self, const aclTensor* y)
104	// 1. 检查参数是否为空指针	108	{
105	CHECK_RET(CheckNotNull(self, y), ACLNN_ERR_INNER_NULLPTR);	109	// 1. 检查参数是否为空指针
		110	CHECK_RET(CheckNotNull(self, y), ACLNN_ERR_INNER_NULLPTR);
106		111
107	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验	112	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验
108	CHECK_RET(CheckDtypeValid(self, y), ACLNN_ERR_PARAM_INVALID);	113	CHECK_RET(CheckDtypeValid(self, y), ACLNN_ERR_PARAM_INVALID);
109		114
110	// 3. 检查数据格式是否支持	115	// 3. 检查数据格式是否支持
111	CHECK_RET(CheckFormat(self, y), ACLNN_ERR_PARAM_INVALID);	116	CHECK_RET(CheckFormat(self, y), ACLNN_ERR_PARAM_INVALID);
112		117
113	// 4. 检查双输入是否能broadcast	118	// 4. 检查双输入是否能broadcast
114	CHECK_RET(CheckShape(self, y), ACLNN_ERR_PARAM_INVALID);	119	CHECK_RET(CheckShape(self, y), ACLNN_ERR_PARAM_INVALID);
115		120
116	return ACLNN_SUCCESS;	121	return ACLNN_SUCCESS;
117	}	122	}
118		123
119	aclnnStatus aclnnBitwiseNotGetWorkspaceSize(const aclTensor* self, aclTensor* out, uint64_t* workspaceSize,	124	aclnnStatus aclnnBitwiseNotGetWorkspaceSize(const aclTensor* self, aclTensor* out, uint64_t* workspaceSize,
120	aclOpExecutor** executor) {	125	aclOpExecutor** executor)
121	L2_DFX_PHASE_1(aclnnBitwiseNot, DFX_IN(self), DFX_OUT(out));	126	{
122	// 固定写法，创建opExecutor	127	L2_DFX_PHASE_1(aclnnBitwiseNot, DFX_IN(self), DFX_OUT(out));
123	auto uniqueExecutor = CREATE_EXECUTOR();	128	// 固定写法，创建opExecutor
124	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);	129	auto uniqueExecutor = CREATE_EXECUTOR();
		130	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
125		131
126	// 固定写法，参数检查	132	// 固定写法，参数检查
127	auto ret = CheckParams(self, out);	133	auto ret = CheckParams(self, out);
128	CHECK_RET(ret == ACLNN_SUCCESS, ret);	134	CHECK_RET(ret == ACLNN_SUCCESS, ret);
129		135
130	// BitwiseNot算子的空tensor在kernel中支持，对标竞品根据算子实际情况补充	136	// BitwiseNot算子的空tensor在kernel中支持，对标竞品根据算子实际情况补充
131	if (self->IsEmpty()) {	137	if (self->IsEmpty()) {
132	// 根据实际支持情况补充	138	// 根据实际支持情况补充
133	*workspaceSize = 0;	139	*workspaceSize = 0;
134	uniqueExecutor.ReleaseTo(executor);	140	uniqueExecutor.ReleaseTo(executor);
		141	return ACLNN_SUCCESS;
		142	}
		143
		144	// 固定写法，将输入self转换成连续的tensor
		145	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
		146	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
		147
		148	// 进行BitwiseNot计算
		149	const aclTensor* notOpOut = nullptr;
		150	if (self->GetDataType() == op::DataType::DT_BOOL) {
		151	notOpOut = l0op::LogicalNot(selfContiguous, uniqueExecutor.get());
		152	} else {
		153	notOpOut = l0op::Invert(selfContiguous, uniqueExecutor.get());
		154	}
		155	CHECK_RET(notOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
		156
		157	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor
		158	auto viewCopyResult = l0op::ViewCopy(notOpOut, out, uniqueExecutor.get());
		159	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
		160
		161	// 固定写法，获取计算过程中需要使用的workspace大小
		162	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
		163	uniqueExecutor.ReleaseTo(executor); // 需要把uniqueExecutor持有executor转移给executor
135	return ACLNN_SUCCESS;	164	return ACLNN_SUCCESS;
136	}
137
138	// 固定写法，将输入self转换成连续的tensor
139	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
140	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
141
142	// 进行BitwiseNot计算
143	const aclTensor* notOpOut = nullptr;
144	if (self->GetDataType() == op::DataType::DT_BOOL) {
145	notOpOut = l0op::LogicalNot(selfContiguous, uniqueExecutor.get());
146	} else {
147	notOpOut = l0op::Invert(selfContiguous, uniqueExecutor.get());
148	}
149	CHECK_RET(notOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
150
151	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor
152	auto viewCopyResult = l0op::ViewCopy(notOpOut, out, uniqueExecutor.get());
153	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
154
155	// 固定写法，获取计算过程中需要使用的workspace大小
156	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
157	uniqueExecutor.ReleaseTo(executor); // 需要把uniqueExecutor持有executor转移给executor
158	return ACLNN_SUCCESS;
159	}	165	}
160		166
161	aclnnStatus aclnnBitwiseNot(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream) {	167	aclnnStatus aclnnBitwiseNot(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
162	L2_DFX_PHASE_2(aclnnBitwiseNot);	168	{
163	// 固定写法，调用框架能力，完成计算	169	L2_DFX_PHASE_2(aclnnBitwiseNot);
164	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	170	// 固定写法，调用框架能力，完成计算
		171	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
165	}	172	}
166		173
167	#ifdef __cplusplus	174	#ifdef __cplusplus
168	}	175	}
169	#endif	176	#endif

Rmath/bitwise_not/op_host/op_api/aclnn_bitwise_not.h→math/bitwise_not/op_api/aclnn_bitwise_not.h+1-1

	@@ -78,4 +78,4 @@ ACLNN_API aclnnStatus aclnnBitwiseNot(void* workspace, uint64_t workspaceSize, a
78	}	78	}
79	#endif	79	#endif
80		80
81	#endif // OP_API_INC_BITWISE_NOT_H_	81	#endif // OP_API_INC_BITWISE_NOT_H_

Dmath/bitwise_not/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources(OPTYPE bitwise_not ACLNNTYPE aclnn_exclude)

Dmath/bitwise_not/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Rmath/bitwise_not/tests/ut/op_host/op_api/test_aclnn_bitwise_not.cpp→math/bitwise_not/tests/ut/op_api/test_aclnn_bitwise_not.cpp+43-31

	@@ -12,21 +12,21 @@
12	#include <vector>	12	#include <vector>
13	#include "gtest/gtest.h"	13	#include "gtest/gtest.h"
14		14
15	#include "aclnn_bitwise_not.h"	15	#include "../../../op_api/aclnn_bitwise_not.h"
16		16
17	#include "op_api_ut_common/op_api_ut.h"	17	#include "op_api_ut_common/op_api_ut.h"
18	#include "op_api_ut_common/tensor_desc.h"	18	#include "op_api_ut_common/tensor_desc.h"
19		19
20
21	using namespace std;	20	using namespace std;
22		21
23	class l2_bitwise_not_test : public testing::Test {	22	class l2_bitwise_not_test : public testing::Test {
24	protected:	23	protected:
25	static void SetUpTestCase() { cout << "bitwise_not_test SetUp" << endl; }	24	static void SetUpTestCase() { cout << "bitwise_not_test SetUp" << endl; }
26	static void TearDownTestCase() { cout << "bitwise_not_test TearDown" << endl; }	25	static void TearDownTestCase() { cout << "bitwise_not_test TearDown" << endl; }
27	};	26	};
28		27
29	TEST_F(l2_bitwise_not_test, case_int16) {	28	TEST_F(l2_bitwise_not_test, case_int16)
		29	{
30	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_ND);	30	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_ND);
31	auto out_tensor_desc = TensorDesc(self_tensor_desc);	31	auto out_tensor_desc = TensorDesc(self_tensor_desc);
32		32
	@@ -38,10 +38,11 @@ TEST_F(l2_bitwise_not_test, case_int16) {
38	EXPECT_EQ(aclRet, ACL_SUCCESS);	38	EXPECT_EQ(aclRet, ACL_SUCCESS);
39		39
40	// SAMPLE: precision simulate	40	// SAMPLE: precision simulate
41	//ut.TestPrecision();	41	// ut.TestPrecision();
42	}	42	}
43		43
44	TEST_F(l2_bitwise_not_test, case_int32) {	44	TEST_F(l2_bitwise_not_test, case_int32)
		45	{
45	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_ND);	46	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_ND);
46	auto out_tensor_desc = TensorDesc(self_tensor_desc);	47	auto out_tensor_desc = TensorDesc(self_tensor_desc);
47		48
	@@ -53,10 +54,11 @@ TEST_F(l2_bitwise_not_test, case_int32) {
53	EXPECT_EQ(aclRet, ACL_SUCCESS);	54	EXPECT_EQ(aclRet, ACL_SUCCESS);
54		55
55	// SAMPLE: precision simulate	56	// SAMPLE: precision simulate
56	ut.TestPrecision();	57	// ut.TestPrecision();
57	}	58	}
58		59
59	TEST_F(l2_bitwise_not_test, case_int64) {	60	TEST_F(l2_bitwise_not_test, case_int64)
		61	{
60	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT64, ACL_FORMAT_ND);	62	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT64, ACL_FORMAT_ND);
61	auto out_tensor_desc = TensorDesc(self_tensor_desc);	63	auto out_tensor_desc = TensorDesc(self_tensor_desc);
62		64
	@@ -68,10 +70,11 @@ TEST_F(l2_bitwise_not_test, case_int64) {
68	EXPECT_EQ(aclRet, ACL_SUCCESS);	70	EXPECT_EQ(aclRet, ACL_SUCCESS);
69		71
70	// SAMPLE: precision simulate	72	// SAMPLE: precision simulate
71	ut.TestPrecision();	73	// ut.TestPrecision();
72	}	74	}
73		75
74	TEST_F(l2_bitwise_not_test, case_int8) {	76	TEST_F(l2_bitwise_not_test, case_int8)
		77	{
75	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT8, ACL_FORMAT_ND);	78	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT8, ACL_FORMAT_ND);
76	auto out_tensor_desc = TensorDesc(self_tensor_desc);	79	auto out_tensor_desc = TensorDesc(self_tensor_desc);
77		80
	@@ -83,10 +86,11 @@ TEST_F(l2_bitwise_not_test, case_int8) {
83	EXPECT_EQ(aclRet, ACL_SUCCESS);	86	EXPECT_EQ(aclRet, ACL_SUCCESS);
84		87
85	// SAMPLE: precision simulate	88	// SAMPLE: precision simulate
86	ut.TestPrecision();	89	// ut.TestPrecision();
87	}	90	}
88		91
89	TEST_F(l2_bitwise_not_test, case_uint8) {	92	TEST_F(l2_bitwise_not_test, case_uint8)
		93	{
90	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_UINT8, ACL_FORMAT_ND);	94	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_UINT8, ACL_FORMAT_ND);
91	auto out_tensor_desc = TensorDesc(self_tensor_desc);	95	auto out_tensor_desc = TensorDesc(self_tensor_desc);
92		96
	@@ -98,10 +102,11 @@ TEST_F(l2_bitwise_not_test, case_uint8) {
98	EXPECT_EQ(aclRet, ACL_SUCCESS);	102	EXPECT_EQ(aclRet, ACL_SUCCESS);
99		103
100	// SAMPLE: precision simulate	104	// SAMPLE: precision simulate
101	ut.TestPrecision();	105	// ut.TestPrecision();
102	}	106	}
103		107
104	TEST_F(l2_bitwise_not_test, case_bool) {	108	TEST_F(l2_bitwise_not_test, case_bool)
		109	{
105	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_BOOL, ACL_FORMAT_ND);	110	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_BOOL, ACL_FORMAT_ND);
106	auto out_tensor_desc = TensorDesc(self_tensor_desc);	111	auto out_tensor_desc = TensorDesc(self_tensor_desc);
107		112
	@@ -113,10 +118,11 @@ TEST_F(l2_bitwise_not_test, case_bool) {
113	EXPECT_EQ(aclRet, ACL_SUCCESS);	118	EXPECT_EQ(aclRet, ACL_SUCCESS);
114		119
115	// SAMPLE: precision simulate	120	// SAMPLE: precision simulate
116	//ut.TestPrecision();	121	// ut.TestPrecision();
117	}	122	}
118		123
119	TEST_F(l2_bitwise_not_test, case_support_format) {	124	TEST_F(l2_bitwise_not_test, case_support_format)
		125	{
120	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_NCHW);	126	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_NCHW);
121	auto out_tensor_desc = TensorDesc(self_tensor_desc);	127	auto out_tensor_desc = TensorDesc(self_tensor_desc);
122		128
	@@ -128,7 +134,7 @@ TEST_F(l2_bitwise_not_test, case_support_format) {
128	EXPECT_EQ(aclRet, ACL_SUCCESS);	134	EXPECT_EQ(aclRet, ACL_SUCCESS);
129		135
130	// SAMPLE: precision simulate	136	// SAMPLE: precision simulate
131	ut.TestPrecision();	137	// ut.TestPrecision();
132		138
133	self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_NHWC);	139	self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_NHWC);
134	out_tensor_desc = TensorDesc(self_tensor_desc);	140	out_tensor_desc = TensorDesc(self_tensor_desc);
	@@ -141,7 +147,7 @@ TEST_F(l2_bitwise_not_test, case_support_format) {
141	EXPECT_EQ(aclRet, ACL_SUCCESS);	147	EXPECT_EQ(aclRet, ACL_SUCCESS);
142		148
143	// SAMPLE: precision simulate	149	// SAMPLE: precision simulate
144	ut1.TestPrecision();	150	// ut1.TestPrecision();
145		151
146	self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_HWCN);	152	self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_HWCN);
147	out_tensor_desc = TensorDesc(self_tensor_desc);	153	out_tensor_desc = TensorDesc(self_tensor_desc);
	@@ -154,7 +160,7 @@ TEST_F(l2_bitwise_not_test, case_support_format) {
154	EXPECT_EQ(aclRet, ACL_SUCCESS);	160	EXPECT_EQ(aclRet, ACL_SUCCESS);
155		161
156	// SAMPLE: precision simulate	162	// SAMPLE: precision simulate
157	ut2.TestPrecision();	163	// ut2.TestPrecision();
158		164
159	self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_NDHWC);	165	self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_NDHWC);
160	out_tensor_desc = TensorDesc(self_tensor_desc);	166	out_tensor_desc = TensorDesc(self_tensor_desc);
	@@ -167,7 +173,7 @@ TEST_F(l2_bitwise_not_test, case_support_format) {
167	EXPECT_EQ(aclRet, ACL_SUCCESS);	173	EXPECT_EQ(aclRet, ACL_SUCCESS);
168		174
169	// SAMPLE: precision simulate	175	// SAMPLE: precision simulate
170	ut3.TestPrecision();	176	// ut3.TestPrecision();
171		177
172	self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_NCDHW);	178	self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_NCDHW);
173	out_tensor_desc = TensorDesc(self_tensor_desc);	179	out_tensor_desc = TensorDesc(self_tensor_desc);
	@@ -180,10 +186,11 @@ TEST_F(l2_bitwise_not_test, case_support_format) {
180	EXPECT_EQ(aclRet, ACL_SUCCESS);	186	EXPECT_EQ(aclRet, ACL_SUCCESS);
181		187
182	// SAMPLE: precision simulate	188	// SAMPLE: precision simulate
183	ut4.TestPrecision();	189	// ut4.TestPrecision();
184	}	190	}
185		191
186	TEST_F(l2_bitwise_not_test, case_nullptr) {	192	TEST_F(l2_bitwise_not_test, case_nullptr)
		193	{
187	auto tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_ND);	194	auto tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT16, ACL_FORMAT_ND);
188		195
189	auto ut = OP_API_UT(aclnnBitwiseNot, INPUT((aclTensor*)nullptr), OUTPUT(tensor_desc));	196	auto ut = OP_API_UT(aclnnBitwiseNot, INPUT((aclTensor*)nullptr), OUTPUT(tensor_desc));
	@@ -194,7 +201,8 @@ TEST_F(l2_bitwise_not_test, case_nullptr) {
194	EXPECT_EQ(aclRet, ACLNN_ERR_INNER_NULLPTR);	201	EXPECT_EQ(aclRet, ACLNN_ERR_INNER_NULLPTR);
195	}	202	}
196		203
197	TEST_F(l2_bitwise_not_test, case_empty) {	204	TEST_F(l2_bitwise_not_test, case_empty)
		205	{
198	auto self_tensor_desc = TensorDesc({7, 0, 6}, ACL_INT32, ACL_FORMAT_ND);	206	auto self_tensor_desc = TensorDesc({7, 0, 6}, ACL_INT32, ACL_FORMAT_ND);
199	auto out_tensor_desc = TensorDesc(self_tensor_desc);	207	auto out_tensor_desc = TensorDesc(self_tensor_desc);
200		208
	@@ -206,7 +214,8 @@ TEST_F(l2_bitwise_not_test, case_empty) {
206	EXPECT_EQ(aclRet, ACL_SUCCESS);	214	EXPECT_EQ(aclRet, ACL_SUCCESS);
207	}	215	}
208		216
209	TEST_F(l2_bitwise_not_test, case_errtype) {	217	TEST_F(l2_bitwise_not_test, case_errtype)
		218	{
210	auto self_tensor_desc = TensorDesc({7, 9, 11, 3, 4, 6, 9, 2, 2}, ACL_INT32, ACL_FORMAT_ND);	219	auto self_tensor_desc = TensorDesc({7, 9, 11, 3, 4, 6, 9, 2, 2}, ACL_INT32, ACL_FORMAT_ND);
211	auto out_tensor_desc = TensorDesc({7, 9, 11, 3, 4, 6, 9, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND);	220	auto out_tensor_desc = TensorDesc({7, 9, 11, 3, 4, 6, 9, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
212		221
	@@ -219,7 +228,8 @@ TEST_F(l2_bitwise_not_test, case_errtype) {
219	}	228	}
220		229
221	// CheckNotNull	230	// CheckNotNull
222	TEST_F(l2_bitwise_not_test, case_nullptr2) {	231	TEST_F(l2_bitwise_not_test, case_nullptr2)
		232	{
223	auto tensor_desc = TensorDesc({10, 5}, ACL_INT32, ACL_FORMAT_ND);	233	auto tensor_desc = TensorDesc({10, 5}, ACL_INT32, ACL_FORMAT_ND);
224		234
225	auto ut = OP_API_UT(aclnnBitwiseNot, INPUT(nullptr), OUTPUT(tensor_desc));	235	auto ut = OP_API_UT(aclnnBitwiseNot, INPUT(nullptr), OUTPUT(tensor_desc));
	@@ -236,7 +246,8 @@ TEST_F(l2_bitwise_not_test, case_nullptr2) {
236	}	246	}
237		247
238	// CheckDataVaild	248	// CheckDataVaild
239	TEST_F(l2_bitwise_not_test, case_dtype_unvaild) {	249	TEST_F(l2_bitwise_not_test, case_dtype_unvaild)
		250	{
240	// uint32	251	// uint32
241	auto tensor_desc = TensorDesc({10, 5}, ACL_UINT32, ACL_FORMAT_ND);	252	auto tensor_desc = TensorDesc({10, 5}, ACL_UINT32, ACL_FORMAT_ND);
242	auto ut = OP_API_UT(aclnnBitwiseNot, INPUT(tensor_desc), OUTPUT(tensor_desc));	253	auto ut = OP_API_UT(aclnnBitwiseNot, INPUT(tensor_desc), OUTPUT(tensor_desc));
	@@ -270,7 +281,8 @@ TEST_F(l2_bitwise_not_test, case_dtype_unvaild) {
270	}	281	}
271		282
272	// CheckShape	283	// CheckShape
273	TEST_F(l2_bitwise_not_test, case_shape) {	284	TEST_F(l2_bitwise_not_test, case_shape)
		285	{
274	auto self_tensor_desc = TensorDesc({10, 5, 2, 10}, ACL_INT32, ACL_FORMAT_ND);	286	auto self_tensor_desc = TensorDesc({10, 5, 2, 10}, ACL_INT32, ACL_FORMAT_ND);
275	auto out_tensor_desc = TensorDesc({10, 5, 5, 10}, ACL_INT32, ACL_FORMAT_ND);	287	auto out_tensor_desc = TensorDesc({10, 5, 5, 10}, ACL_INT32, ACL_FORMAT_ND);
276		288
	@@ -282,7 +294,8 @@ TEST_F(l2_bitwise_not_test, case_shape) {
282	}	294	}
283		295
284	// CheckFormat	296	// CheckFormat
285	TEST_F(l2_bitwise_not_test, case_format) {	297	TEST_F(l2_bitwise_not_test, case_format)
		298	{
286	auto self_tensor_desc = TensorDesc({10, 5, 2, 10}, ACL_INT32, ACL_FORMAT_NC1HWC0);	299	auto self_tensor_desc = TensorDesc({10, 5, 2, 10}, ACL_INT32, ACL_FORMAT_NC1HWC0);
287	auto out_tensor_desc = TensorDesc({10, 5, 2, 10}, ACL_INT32, ACL_FORMAT_NCHW);	300	auto out_tensor_desc = TensorDesc({10, 5, 2, 10}, ACL_INT32, ACL_FORMAT_NCHW);
288		301
	@@ -294,7 +307,8 @@ TEST_F(l2_bitwise_not_test, case_format) {
294	}	307	}
295		308
296	// uncontiguous	309	// uncontiguous
297	TEST_F(l2_bitwise_not_test, case_uncontiguous) {	310	TEST_F(l2_bitwise_not_test, case_uncontiguous)
		311	{
298	auto self_tensor_desc = TensorDesc({5, 4}, ACL_INT32, ACL_FORMAT_ND, {1, 5}, 0, {4, 5});	312	auto self_tensor_desc = TensorDesc({5, 4}, ACL_INT32, ACL_FORMAT_ND, {1, 5}, 0, {4, 5});
299	auto out_tensor_desc = TensorDesc({5, 4}, ACL_INT32, ACL_FORMAT_ND);	313	auto out_tensor_desc = TensorDesc({5, 4}, ACL_INT32, ACL_FORMAT_ND);
300		314
	@@ -304,5 +318,3 @@ TEST_F(l2_bitwise_not_test, case_uncontiguous) {
304	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	318	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
305	EXPECT_EQ(aclRet, ACL_SUCCESS);	319	EXPECT_EQ(aclRet, ACL_SUCCESS);
306	}	320	}
307
308

Dmath/bitwise_not/tests/ut/op_host/CMakeLists.txt+0-20

	@@ -1,20 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()
18
19	if(OP_API_UT OR (UT_TEST_ALL AND NOT AICPU_ONLY))
20	endif()

Dmath/bitwise_not/tests/ut/op_host/op_api/CMakeLists.txt+0-11

	@@ -1,11 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11

Mmath/cholesky/CMakeLists.txt+5-13

	@@ -1,19 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
		7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
10		10
11	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE cholesky ACLNNTYPE aclnn_exclude)
12	if(NOT ENABLE_TEST)
13	list(REMOVE_ITEM CURRENT_DIRS tests)
14	endif()
15	foreach(SUB_DIR ${CURRENT_DIRS})
16	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
17	add_subdirectory(${SUB_DIR})
18	endif()
19	endforeach()

Amath/cholesky/op_api/aclnn_linalg_cholesky.cpp+190-0

@@ -0,0 +1,190 @@
	1	/**
	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10
	11	#include "aclnn_linalg_cholesky.h"
	12	#include "cholesky.h"
	13	#include "aclnn_kernels/contiguous.h"
	14	#include "aclnn_kernels/cast.h"
	15	#include "aclnn_kernels/transpose.h"
	16	#include "aclnn_kernels/common/op_error_check.h"
	17	#include "opdev/op_log.h"
	18	#include "opdev/make_op_executor.h"
	19	#include "opdev/op_executor.h"
	20	#include "opdev/platform.h"
	21	#include "opdev/op_dfx.h"
	22	#include "opdev/tensor_view_utils.h"
	23
	24	using namespace op;
	25	#ifdef __cplusplus
	26	extern "C" {
	27	#endif
	28
	29	const int64_t SECOND_LAST_DIM_OFFSET = 2;
	30	const int64_t LAST_DIM_OFFSET = 1;
	31	const int64_t MAX_LAST_DIM_SIZE = 8192;
	32
	33	static const std::initializer_list<op::DataType> ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST = {
	34	op::DataType::DT_FLOAT, op::DataType::DT_BF16, op::DataType::DT_FLOAT16};
	35
	36	static const std::initializer_list<op::DataType> NULL_SUPPORT_LIST = {};
	37
	38	static const std::initializer_list<op::DataType>& GetDtypeSupportList()
	39	{
	40	if (op::GetCurrentPlatformInfo().GetCurNpuArch() == NpuArch::DAV_2201 \|\|
	41	op::GetCurrentPlatformInfo().GetCurNpuArch() == NpuArch::DAV_3510) {
	42	return ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST;
	43	} else {
	44	return NULL_SUPPORT_LIST;
	45	}
	46	}
	47
	48	static bool CheckNotNull(const aclTensor* self, aclTensor* out)
	49	{
	50	OP_CHECK_NULL(self, return false);
	51	OP_CHECK_NULL(out, return false);
	52	return true;
	53	}
	54
	55	static bool CheckDtypeValid(const aclTensor* self, const aclTensor* out)
	56	{
	57	auto supportList = GetDtypeSupportList();
	58
	59	// 检查self与out的数据类型是否一致
	60	OP_CHECK_DTYPE_NOT_MATCH(out, self->GetDataType(), return false);
	61	// 检查self的数据类型是否支持，out和self数据类型一致，不需要额外检查
	62	OP_CHECK_DTYPE_NOT_SUPPORT(self, supportList, return false);
	63
	64	return true;
	65	}
	66
	67	static bool CheckFormat(const aclTensor* self, const aclTensor* out)
	68	{
	69	// 输入输出的格式需要一致
	70	if (self->GetStorageFormat() != out->GetStorageFormat()) {
	71	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Format of input and output should be equal. self [%s], out [%s].",
	72	ToString(self->GetStorageShape()).GetString(), ToString(out->GetStorageShape()).GetString());
	73	return false;
	74	}
	75
	76	// self格式不能是私有格式
	77	if (IsPrivateFormat(self->GetStorageFormat())) {
	78	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Format only support ND.");
	79	return false;
	80	}
	81
	82	return true;
	83	}
	84
	85	static bool CheckShape(const aclTensor* self, const aclTensor* out)
	86	{
	87	// 维度不能超过8
	88	OP_CHECK_MAX_DIM(self, ACLNN_MAX_SHAPE_RANK, return false);
	89
	90	// 维度最少为2维
	91	OP_CHECK_MIN_DIM(self, 2, return false);
	92
	93	// self和out的shape必须一致
	94	OP_CHECK_SHAPE_NOT_EQUAL(self, out, return false);
	95
	96	return true;
	97	}
	98
	99	static aclnnStatus CheckParams(const aclTensor* self, aclTensor* out)
	100	{
	101	// 1. 检查参数是否为空指针
	102	CHECK_RET(CheckNotNull(self, out), ACLNN_ERR_PARAM_NULLPTR);
	103
	104	// 2. 检查输入的数据类型是否在API支持的数据类型范围内
	105	CHECK_RET(CheckDtypeValid(self, out), ACLNN_ERR_PARAM_INVALID);
	106
	107	// 3. 检查数据格式是否支持
	108	CHECK_RET(CheckFormat(self, out), ACLNN_ERR_PARAM_INVALID);
	109
	110	// 4. 检查shape是否满足约束
	111	CHECK_RET(CheckShape(self, out), ACLNN_ERR_PARAM_INVALID);
	112
	113	return ACLNN_SUCCESS;
	114	}
	115
	116	aclnnStatus aclnnLinalgCholeskyGetWorkspaceSize(const aclTensor* self, bool upper, aclTensor* out,
	117	uint64_t* workspaceSize, aclOpExecutor** executor)
	118	{
	119	L2_DFX_PHASE_1(aclnnLinalgCholesky, DFX_IN(self, upper), DFX_OUT(out));
	120
	121	// 固定写法，创建OpExecutor
	122	auto uniqueExecutor = CREATE_EXECUTOR();
	123	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
	124
	125	// 固定写法，参数检查
	126	auto ret = CheckParams(self, out);
	127	CHECK_RET(ret == ACLNN_SUCCESS, ret);
	128
	129	if (self->IsEmpty()) {
	130	// 根据实际支持情况补充
	131	*workspaceSize = 0;
	132	uniqueExecutor.ReleaseTo(executor);
	133	return ACLNN_SUCCESS;
	134	}
	135
	136	// self最后两维必须为相同
	137	auto dims = static_cast<int64_t>(self->GetViewShape().GetDimNum());
	138	int64_t last_dim_size = self->GetViewShape().GetDim(dims - 1);
	139	int64_t second_last_dim_size = self->GetViewShape().GetDim(dims - 2);
	140	if (last_dim_size != second_last_dim_size) {
	141	OP_LOGE(ACLNN_ERR_PARAM_INVALID,
	142	"self must be batches of square matrices, but they are [%ld] by [%ld] matrices", second_last_dim_size,
	143	last_dim_size);
	144	return ACLNN_ERR_PARAM_INVALID;
	145	}
	146	// 尾轴超过8192可能会超时报错，提前拦截
	147	if (last_dim_size > MAX_LAST_DIM_SIZE) {
	148	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The last dim must be less than or equal to 8192.");
	149	return ACLNN_ERR_PARAM_INVALID;
	150	}
	151
	152	// self如果非连续，需要转换
	153	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
	154	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
	155
	156	// 输入类型是bf16时，需要转换成fp32
	157	if (self->GetDataType() == op::DataType::DT_BF16 \|\| self->GetDataType() == op::DataType::DT_FLOAT16) {
	158	selfContiguous = l0op::Cast(selfContiguous, op::DataType::DT_FLOAT, uniqueExecutor.get());
	159	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
	160	}
	161
	162	// 调用l0算子Cholesky进行计算
	163	auto choleskyResult = l0op::Cholesky(selfContiguous, upper, uniqueExecutor.get());
	164	CHECK_RET(choleskyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
	165
	166	// 固定写法，将计算结果转换成输出out的数据类型
	167	choleskyResult = l0op::Cast(choleskyResult, out->GetDataType(), uniqueExecutor.get());
	168	CHECK_RET(choleskyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
	169
	170	// 将结果拷贝到out
	171	auto viewCopyResult = l0op::ViewCopy(choleskyResult, out, uniqueExecutor.get());
	172	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
	173
	174	// 固定写法，获取计算过程中需要使用的workspace大小
	175	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
	176	uniqueExecutor.ReleaseTo(executor);
	177	return ACLNN_SUCCESS;
	178	}
	179
	180	aclnnStatus aclnnLinalgCholesky(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor,
	181	const aclrtStream stream)
	182	{
	183	L2_DFX_PHASE_2(aclnnLinalgCholesky);
	184	// 固定写法，调用框架能力，完成计算
	185	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
	186	}
	187
	188	#ifdef __cplusplus
	189	}
	190	#endif

Rmath/cholesky/op_host/op_api/aclnn_linalg_cholesky.h→math/cholesky/op_api/aclnn_linalg_cholesky.h+6-5

	@@ -7,7 +7,7 @@
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/	9	*/
10		10
11	#ifndef OP_API_INC_LINALG_CHOLESKY_H_	11	#ifndef OP_API_INC_LINALG_CHOLESKY_H_
12	#define OP_API_INC_LINALG_CHOLESKY_H_	12	#define OP_API_INC_LINALG_CHOLESKY_H_
13		13
	@@ -50,8 +50,8 @@ extern "C" {
50	* @param [out] executor: 返回op执行器，包含算子计算流程。	50	* @param [out] executor: 返回op执行器，包含算子计算流程。
51	* @return aclnnStatus: 返回状态码。	51	* @return aclnnStatus: 返回状态码。
52	*/	52	*/
53	ACLNN_API aclnnStatus aclnnLinalgCholeskyGetWorkspaceSize(const aclTensor* self, bool upper, aclTensor* out, uint64_t* workspaceSize,	53	ACLNN_API aclnnStatus aclnnLinalgCholeskyGetWorkspaceSize(const aclTensor* self, bool upper, aclTensor* out,
54	aclOpExecutor** executor);	54	uint64_t* workspaceSize, aclOpExecutor** executor);
55		55
56	/**	56	/**
57	* @brief aclnnLinalgCholesky的第二段接口，用于执行计算。	57	* @brief aclnnLinalgCholesky的第二段接口，用于执行计算。
	@@ -62,10 +62,11 @@ ACLNN_API aclnnStatus aclnnLinalgCholeskyGetWorkspaceSize(const aclTensor* self,
62	* @param [in] executor: op执行器，包含了算子计算流程。	62	* @param [in] executor: op执行器，包含了算子计算流程。
63	* @return aclnnStatus: 返回状态码。	63	* @return aclnnStatus: 返回状态码。
64	*/	64	*/
65	ACLNN_API aclnnStatus aclnnLinalgCholesky(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream);	65	ACLNN_API aclnnStatus aclnnLinalgCholesky(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor,
		66	const aclrtStream stream);
66		67
67	#ifdef __cplusplus	68	#ifdef __cplusplus
68	}	69	}
69	#endif	70	#endif
70		71
71	#endif // OP_API_INC_LINALG_CHOLESKY_H_	72	#endif // OP_API_INC_LINALG_CHOLESKY_H_

Rmath/cholesky/op_host/op_api/cholesky.cpp→math/cholesky/op_api/cholesky.cpp+14-11

	@@ -7,7 +7,7 @@
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/	9	*/
10		10
11	#include "cholesky.h"	11	#include "cholesky.h"
12	#include "opdev/op_log.h"	12	#include "opdev/op_log.h"
13	#include "opdev/make_op_executor.h"	13	#include "opdev/make_op_executor.h"
	@@ -22,17 +22,20 @@ namespace l0op {
22	OP_TYPE_REGISTER(Cholesky);	22	OP_TYPE_REGISTER(Cholesky);
23		23
24	// AICORE算子kernel	24	// AICORE算子kernel
25	static const aclTensor CholeskyAiCore(const aclTensor self, bool upper, aclTensor out, aclOpExecutor executor) {	25	static const aclTensor* CholeskyAiCore(const aclTensor* self, bool upper, aclTensor* out, aclOpExecutor* executor)
26	L0_DFX(CholeskyAiCore, self, upper, out);	26	{
27	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(Cholesky, OP_INPUT(self), OP_OUTPUT(out), OP_ATTR(upper));	27	L0_DFX(CholeskyAiCore, self, upper, out);
28	OP_CHECK(ret == ACLNN_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "CholeskyAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."), return nullptr);	28	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(Cholesky, OP_INPUT(self), OP_OUTPUT(out), OP_ATTR(upper));
29	return out;	29	OP_CHECK(ret == ACLNN_SUCCESS,
		30	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "CholeskyAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."), return nullptr);
		31	return out;
30	}	32	}
31		33
32	const aclTensor Cholesky(const aclTensor self, bool upper, aclOpExecutor *executor) {	34	const aclTensor* Cholesky(const aclTensor* self, bool upper, aclOpExecutor* executor)
33	auto out = executor->AllocTensor(self->GetViewShape(), self->GetDataType());	35	{
34	CHECK_RET(out != nullptr, nullptr);	36	auto out = executor->AllocTensor(self->GetViewShape(), self->GetDataType());
35	return CholeskyAiCore(self, upper, out, executor);	37	CHECK_RET(out != nullptr, nullptr);
		38	return CholeskyAiCore(self, upper, out, executor);
36	}	39	}
37		40
38	} // namespace l0op	41	} // namespace l0op

Rmath/cholesky/op_host/op_api/cholesky.h→math/cholesky/op_api/cholesky.h+3-3

	@@ -7,15 +7,15 @@
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/	9	*/
10		10
11	#ifndef PTA_NPU_OP_API_INC_LEVEL0_OP_CHOLESKY_OP_H_	11	#ifndef PTA_NPU_OP_API_INC_LEVEL0_OP_CHOLESKY_OP_H_
12	#define PTA_NPU_OP_API_INC_LEVEL0_OP_CHOLESKY_OP_H_	12	#define PTA_NPU_OP_API_INC_LEVEL0_OP_CHOLESKY_OP_H_
13		13
14	#include "opdev/op_executor.h"	14	#include "opdev/op_executor.h"
15		15
16	namespace l0op {	16	namespace l0op {
17	const aclTensor Cholesky(const aclTensor self, bool upper, aclOpExecutor *executor);	17	const aclTensor* Cholesky(const aclTensor* self, bool upper, aclOpExecutor* executor);
18		18
19	}	19	}
20		20
21	#endif // PTA_NPU_OP_API_INC_LEVEL0_OP_CHOLESKY_OP_H_	21	#endif // PTA_NPU_OP_API_INC_LEVEL0_OP_CHOLESKY_OP_H_

Dmath/cholesky/op_host/CMakeLists.txt+0-11

	@@ -1,11 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------
10
11	add_modules_sources(HOSTNAME ${OPHOST_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR} OPTYPE cholesky ACLNNTYPE aclnn_exclude)

Dmath/cholesky/op_host/op_api/aclnn_linalg_cholesky.cpp+0-179

	@@ -1,179 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10
11	#include "aclnn_linalg_cholesky.h"
12	#include "cholesky.h"
13	#include "aclnn_kernels/contiguous.h"
14	#include "aclnn_kernels/cast.h"
15	#include "aclnn_kernels/transpose.h"
16	#include "aclnn_kernels/common/op_error_check.h"
17	#include "opdev/op_log.h"
18	#include "opdev/make_op_executor.h"
19	#include "opdev/op_executor.h"
20	#include "opdev/platform.h"
21	#include "opdev/op_dfx.h"
22	#include "opdev/tensor_view_utils.h"
23
24	using namespace op;
25	#ifdef __cplusplus
26	extern "C" {
27	#endif
28
29	const int64_t SECOND_LAST_DIM_OFFSET = 2;
30	const int64_t LAST_DIM_OFFSET = 1;
31	const int64_t MAX_LAST_DIM_SIZE = 8192;
32
33	static const std::initializer_list<op::DataType> ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST = {
34	op::DataType::DT_FLOAT, op::DataType::DT_BF16, op::DataType::DT_FLOAT16};
35
36	static const std::initializer_list<op::DataType> NULL_SUPPORT_LIST = {};
37
38	static const std::initializer_list<op::DataType>& GetDtypeSupportList() {
39	if (op::GetCurrentPlatformInfo().GetCurNpuArch() == NpuArch::DAV_2201 \|\|
40	op::GetCurrentPlatformInfo().GetCurNpuArch() == NpuArch::DAV_3510) {
41	return ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST;
42	} else {
43	return NULL_SUPPORT_LIST;
44	}
45	}
46
47	static bool CheckNotNull(const aclTensor* self, aclTensor* out) {
48	OP_CHECK_NULL(self, return false);
49	OP_CHECK_NULL(out, return false);
50	return true;
51	}
52
53	static bool CheckDtypeValid(const aclTensor self, const aclTensor out) {
54	auto supportList = GetDtypeSupportList();
55
56	//检查self与out的数据类型是否一致
57	OP_CHECK_DTYPE_NOT_MATCH(out, self->GetDataType(), return false);
58	// 检查self的数据类型是否支持，out和self数据类型一致，不需要额外检查
59	OP_CHECK_DTYPE_NOT_SUPPORT(self, supportList, return false);
60
61	return true;
62	}
63
64	static bool CheckFormat(const aclTensor self, const aclTensor out) {
65	// 输入输出的格式需要一致
66	if (self->GetStorageFormat() != out->GetStorageFormat()) {
67	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Format of input and output should be equal. self [%s], out [%s].",
68	ToString(self->GetStorageShape()).GetString(), ToString(out->GetStorageShape()).GetString());
69	return false;
70	}
71
72	// self格式不能是私有格式
73	if (IsPrivateFormat(self->GetStorageFormat())) {
74	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Format only support ND.");
75	return false;
76	}
77
78	return true;
79	}
80
81	static bool CheckShape(const aclTensor self, const aclTensor out) {
82	// 维度不能超过8
83	OP_CHECK_MAX_DIM(self, ACLNN_MAX_SHAPE_RANK, return false);
84
85	// 维度最少为2维
86	OP_CHECK_MIN_DIM(self, 2, return false);
87
88	// self和out的shape必须一致
89	OP_CHECK_SHAPE_NOT_EQUAL(self, out, return false);
90
91	return true;
92	}
93
94	static aclnnStatus CheckParams(const aclTensor self, aclTensor out) {
95	// 1. 检查参数是否为空指针
96	CHECK_RET(CheckNotNull(self, out), ACLNN_ERR_PARAM_NULLPTR);
97
98	// 2. 检查输入的数据类型是否在API支持的数据类型范围内
99	CHECK_RET(CheckDtypeValid(self, out), ACLNN_ERR_PARAM_INVALID);
100
101	// 3. 检查数据格式是否支持
102	CHECK_RET(CheckFormat(self, out), ACLNN_ERR_PARAM_INVALID);
103
104	// 4. 检查shape是否满足约束
105	CHECK_RET(CheckShape(self, out), ACLNN_ERR_PARAM_INVALID);
106
107	return ACLNN_SUCCESS;
108	}
109
110	aclnnStatus aclnnLinalgCholeskyGetWorkspaceSize(const aclTensor self, bool upper, aclTensor out,
111	uint64_t workspaceSize, aclOpExecutor *executor) {
112	L2_DFX_PHASE_1(aclnnLinalgCholesky, DFX_IN(self, upper), DFX_OUT(out));
113
114	// 固定写法，创建OpExecutor
115	auto uniqueExecutor = CREATE_EXECUTOR();
116	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
117
118	// 固定写法，参数检查
119	auto ret = CheckParams(self, out);
120	CHECK_RET(ret == ACLNN_SUCCESS, ret);
121
122	if (self->IsEmpty()) {
123	// 根据实际支持情况补充
124	*workspaceSize = 0;
125	uniqueExecutor.ReleaseTo(executor);
126	return ACLNN_SUCCESS;
127	}
128
129	// self最后两维必须为相同
130	auto dims = static_cast<int64_t>(self->GetViewShape().GetDimNum());
131	int64_t last_dim_size = self->GetViewShape().GetDim(dims -1);
132	int64_t second_last_dim_size = self->GetViewShape().GetDim(dims -2);
133	if (last_dim_size != second_last_dim_size) {
134	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "self must be batches of square matrices, but they are [%ld] by [%ld] matrices", second_last_dim_size, last_dim_size);
135	return ACLNN_ERR_PARAM_INVALID;
136	}
137	// 尾轴超过8192可能会超时报错，提前拦截
138	if (last_dim_size > MAX_LAST_DIM_SIZE) {
139	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The last dim must be less than or equal to 8192.");
140	return ACLNN_ERR_PARAM_INVALID;
141	}
142
143	// self如果非连续，需要转换
144	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
145	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
146
147	// 输入类型是bf16时，需要转换成fp32
148	if (self->GetDataType() == op::DataType::DT_BF16 \|\| self->GetDataType() == op::DataType::DT_FLOAT16) {
149	selfContiguous = l0op::Cast(selfContiguous, op::DataType::DT_FLOAT, uniqueExecutor.get());
150	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
151	}
152
153	// 调用l0算子Cholesky进行计算
154	auto choleskyResult = l0op::Cholesky(selfContiguous, upper, uniqueExecutor.get());
155	CHECK_RET(choleskyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
156
157	// 固定写法，将计算结果转换成输出out的数据类型
158	choleskyResult = l0op::Cast(choleskyResult, out->GetDataType(), uniqueExecutor.get());
159	CHECK_RET(choleskyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
160
161	// 将结果拷贝到out
162	auto viewCopyResult = l0op::ViewCopy(choleskyResult, out, uniqueExecutor.get());
163	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
164
165	// 固定写法，获取计算过程中需要使用的workspace大小
166	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
167	uniqueExecutor.ReleaseTo(executor);
168	return ACLNN_SUCCESS;
169	}
170
171	aclnnStatus aclnnLinalgCholesky(void workspace, uint64_t workspaceSize, aclOpExecutor executor, const aclrtStream stream) {
172	L2_DFX_PHASE_2(aclnnLinalgCholesky);
173	// 固定写法，调用框架能力，完成计算
174	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
175	}
176
177	#ifdef __cplusplus
178	}
179	#endif

Dmath/cholesky/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/cholesky/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/cholesky/tests/ut/op_api/CMakeLists.txt+0-14

	@@ -1,14 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. See LICENSE in the root of
9	# the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	if(UT_TEST_ALL OR OP_API_UT)
13	add_modules_ut_sources(UT_NAME ${OP_API_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
14	endif()

Mmath/cholesky/tests/ut/op_api/test_aclnn_linalg_cholesky.cpp+19-14

	@@ -1,17 +1,17 @@
1	/**	1	/**
2	* This program is free software, you can redistribute it and/or modify.
3	* Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	* This file is a part of the CANN Open Software.	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	* Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	* CANN Open Software License Agreement Version 2.0 (the "License").
6	* Please refer to the License for details. You may not use this file except in compliance with the License.	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
7	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
		7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/	9	*/
10	#include <array>	10	#include <array>
11	#include <vector>	11	#include <vector>
12	#include "gtest/gtest.h"	12	#include "gtest/gtest.h"
13		13
14	#include "../../../op_host/op_api/aclnn_linalg_cholesky.h"	14	#include "../../../op_api/aclnn_linalg_cholesky.h"
15	#include "op_api_ut_common/op_api_ut.h"	15	#include "op_api_ut_common/op_api_ut.h"
16	#include "op_api_ut_common/scalar_desc.h"	16	#include "op_api_ut_common/scalar_desc.h"
17	#include "op_api_ut_common/tensor_desc.h"	17	#include "op_api_ut_common/tensor_desc.h"
	@@ -21,14 +21,15 @@ using namespace op;
21	using namespace std;	21	using namespace std;
22		22
23	class l2_linalg_cholesky_test : public testing::Test {	23	class l2_linalg_cholesky_test : public testing::Test {
24	protected:	24	protected:
25	static void SetUpTestCase() { std::cout << "aclnnLinalgCholesky_test SetUp" << std::endl; }	25	static void SetUpTestCase() { std::cout << "aclnnLinalgCholesky_test SetUp" << std::endl; }
26		26
27	static void TearDownTestCase() { std::cout << "aclnnLinalgCholesky_test TearDown" << std::endl; }	27	static void TearDownTestCase() { std::cout << "aclnnLinalgCholesky_test TearDown" << std::endl; }
28	};	28	};
29		29
30	// checkNotNull	30	// checkNotNull
31	TEST_F(l2_linalg_cholesky_test, ascend910B_case_1) {	31	TEST_F(l2_linalg_cholesky_test, ascend910B_case_1)
		32	{
32	auto out_desc = TensorDesc({3, 3}, ACL_FLOAT, ACL_FORMAT_ND);	33	auto out_desc = TensorDesc({3, 3}, ACL_FLOAT, ACL_FORMAT_ND);
33	auto ut = OP_API_UT(aclnnLinalgCholesky, INPUT((aclTensor*)nullptr, true), OUTPUT(out_desc));	34	auto ut = OP_API_UT(aclnnLinalgCholesky, INPUT((aclTensor*)nullptr, true), OUTPUT(out_desc));
34	uint64_t workspace_size = 0;	35	uint64_t workspace_size = 0;
	@@ -37,7 +38,8 @@ TEST_F(l2_linalg_cholesky_test, ascend910B_case_1) {
37	}	38	}
38		39
39	// CheckDtypeValid	40	// CheckDtypeValid
40	TEST_F(l2_linalg_cholesky_test, ascend910B_case_2) {	41	TEST_F(l2_linalg_cholesky_test, ascend910B_case_2)
		42	{
41	auto self_desc = TensorDesc({3, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);	43	auto self_desc = TensorDesc({3, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);
42	auto out_desc = TensorDesc({3, 3}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-10, 10);	44	auto out_desc = TensorDesc({3, 3}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-10, 10);
43	auto ut = OP_API_UT(aclnnLinalgCholesky, INPUT(self_desc, true), OUTPUT(out_desc));	45	auto ut = OP_API_UT(aclnnLinalgCholesky, INPUT(self_desc, true), OUTPUT(out_desc));
	@@ -47,7 +49,8 @@ TEST_F(l2_linalg_cholesky_test, ascend910B_case_2) {
47	}	49	}
48		50
49	// CheckShape	51	// CheckShape
50	TEST_F(l2_linalg_cholesky_test, ascend910B_case_3) {	52	TEST_F(l2_linalg_cholesky_test, ascend910B_case_3)
		53	{
51	auto self_desc = TensorDesc({1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);	54	auto self_desc = TensorDesc({1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);
52	auto out_desc = TensorDesc({1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);	55	auto out_desc = TensorDesc({1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);
53	auto ut = OP_API_UT(aclnnLinalgCholesky, INPUT(self_desc, true), OUTPUT(out_desc));	56	auto ut = OP_API_UT(aclnnLinalgCholesky, INPUT(self_desc, true), OUTPUT(out_desc));
	@@ -57,7 +60,8 @@ TEST_F(l2_linalg_cholesky_test, ascend910B_case_3) {
57	}	60	}
58		61
59	// CheckShape	62	// CheckShape
60	TEST_F(l2_linalg_cholesky_test, ascend910B_case_4) {	63	TEST_F(l2_linalg_cholesky_test, ascend910B_case_4)
		64	{
61	auto self_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);	65	auto self_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);
62	auto out_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);	66	auto out_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);
63	auto ut = OP_API_UT(aclnnLinalgCholesky, INPUT(self_desc, false), OUTPUT(out_desc));	67	auto ut = OP_API_UT(aclnnLinalgCholesky, INPUT(self_desc, false), OUTPUT(out_desc));
	@@ -67,11 +71,12 @@ TEST_F(l2_linalg_cholesky_test, ascend910B_case_4) {
67	}	71	}
68		72
69	// 正常路径	73	// 正常路径
70	TEST_F(l2_linalg_cholesky_test, ascend910B_case_5) {	74	TEST_F(l2_linalg_cholesky_test, ascend910B_case_5)
		75	{
71	auto self_desc = TensorDesc({3, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);	76	auto self_desc = TensorDesc({3, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);
72	auto out_desc = TensorDesc({3, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);	77	auto out_desc = TensorDesc({3, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-10, 10);
73	auto ut = OP_API_UT(aclnnLinalgCholesky, INPUT(self_desc, true), OUTPUT(out_desc));	78	auto ut = OP_API_UT(aclnnLinalgCholesky, INPUT(self_desc, true), OUTPUT(out_desc));
74	uint64_t workspace_size = 0;	79	uint64_t workspace_size = 0;
75	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	80	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
76	EXPECT_EQ(aclRet, ACLNN_SUCCESS);	81	EXPECT_EQ(aclRet, ACLNN_SUCCESS);
77	}	82	}

Dmath/cholesky/tests/ut/op_host/CMakeLists.txt+0-22

	@@ -1,22 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	if(UT_TEST_ALL OR OP_HOST_UT)
13	add_modules_ut_sources(UT_NAME ${OP_TILING_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
14	add_modules_ut_sources(UT_NAME ${OP_INFERSHAPE_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
15	endif()
16
17	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
18	foreach(SUB_DIR ${CURRENT_DIRS})
19	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
20	add_subdirectory(${SUB_DIR})
21	endif()
22	endforeach()

Dmath/complex/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/complex/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Rmath/complex/tests/ut/op_host/op_api/test_aclnn_complex.cpp→math/complex/tests/ut/op_api/test_aclnn_complex.cpp+45-43

	@@ -11,7 +11,7 @@
11	#include <vector>	11	#include <vector>
12	#include <array>	12	#include <array>
13	#include "gtest/gtest.h"	13	#include "gtest/gtest.h"
14	#include "../../../../op_host/op_api/aclnn_complex.h"	14	#include "../../../op_api/aclnn_complex.h"
15	#include "op_api_ut_common/tensor_desc.h"	15	#include "op_api_ut_common/tensor_desc.h"
16	#include "op_api_ut_common/scalar_desc.h"	16	#include "op_api_ut_common/scalar_desc.h"
17	#include "op_api_ut_common/op_api_ut.h"	17	#include "op_api_ut_common/op_api_ut.h"
	@@ -19,59 +19,61 @@
19	using namespace std;	19	using namespace std;
20		20
21	class complex_test : public testing::Test {	21	class complex_test : public testing::Test {
22	protected:	22	protected:
23	static void SetUpTestCase() { cout << "complex_test SetUp" << endl; }	23	static void SetUpTestCase() { cout << "complex_test SetUp" << endl; }
24		24
25	static void TearDownTestCase() { cout << "complex_test TearDown" << endl; }	25	static void TearDownTestCase() { cout << "complex_test TearDown" << endl; }
26	};	26	};
27		27
28		28	TEST_F(complex_test, ascend910B2_complex_test_complex64)
29	TEST_F(complex_test, ascend910B2_complex_test_complex64) {	29	{
30	auto tensor_real = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND);	30	auto tensor_real = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND);
31	auto tensor_imag = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND);	31	auto tensor_imag = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND);
32	auto tensor_out = TensorDesc({2, 3}, ACL_COMPLEX64, ACL_FORMAT_ND);	32	auto tensor_out = TensorDesc({2, 3}, ACL_COMPLEX64, ACL_FORMAT_ND);
33	auto ut = OP_API_UT(aclnnComplex, INPUT(tensor_real, tensor_imag), OUTPUT(tensor_out));	33	auto ut = OP_API_UT(aclnnComplex, INPUT(tensor_real, tensor_imag), OUTPUT(tensor_out));
34	// SAMPLE: only test GetWorkspaceSize	34	// SAMPLE: only test GetWorkspaceSize
35	uint64_t workspace_size = 0;	35	uint64_t workspace_size = 0;
36	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	36	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
37	EXPECT_EQ(aclRet, ACL_SUCCESS);	37	EXPECT_EQ(aclRet, ACL_SUCCESS);
38
39	}	38	}
40		39
41	TEST_F(complex_test, ascend910B2_complex_test_complex32) {	40	TEST_F(complex_test, ascend910B2_complex_test_complex32)
42	auto tensor_real = TensorDesc({2, 3}, ACL_FLOAT16, ACL_FORMAT_ND);	41	{
43	auto tensor_imag = TensorDesc({2, 3}, ACL_FLOAT16, ACL_FORMAT_ND);	42	auto tensor_real = TensorDesc({2, 3}, ACL_FLOAT16, ACL_FORMAT_ND);
44	auto tensor_out = TensorDesc({2, 3}, ACL_COMPLEX32, ACL_FORMAT_ND);	43	auto tensor_imag = TensorDesc({2, 3}, ACL_FLOAT16, ACL_FORMAT_ND);
45	auto ut = OP_API_UT(aclnnComplex, INPUT(tensor_real, tensor_imag), OUTPUT(tensor_out));	44	auto tensor_out = TensorDesc({2, 3}, ACL_COMPLEX32, ACL_FORMAT_ND);
		45	auto ut = OP_API_UT(aclnnComplex, INPUT(tensor_real, tensor_imag), OUTPUT(tensor_out));
46		46
47	// SAMPLE: only test GetWorkspaceSize	47	// SAMPLE: only test GetWorkspaceSize
48	uint64_t workspace_size = 0;	48	uint64_t workspace_size = 0;
49	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	49	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
50	EXPECT_EQ(aclRet, ACL_SUCCESS);	50	EXPECT_EQ(aclRet, ACL_SUCCESS);
51	}	51	}
52		52
53	TEST_F(complex_test, ascend910B2_complex_test_complex128) {	53	TEST_F(complex_test, ascend910B2_complex_test_complex128)
54	auto tensor_real = TensorDesc({2, 3}, ACL_COMPLEX32, ACL_FORMAT_ND);	54	{
55	auto tensor_imag = TensorDesc({2, 3}, ACL_COMPLEX32, ACL_FORMAT_ND);	55	auto tensor_real = TensorDesc({2, 3}, ACL_COMPLEX32, ACL_FORMAT_ND);
56	auto tensor_out = TensorDesc({2, 3}, ACL_COMPLEX128, ACL_FORMAT_ND);	56	auto tensor_imag = TensorDesc({2, 3}, ACL_COMPLEX32, ACL_FORMAT_ND);
57	auto ut = OP_API_UT(aclnnComplex, INPUT(tensor_real, tensor_imag), OUTPUT(tensor_out));	57	auto tensor_out = TensorDesc({2, 3}, ACL_COMPLEX128, ACL_FORMAT_ND);
		58	auto ut = OP_API_UT(aclnnComplex, INPUT(tensor_real, tensor_imag), OUTPUT(tensor_out));
58		59
59	// SAMPLE: only test GetWorkspaceSize	60	// SAMPLE: only test GetWorkspaceSize
60	uint64_t workspace_size = 0;	61	uint64_t workspace_size = 0;
61	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	62	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
62	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);	63	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
63	}	64	}
64		65
65	TEST_F(complex_test, ascend910B2_complex_test_output_check) {	66	TEST_F(complex_test, ascend910B2_complex_test_output_check)
66	auto tensor_real = TensorDesc({2, 3}, ACL_DOUBLE, ACL_FORMAT_ND);	67	{
67	auto tensor_imag = TensorDesc({2, 3}, ACL_DOUBLE, ACL_FORMAT_ND);	68	auto tensor_real = TensorDesc({2, 3}, ACL_DOUBLE, ACL_FORMAT_ND);
68	auto tensor_out = TensorDesc({2, 3}, ACL_COMPLEX64, ACL_FORMAT_ND);	69	auto tensor_imag = TensorDesc({2, 3}, ACL_DOUBLE, ACL_FORMAT_ND);
69	auto ut = OP_API_UT(aclnnComplex, INPUT(tensor_real, tensor_imag), OUTPUT(tensor_out));	70	auto tensor_out = TensorDesc({2, 3}, ACL_COMPLEX64, ACL_FORMAT_ND);
		71	auto ut = OP_API_UT(aclnnComplex, INPUT(tensor_real, tensor_imag), OUTPUT(tensor_out));
70		72
71	// SAMPLE: only test GetWorkspaceSize	73	// SAMPLE: only test GetWorkspaceSize
72	uint64_t workspace_size = 0;	74	uint64_t workspace_size = 0;
73	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	75	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
74	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);	76	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
75	}	77	}
76		78
77	// 测试空tensor	79	// 测试空tensor
	@@ -84,4 +86,4 @@ TEST_F(complex_test, ascend910B2_case_empty_tensors)
84	uint64_t workspace_size = 0;	86	uint64_t workspace_size = 0;
85	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	87	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
86	EXPECT_EQ(aclRet, ACL_SUCCESS);	88	EXPECT_EQ(aclRet, ACL_SUCCESS);
87	}	89	}

Dmath/complex/tests/ut/op_host/CMakeLists.txt+0-20

	@@ -1,20 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()
18
19	if(OP_API_UT OR (UT_TEST_ALL AND NOT AICPU_ONLY))
20	endif()

Dmath/complex/tests/ut/op_host/op_api/CMakeLists.txt+0-10

	@@ -1,10 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------

Mmath/cummax/CMakeLists.txt+3-12

	@@ -1,20 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11		10
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE cummax ACLNNTYPE aclnn_exclude)
13	if(NOT ENABLE_TEST AND NOT BENCHMARK)
14	list(REMOVE_ITEM CURRENT_DIRS tests)
15	endif()
16	foreach(SUB_DIR ${CURRENT_DIRS})
17	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
18	add_subdirectory(${SUB_DIR})
19	endif()
20	endforeach()

Rmath/cummax/op_host/op_api/aclnn_cummax.cpp→math/cummax/op_api/aclnn_cummax.cpp+81-76

	@@ -35,112 +35,117 @@ static const std::initializer_list<op::DataType> ASCEND910_SELF_DTYPE_SUPPORT_LI
35	op::DataType::DT_INT64, op::DataType::DT_UINT8, op::DataType::DT_BOOL};	35	op::DataType::DT_INT64, op::DataType::DT_UINT8, op::DataType::DT_BOOL};
36		36
37	static const std::initializer_list<op::DataType> ASCEND910B_SELF_DTYPE_SUPPORT_LIST = {	37	static const std::initializer_list<op::DataType> ASCEND910B_SELF_DTYPE_SUPPORT_LIST = {
38	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_DOUBLE,	38	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_DOUBLE, op::DataType::DT_INT8,
39	op::DataType::DT_INT8, op::DataType::DT_INT16, op::DataType::DT_INT32,	39	op::DataType::DT_INT16, op::DataType::DT_INT32, op::DataType::DT_INT64, op::DataType::DT_UINT8,
40	op::DataType::DT_INT64, op::DataType::DT_UINT8, op::DataType::DT_BOOL,	40	op::DataType::DT_BOOL, op::DataType::DT_BF16};
41	op::DataType::DT_BF16};
42		41
43	static const std::initializer_list<op::DataType> INDICES_DTYPE_SUPPORT_LIST = {op::DataType::DT_INT32,	42	static const std::initializer_list<op::DataType> INDICES_DTYPE_SUPPORT_LIST = {op::DataType::DT_INT32,
44	op::DataType::DT_INT64};	43	op::DataType::DT_INT64};
45		44
46	static bool CheckDtypeValid(const aclTensor* self, const aclTensor* valuesOut, const aclTensor* indicesOut) {	45	static bool CheckDtypeValid(const aclTensor* self, const aclTensor* valuesOut, const aclTensor* indicesOut)
47	bool isAscend910BSocVersion = (GetCurrentPlatformInfo().GetSocVersion() >= SocVersion::ASCEND910B &&	46	{
		47	bool isAscend910BSocVersion = (GetCurrentPlatformInfo().GetSocVersion() >= SocVersion::ASCEND910B &&
48	GetCurrentPlatformInfo().GetSocVersion() <= SocVersion::ASCEND910E);	48	GetCurrentPlatformInfo().GetSocVersion() <= SocVersion::ASCEND910E);
49	const std::initializer_list<op::DataType> selfDtypeSupportList =	49	const std::initializer_list<op::DataType> selfDtypeSupportList = isAscend910BSocVersion ?
50	isAscend910BSocVersion ? ASCEND910B_SELF_DTYPE_SUPPORT_LIST : ASCEND910_SELF_DTYPE_SUPPORT_LIST;	50	ASCEND910B_SELF_DTYPE_SUPPORT_LIST :
51	OP_CHECK_DTYPE_NOT_SUPPORT(self, selfDtypeSupportList, return false);	51	ASCEND910_SELF_DTYPE_SUPPORT_LIST;
52	OP_CHECK_DTYPE_NOT_SUPPORT(valuesOut, selfDtypeSupportList, return false);	52	OP_CHECK_DTYPE_NOT_SUPPORT(self, selfDtypeSupportList, return false);
53	OP_CHECK_DTYPE_NOT_SUPPORT(indicesOut, INDICES_DTYPE_SUPPORT_LIST, return false);	53	OP_CHECK_DTYPE_NOT_SUPPORT(valuesOut, selfDtypeSupportList, return false);
		54	OP_CHECK_DTYPE_NOT_SUPPORT(indicesOut, INDICES_DTYPE_SUPPORT_LIST, return false);
54		55
55	return true;	56	return true;
56	}	57	}
57		58
58	static bool CheckDimValid(const aclTensor* self, const int64_t dim) {	59	static bool CheckDimValid(const aclTensor* self, const int64_t dim)
59	const int64_t dimNum = self->GetViewShape().GetDimNum();	60	{
60	int64_t minimum = dimNum * (-1);	61	const int64_t dimNum = self->GetViewShape().GetDimNum();
61	int64_t maximum = dimNum - 1;	62	int64_t minimum = dimNum * (-1);
62	if (dimNum == 0) {	63	int64_t maximum = dimNum - 1;
63	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "dimension specified as %ld but tensor has not dimensions.", dim);	64	if (dimNum == 0) {
64	return false;	65	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "dimension specified as %ld but tensor has not dimensions.", dim);
65	}	66	return false;
66	if (dim < minimum \|\| dim > maximum) {	67	}
67	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "dim must be within the range of [%ld, %ld], but it is %ld.", minimum, maximum,	68	if (dim < minimum \|\| dim > maximum) {
68	dim);	69	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "dim must be within the range of [%ld, %ld], but it is %ld.", minimum, maximum,
69	return false;	70	dim);
70	}	71	return false;
71	return true;	72	}
		73	return true;
72	}	74	}
73		75
74	static aclnnStatus CheckParamsCummax(const aclTensor* self, const int64_t dim, const aclTensor* valuesOut,	76	static aclnnStatus CheckParamsCummax(const aclTensor* self, const int64_t dim, const aclTensor* valuesOut,
75	const aclTensor* indicesOut) {	77	const aclTensor* indicesOut)
76	// 1. 检查参数是否为空指针	78	{
77	CHECK_RET(CheckNotNull3Tensor(self, valuesOut, indicesOut), ACLNN_ERR_PARAM_NULLPTR);	79	// 1. 检查参数是否为空指针
		80	CHECK_RET(CheckNotNull3Tensor(self, valuesOut, indicesOut), ACLNN_ERR_PARAM_NULLPTR);
78		81
79	// 2. 检查dim 是否合法	82	// 2. 检查dim 是否合法
80	CHECK_RET(CheckDimValid(self, dim), ACLNN_ERR_PARAM_INVALID);	83	CHECK_RET(CheckDimValid(self, dim), ACLNN_ERR_PARAM_INVALID);
81		84
82	// 3. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验	85	// 3. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验
83	CHECK_RET(CheckDtypeValid(self, valuesOut, indicesOut), ACLNN_ERR_PARAM_INVALID);	86	CHECK_RET(CheckDtypeValid(self, valuesOut, indicesOut), ACLNN_ERR_PARAM_INVALID);
84		87
85	// 4. 检查shape是否支持	88	// 4. 检查shape是否支持
86	CHECK_RET(CheckShapeCumMinMax(self, valuesOut, indicesOut), ACLNN_ERR_PARAM_INVALID);	89	CHECK_RET(CheckShapeCumMinMax(self, valuesOut, indicesOut), ACLNN_ERR_PARAM_INVALID);
87		90
88	return ACLNN_SUCCESS;	91	return ACLNN_SUCCESS;
89	}	92	}
90		93
91	aclnnStatus aclnnCummaxGetWorkspaceSize(const aclTensor* self, int64_t dim, aclTensor* valuesOut, aclTensor* indicesOut,	94	aclnnStatus aclnnCummaxGetWorkspaceSize(const aclTensor* self, int64_t dim, aclTensor* valuesOut, aclTensor* indicesOut,
92	uint64_t* workspaceSize, aclOpExecutor** executor) {	95	uint64_t* workspaceSize, aclOpExecutor** executor)
93	OP_CHECK_COMM_INPUT(workspaceSize, executor);	96	{
94		97	OP_CHECK_COMM_INPUT(workspaceSize, executor);
95	L2_DFX_PHASE_1(aclnnCummax, DFX_IN(self, dim), DFX_OUT(valuesOut, indicesOut));
96		98
97	auto ret = CheckParamsCummax(self, dim, valuesOut, indicesOut);	99	L2_DFX_PHASE_1(aclnnCummax, DFX_IN(self, dim), DFX_OUT(valuesOut, indicesOut));
98	CHECK_RET(ret == ACLNN_SUCCESS, ret);
99		100
100	auto uniqueExecutor = CREATE_EXECUTOR();	101	auto ret = CheckParamsCummax(self, dim, valuesOut, indicesOut);
101	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);	102	CHECK_RET(ret == ACLNN_SUCCESS, ret);
102		103
103	if (self->IsEmpty()) {	104	auto uniqueExecutor = CREATE_EXECUTOR();
104	*workspaceSize = 0;	105	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
105	uniqueExecutor.ReleaseTo(executor);
106	return ACLNN_SUCCESS;
107	}
108		106
109	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());	107	if (self->IsEmpty()) {
110	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);	108	*workspaceSize = 0;
111	if (selfContiguous->GetDataType() == DataType::DT_BOOL) {	109	uniqueExecutor.ReleaseTo(executor);
112	selfContiguous = l0op::Cast(selfContiguous, DataType::DT_UINT8, uniqueExecutor.get());	110	return ACLNN_SUCCESS;
		111	}
		112
		113	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
113	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);	114	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
114	}	115	if (selfContiguous->GetDataType() == DataType::DT_BOOL) {
		116	selfContiguous = l0op::Cast(selfContiguous, DataType::DT_UINT8, uniqueExecutor.get());
		117	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
		118	}
115		119
116	std::tuple<aclTensor, aclTensor> cummaxResult;	120	std::tuple<aclTensor, aclTensor> cummaxResult;
117	if (indicesOut->GetDataType() == DataType::DT_INT64) {	121	if (indicesOut->GetDataType() == DataType::DT_INT64) {
118	cummaxResult = l0op::CummaxOutInt64(selfContiguous, dim, uniqueExecutor.get());	122	cummaxResult = l0op::CummaxOutInt64(selfContiguous, dim, uniqueExecutor.get());
119	} else {	123	} else {
120	cummaxResult = l0op::CummaxOutInt32(selfContiguous, dim, uniqueExecutor.get());	124	cummaxResult = l0op::CummaxOutInt32(selfContiguous, dim, uniqueExecutor.get());
121	}	125	}
122	const aclTensor* valuesResult = std::get<0>(cummaxResult);	126	const aclTensor* valuesResult = std::get<0>(cummaxResult);
123	CHECK_RET(valuesResult != nullptr, ACLNN_ERR_INNER_NULLPTR);	127	CHECK_RET(valuesResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
124	const aclTensor* indicesResult = std::get<1>(cummaxResult);	128	const aclTensor* indicesResult = std::get<1>(cummaxResult);
125	CHECK_RET(indicesResult != nullptr, ACLNN_ERR_INNER_NULLPTR);	129	CHECK_RET(indicesResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
126		130
127	auto valuesCastResult = l0op::Cast(valuesResult, valuesOut->GetDataType(), uniqueExecutor.get());	131	auto valuesCastResult = l0op::Cast(valuesResult, valuesOut->GetDataType(), uniqueExecutor.get());
128	CHECK_RET(valuesCastResult != nullptr, ACLNN_ERR_INNER_NULLPTR);	132	CHECK_RET(valuesCastResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
129	auto valuesViewCopyResult = l0op::ViewCopy(valuesCastResult, valuesOut, uniqueExecutor.get());	133	auto valuesViewCopyResult = l0op::ViewCopy(valuesCastResult, valuesOut, uniqueExecutor.get());
130	CHECK_RET(valuesViewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);	134	CHECK_RET(valuesViewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
131		135
132	auto indicesViewCopyResult = l0op::ViewCopy(indicesResult, indicesOut, uniqueExecutor.get());	136	auto indicesViewCopyResult = l0op::ViewCopy(indicesResult, indicesOut, uniqueExecutor.get());
133	CHECK_RET(indicesViewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);	137	CHECK_RET(indicesViewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
134		138
135	*workspaceSize = uniqueExecutor->GetWorkspaceSize();	139	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
136	uniqueExecutor.ReleaseTo(executor);	140	uniqueExecutor.ReleaseTo(executor);
137		141
138	return ACLNN_SUCCESS;	142	return ACLNN_SUCCESS;
139	}	143	}
140		144
141	aclnnStatus aclnnCummax(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream) {	145	aclnnStatus aclnnCummax(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
142	L2_DFX_PHASE_2(aclnnCummax);	146	{
143	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	147	L2_DFX_PHASE_2(aclnnCummax);
		148	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
144	}	149	}
145		150
146	#ifdef __cplusplus	151	#ifdef __cplusplus

Rmath/cummax/op_host/op_api/aclnn_cummax.h→math/cummax/op_api/aclnn_cummax.h+1-1

	@@ -62,4 +62,4 @@ ACLNN_API aclnnStatus aclnnCummax(void* workspace, uint64_t workspaceSize, aclOp
62	}	62	}
63	#endif	63	#endif
64		64
65	#endif // OP_API_INC_LEVEL2_ACLNN_CUMMAX_H_	65	#endif // OP_API_INC_LEVEL2_ACLNN_CUMMAX_H_

Rmath/cummax/op_host/op_api/cummax.cpp→math/cummax/op_api/cummax.cpp+33-29

	@@ -31,41 +31,45 @@ OP_TYPE_REGISTER(Cummax);
31		31
32	// AICPU算子kernel	32	// AICPU算子kernel
33	static inline std::tuple<aclTensor, aclTensor> CummaxAiCpu(const aclTensor* self, int64_t dim, aclTensor* valuesOut,	33	static inline std::tuple<aclTensor, aclTensor> CummaxAiCpu(const aclTensor* self, int64_t dim, aclTensor* valuesOut,
34	aclTensor* indicesOut, aclOpExecutor* executor) {	34	aclTensor* indicesOut, aclOpExecutor* executor)
35	L0_DFX(CummaxAiCpu, self, dim, valuesOut, indicesOut);	35	{
		36	L0_DFX(CummaxAiCpu, self, dim, valuesOut, indicesOut);
36		37
37	static internal::AicpuTaskSpace space("Cummax");	38	static internal::AicpuTaskSpace space("Cummax");
38	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICPU，将AiCpu Cummax算子加入任务队列	39	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICPU，将AiCpu Cummax算子加入任务队列
39	// Cummax是算子的OpType，self是算子的输入，valuesOut、indicesOut是算子的输出，属性dim传入dim	40	// Cummax是算子的OpType，self是算子的输入，valuesOut、indicesOut是算子的输出，属性dim传入dim
40	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(Cummax, OP_ATTR_NAMES({"dim"}), OP_INPUT(self), OP_OUTPUT(valuesOut, indicesOut),	41	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(Cummax, OP_ATTR_NAMES({"dim"}), OP_INPUT(self),
41	OP_ATTR(dim));	42	OP_OUTPUT(valuesOut, indicesOut), OP_ATTR(dim));
42	if (ret != ACL_SUCCESS) {	43	if (ret != ACL_SUCCESS) {
43	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "CummaxAiCpu ADD_TO_LAUNCHER_LIST_AICPU failed.");	44	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "CummaxAiCpu ADD_TO_LAUNCHER_LIST_AICPU failed.");
44	return std::tuple<aclTensor, aclTensor>(nullptr, nullptr);	45	return std::tuple<aclTensor, aclTensor>(nullptr, nullptr);
45	}	46	}
46	return {valuesOut, indicesOut};	47	return {valuesOut, indicesOut};
47	}	48	}
48		49
49	static inline std::tuple<aclTensor, aclTensor> CummaxExec(const aclTensor* self, int64_t dim, aclTensor* valuesOut,	50	static inline std::tuple<aclTensor, aclTensor> CummaxExec(const aclTensor* self, int64_t dim, aclTensor* valuesOut,
50	aclTensor* indicesOut, aclOpExecutor* executor) {	51	aclTensor* indicesOut, aclOpExecutor* executor)
51	if (valuesOut == nullptr \|\| indicesOut == nullptr) {	52	{
52	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "alloc out tensor failed.");	53	if (valuesOut == nullptr \|\| indicesOut == nullptr) {
53	return {nullptr, nullptr};	54	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "alloc out tensor failed.");
54	}	55	return {nullptr, nullptr};
55	return CummaxAiCpu(self, dim, valuesOut, indicesOut, executor);	56	}
		57	return CummaxAiCpu(self, dim, valuesOut, indicesOut, executor);
56	}	58	}
57		59
58	std::tuple<aclTensor, aclTensor> CummaxOutInt32(const aclTensor* self, int64_t dim, aclOpExecutor* executor) {	60	std::tuple<aclTensor, aclTensor> CummaxOutInt32(const aclTensor* self, int64_t dim, aclOpExecutor* executor)
59	// 根据输入shape申请输出tensor	61	{
60	auto valuesOut = executor->AllocTensor(self->GetViewShape(), self->GetDataType(), self->GetViewFormat());	62	// 根据输入shape申请输出tensor
61	auto indicesOut = executor->AllocTensor(self->GetViewShape(), DataType::DT_INT32, self->GetViewFormat());	63	auto valuesOut = executor->AllocTensor(self->GetViewShape(), self->GetDataType(), self->GetViewFormat());
62	return CummaxExec(self, dim, valuesOut, indicesOut, executor);	64	auto indicesOut = executor->AllocTensor(self->GetViewShape(), DataType::DT_INT32, self->GetViewFormat());
		65	return CummaxExec(self, dim, valuesOut, indicesOut, executor);
63	}	66	}
64		67
65	std::tuple<aclTensor, aclTensor> CummaxOutInt64(const aclTensor* self, int64_t dim, aclOpExecutor* executor) {	68	std::tuple<aclTensor, aclTensor> CummaxOutInt64(const aclTensor* self, int64_t dim, aclOpExecutor* executor)
66	// 根据输入shape申请输出tensor	69	{
67	auto valuesOut = executor->AllocTensor(self->GetViewShape(), self->GetDataType(), self->GetViewFormat());	70	// 根据输入shape申请输出tensor
68	auto indicesOut = executor->AllocTensor(self->GetViewShape(), DataType::DT_INT64, self->GetViewFormat());	71	auto valuesOut = executor->AllocTensor(self->GetViewShape(), self->GetDataType(), self->GetViewFormat());
69	return CummaxExec(self, dim, valuesOut, indicesOut, executor);	72	auto indicesOut = executor->AllocTensor(self->GetViewShape(), DataType::DT_INT64, self->GetViewFormat());
		73	return CummaxExec(self, dim, valuesOut, indicesOut, executor);
70	}	74	}
71	} // namespace l0op	75	} // namespace l0op

Rmath/cummax/op_host/op_api/cummax.h→math/cummax/op_api/cummax.h+2-2

	@@ -17,6 +17,6 @@ namespace l0op {
17	std::tuple<aclTensor, aclTensor> CummaxOutInt32(const aclTensor* self, int64_t dim, aclOpExecutor* executor);	17	std::tuple<aclTensor, aclTensor> CummaxOutInt32(const aclTensor* self, int64_t dim, aclOpExecutor* executor);
18		18
19	std::tuple<aclTensor, aclTensor> CummaxOutInt64(const aclTensor* self, int64_t dim, aclOpExecutor* executor);	19	std::tuple<aclTensor, aclTensor> CummaxOutInt64(const aclTensor* self, int64_t dim, aclOpExecutor* executor);
20	} // namespace l0op	20	} // namespace l0op
21		21
22	#endif // OP_API_INC_LEVEL0_CUMMAX_H_	22	#endif // OP_API_INC_LEVEL0_CUMMAX_H_

Dmath/cummax/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources(OPTYPE cummax ACLNNTYPE aclnn_exclude)

Dmath/cummax/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/cummax/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Amath/cummax/tests/ut/op_api/test_aclnn_cummax.cpp+356-0

@@ -0,0 +1,356 @@
	1	/**
	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10
	11	#include "../../../op_api/aclnn_cummax.h"
	12	#include <vector>
	13	#include <array>
	14	#include "gtest/gtest.h"
	15	#include "op_api_ut_common/tensor_desc.h"
	16	#include "op_api_ut_common/scalar_desc.h"
	17	#include "op_api_ut_common/op_api_ut.h"
	18
	19	using namespace std;
	20
	21	class l2_cummax_test : public testing::Test {
	22	protected:
	23	static void SetUpTestCase() { cout << "cummax_test SetUp" << endl; }
	24
	25	static void TearDownTestCase() { cout << "cummax_test TearDown" << endl; }
	26	};
	27
	28	// 正常场景
	29	TEST_F(l2_cummax_test, l2_cummax_all_datatype_out_int64)
	30	{
	31	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
	32	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
	33	int64_t dim = 0;
	34	for (auto dtype : dtypes) {
	35	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	36	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	37	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
	38
	39	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	40	}
	41	}
	42
	43	TEST_F(l2_cummax_test, l2_cummax_all_datatype_out_int32)
	44	{
	45	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
	46	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
	47	int64_t dim = 0;
	48	for (auto dtype : dtypes) {
	49	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	50	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	51	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
	52
	53	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	54	}
	55	}
	56
	57	TEST_F(l2_cummax_test, l2_cummax_all_Format)
	58	{
	59	vector<aclFormat> formats{ACL_FORMAT_ND, ACL_FORMAT_NCHW, ACL_FORMAT_NHWC, ACL_FORMAT_NCDHW,
	60	ACL_FORMAT_NDHWC, ACL_FORMAT_NC, ACL_FORMAT_NCL};
	61	int64_t dim = 0;
	62	aclDataType dtype = ACL_FLOAT;
	63	for (auto format : formats) {
	64	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, format).ValueRange(-50, 50);
	65	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, format).ValueRange(-50, 50);
	66	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT32, format).ValueRange(-50, 50);
	67
	68	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	69	}
	70	}
	71
	72	TEST_F(l2_cummax_test, l2_cummax_all_datatype_not_same_out_int64)
	73	{
	74	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
	75	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
	76	int64_t dim = 0;
	77	for (auto dtype : dtypes) {
	78	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	79	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
	80	for (auto dtype_ : dtypes) {
	81	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype_, ACL_FORMAT_ND).ValueRange(-50, 50);
	82
	83	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	84	}
	85	}
	86	}
	87
	88	TEST_F(l2_cummax_test, l2_cummax_all_datatype_not_same_out_int32)
	89	{
	90	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
	91	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
	92	int64_t dim = 0;
	93	for (auto dtype : dtypes) {
	94	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	95	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
	96	for (auto dtype_ : dtypes) {
	97	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype_, ACL_FORMAT_ND).ValueRange(-50, 50);
	98
	99	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	100	}
	101	}
	102	}
	103
	104	TEST_F(l2_cummax_test, l2_cummax_all_datatype_out_int32_8_dim_0)
	105	{
	106	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
	107	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
	108	int64_t dim = 0;
	109	for (auto dtype : dtypes) {
	110	auto self_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	111	auto values_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	112	auto indices_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
	113
	114	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	115	}
	116	}
	117
	118	TEST_F(l2_cummax_test, l2_cummax_all_datatype_out_int64_8_dim_0)
	119	{
	120	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
	121	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
	122	int64_t dim = 0;
	123	for (auto dtype : dtypes) {
	124	auto self_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	125	auto values_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	126	auto indices_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
	127
	128	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	129	}
	130	}
	131
	132	TEST_F(l2_cummax_test, l2_cummax_all_datatype_out_int32_8_dim_1)
	133	{
	134	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
	135	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
	136	int64_t dim = 1;
	137	for (auto dtype : dtypes) {
	138	auto self_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	139	auto values_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	140	auto indices_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
	141
	142	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	143	}
	144	}
	145
	146	TEST_F(l2_cummax_test, l2_cummax_out_int64_8_dim_1)
	147	{
	148	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
	149	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
	150	int64_t dim = 1;
	151	for (auto dtype : dtypes) {
	152	auto self_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	153	auto values_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	154	auto indices_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
	155
	156	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	157	}
	158	}
	159
	160	TEST_F(l2_cummax_test, l2_cummax_out_int32_negative_one)
	161	{
	162	int64_t dim = -1;
	163	aclDataType dtype = ACL_FLOAT;
	164	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	165	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	166	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
	167
	168	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	169	}
	170
	171	TEST_F(l2_cummax_test, l2_cummax_self_same_values)
	172	{
	173	int64_t dim = 0;
	174	aclDataType dtype = ACL_FLOAT;
	175	auto self_tensor = TensorDesc({8}, dtype, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 1});
	176	auto values_tensor = TensorDesc({8}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	177	auto indices_tensor = TensorDesc({8}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
	178
	179	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	180	}
	181
	182	TEST_F(l2_cummax_test, l2_cummax_null_tensor)
	183	{
	184	int64_t dim = 1;
	185	aclDataType dtype = ACL_FLOAT;
	186	auto self_tensor = TensorDesc({2, 2, 0, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	187	auto values_tensor = TensorDesc({2, 2, 0, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	188	auto indices_tensor = TensorDesc({2, 2, 0, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
	189
	190	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	191	uint64_t workspace_size = 0;
	192	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	193	EXPECT_EQ(aclRet, ACLNN_SUCCESS);
	194	}
	195
	196	// discontinues
	197	TEST_F(l2_cummax_test, l2_cummax_out_int64_self_discontinues)
	198	{
	199	int64_t dim = 0;
	200	aclDataType dtype = ACL_FLOAT;
	201	auto self_tensor = TensorDesc({2, 2, 5, 4}, ACL_FLOAT, ACL_FORMAT_NCHW, {40, 20, 1, 5}, 0, {2, 2, 4, 5})
	202	.ValueRange(-50, 50);
	203	auto values_tensor = TensorDesc({2, 2, 5, 4}, dtype, ACL_FORMAT_NCHW).ValueRange(-50, 50);
	204	auto indices_tensor = TensorDesc({2, 2, 5, 4}, ACL_INT64, ACL_FORMAT_NCHW).ValueRange(-50, 50);
	205
	206	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	207	}
	208	TEST_F(l2_cummax_test, l2_cummax_out_int32_self_discontinues)
	209	{
	210	int64_t dim = 0;
	211	aclDataType dtype = ACL_FLOAT;
	212	auto self_tensor = TensorDesc({2, 2, 5, 4}, dtype, ACL_FORMAT_ND, {40, 20, 1, 5}, 0, {2, 2, 4, 5})
	213	.ValueRange(-50, 50);
	214	auto values_tensor = TensorDesc({2, 2, 5, 4}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	215	auto indices_tensor = TensorDesc({2, 2, 5, 4}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
	216
	217	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	218	}
	219
	220	TEST_F(l2_cummax_test, l2_cummax_out_int64_out_discontinues)
	221	{
	222	int64_t dim = 0;
	223	aclDataType dtype = ACL_FLOAT;
	224	auto self_tensor = TensorDesc({2, 2, 5, 4}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	225	auto values_tensor = TensorDesc({2, 2, 5, 4}, dtype, ACL_FORMAT_ND, {40, 20, 1, 5}, 0, {2, 2, 4, 5})
	226	.ValueRange(-50, 50);
	227	auto indices_tensor = TensorDesc({2, 2, 5, 4}, ACL_INT64, ACL_FORMAT_ND, {40, 20, 1, 5}, 0, {2, 2, 4, 5})
	228	.ValueRange(-50, 50);
	229
	230	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	231	}
	232
	233	// Abnormal Scenarios
	234	TEST_F(l2_cummax_test, l2_cummax_self_datatype_not_support)
	235	{
	236	vector<aclDataType> dtypes{ACL_COMPLEX64, ACL_COMPLEX128};
	237	int64_t dim = 1;
	238	for (auto dtype : dtypes) {
	239	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	240	auto values_tensor = TensorDesc({2, 2, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-50, 50);
	241	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
	242
	243	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	244	uint64_t workspace_size = 0;
	245	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	246	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	247	}
	248	}
	249
	250	TEST_F(l2_cummax_test, l2_cummax_values_datatype_not_support)
	251	{
	252	vector<aclDataType> dtypes{ACL_COMPLEX64, ACL_COMPLEX128};
	253	int64_t dim = 1;
	254	for (auto dtype : dtypes) {
	255	auto self_tensor = TensorDesc({2, 2, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-50, 50);
	256	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	257	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
	258
	259	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	260	uint64_t workspace_size = 0;
	261	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	262	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	263	}
	264	}
	265
	266	TEST_F(l2_cummax_test, l2_cummax_indices_datatype_not_support)
	267	{
	268	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
	269	ACL_INT16, ACL_BOOL, ACL_COMPLEX64, ACL_COMPLEX128};
	270	int64_t dim = 1;
	271	for (auto dtype : dtypes) {
	272	auto self_tensor = TensorDesc({2, 2, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-50, 50);
	273	auto values_tensor = TensorDesc({2, 2, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-50, 50);
	274	auto indices_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	275
	276	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	277	uint64_t workspace_size = 0;
	278	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	279	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	280	}
	281	}
	282
	283	TEST_F(l2_cummax_test, l2_cummax_values_shape_not_support_out_int32)
	284	{
	285	aclDataType dtype = ACL_FLOAT;
	286	int64_t dim = 1;
	287
	288	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	289	auto values_tensor = TensorDesc({2, 2, 2, 4}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	290	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
	291
	292	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	293	uint64_t workspace_size = 0;
	294	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	295	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	296	}
	297
	298	TEST_F(l2_cummax_test, l2_cummax_values_shape_not_support_out_int64)
	299	{
	300	aclDataType dtype = ACL_FLOAT;
	301	int64_t dim = 1;
	302
	303	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	304	auto values_tensor = TensorDesc({2, 2, 2, 4}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	305	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
	306
	307	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	308	uint64_t workspace_size = 0;
	309	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	310	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	311	}
	312
	313	TEST_F(l2_cummax_test, l2_cummax_indices_shape_not_support_out_int32)
	314	{
	315	aclDataType dtype = ACL_FLOAT;
	316	int64_t dim = 1;
	317
	318	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	319	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	320	auto indices_tensor = TensorDesc({2, 2, 2, 4}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
	321
	322	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	323	uint64_t workspace_size = 0;
	324	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	325	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	326	}
	327
	328	TEST_F(l2_cummax_test, l2_cummax_self_nullptr)
	329	{
	330	aclDataType dtype = ACL_FLOAT;
	331	int64_t dim = 1;
	332
	333	auto self_tensor = nullptr;
	334	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	335	auto indices_tensor = TensorDesc({2, 2, 2, 4}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
	336
	337	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	338	uint64_t workspace_size = 0;
	339	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	340	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	341	}
	342
	343	TEST_F(l2_cummax_test, l2_cummax_self_9_dims)
	344	{
	345	aclDataType dtype = ACL_FLOAT;
	346	int64_t dim = 1;
	347
	348	auto self_tensor = TensorDesc({1, 1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	349	auto values_tensor = TensorDesc({1, 1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
	350	auto indices_tensor = TensorDesc({1, 1, 1, 1, 1, 2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
	351
	352	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
	353	uint64_t workspace_size = 0;
	354	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	355	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	356	}

Dmath/cummax/tests/ut/op_host/CMakeLists.txt+0-20

	@@ -1,20 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()
18
19	if(OP_API_UT OR (UT_TEST_ALL AND NOT AICPU_ONLY))
20	endif()

Dmath/cummax/tests/ut/op_host/op_api/CMakeLists.txt+0-10

	@@ -1,10 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------

Dmath/cummax/tests/ut/op_host/op_api/test_aclnn_cummax.cpp+0-337

	@@ -1,337 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10
11	#include "aclnn_cummax.h"
12	#include <vector>
13	#include <array>
14	#include "gtest/gtest.h"
15	#include "op_api_ut_common/tensor_desc.h"
16	#include "op_api_ut_common/scalar_desc.h"
17	#include "op_api_ut_common/op_api_ut.h"
18
19	using namespace std;
20
21	class l2_cummax_test : public testing::Test {
22	protected:
23	static void SetUpTestCase() {
24	cout << "cummax_test SetUp" << endl;
25	}
26
27	static void TearDownTestCase() {
28	cout << "cummax_test TearDown" << endl;
29	}
30	};
31
32	// 正常场景
33	TEST_F(l2_cummax_test, l2_cummax_all_datatype_out_int64) {
34	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
35	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
36	int64_t dim = 0;
37	for (auto dtype : dtypes) {
38	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
39	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
40	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
41
42	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
43	}
44	}
45
46	TEST_F(l2_cummax_test, l2_cummax_all_datatype_out_int32) {
47	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
48	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
49	int64_t dim = 0;
50	for (auto dtype : dtypes) {
51	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
52	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
53	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
54
55	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
56	}
57	}
58
59	TEST_F(l2_cummax_test, l2_cummax_all_Format) {
60	vector<aclFormat> formats{ACL_FORMAT_ND, ACL_FORMAT_NCHW, ACL_FORMAT_NHWC, ACL_FORMAT_NCDHW,
61	ACL_FORMAT_NDHWC, ACL_FORMAT_NC, ACL_FORMAT_NCL};
62	int64_t dim = 0;
63	aclDataType dtype = ACL_FLOAT;
64	for (auto format : formats) {
65	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, format).ValueRange(-50, 50);
66	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, format).ValueRange(-50, 50);
67	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT32, format).ValueRange(-50, 50);
68
69	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
70	}
71	}
72
73	TEST_F(l2_cummax_test, l2_cummax_all_datatype_not_same_out_int64) {
74	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
75	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
76	int64_t dim = 0;
77	for (auto dtype : dtypes) {
78	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
79	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
80	for (auto dtype_ : dtypes) {
81	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype_, ACL_FORMAT_ND).ValueRange(-50, 50);
82
83	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
84	}
85	}
86	}
87
88	TEST_F(l2_cummax_test, l2_cummax_all_datatype_not_same_out_int32) {
89	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
90	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
91	int64_t dim = 0;
92	for (auto dtype : dtypes) {
93	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
94	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
95	for (auto dtype_ : dtypes) {
96	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype_, ACL_FORMAT_ND).ValueRange(-50, 50);
97
98	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
99	}
100	}
101	}
102
103	TEST_F(l2_cummax_test, l2_cummax_all_datatype_out_int32_8_dim_0) {
104	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
105	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
106	int64_t dim = 0;
107	for (auto dtype : dtypes) {
108	auto self_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
109	auto values_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
110	auto indices_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
111
112	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
113	}
114	}
115
116	TEST_F(l2_cummax_test, l2_cummax_all_datatype_out_int64_8_dim_0) {
117	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
118	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
119	int64_t dim = 0;
120	for (auto dtype : dtypes) {
121	auto self_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
122	auto values_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
123	auto indices_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
124
125	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
126	}
127	}
128
129	TEST_F(l2_cummax_test, l2_cummax_all_datatype_out_int32_8_dim_1) {
130	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
131	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
132	int64_t dim = 1;
133	for (auto dtype : dtypes) {
134	auto self_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
135	auto values_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
136	auto indices_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
137
138	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
139	}
140	}
141
142	TEST_F(l2_cummax_test, l2_cummax_out_int64_8_dim_1) {
143	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
144	ACL_INT16, ACL_INT32, ACL_INT64, ACL_BOOL};
145	int64_t dim = 1;
146	for (auto dtype : dtypes) {
147	auto self_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
148	auto values_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
149	auto indices_tensor = TensorDesc({1, 1, 1, 1, 2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
150
151	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
152	}
153	}
154
155	TEST_F(l2_cummax_test, l2_cummax_out_int32_negative_one) {
156	int64_t dim = -1;
157	aclDataType dtype = ACL_FLOAT;
158	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
159	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
160	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
161
162	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
163	}
164
165	TEST_F(l2_cummax_test, l2_cummax_self_same_values) {
166	int64_t dim = 0;
167	aclDataType dtype = ACL_FLOAT;
168	auto self_tensor = TensorDesc({8}, dtype, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 1});
169	auto values_tensor = TensorDesc({8}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
170	auto indices_tensor = TensorDesc({8}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
171
172	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
173	}
174
175	TEST_F(l2_cummax_test, l2_cummax_null_tensor) {
176	int64_t dim = 1;
177	aclDataType dtype = ACL_FLOAT;
178	auto self_tensor = TensorDesc({2, 2, 0, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
179	auto values_tensor = TensorDesc({2, 2, 0, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
180	auto indices_tensor = TensorDesc({2, 2, 0, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
181
182	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
183	uint64_t workspace_size = 0;
184	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
185	EXPECT_EQ(aclRet, ACLNN_SUCCESS);
186	}
187
188	// discontinues
189	TEST_F(l2_cummax_test, l2_cummax_out_int64_self_discontinues) {
190	int64_t dim = 0;
191	aclDataType dtype = ACL_FLOAT;
192	auto self_tensor =
193	TensorDesc({2, 2, 5, 4}, ACL_FLOAT, ACL_FORMAT_NCHW, {40, 20, 1, 5}, 0, {2, 2, 4, 5}).ValueRange(-50, 50);
194	auto values_tensor = TensorDesc({2, 2, 5, 4}, dtype, ACL_FORMAT_NCHW).ValueRange(-50, 50);
195	auto indices_tensor = TensorDesc({2, 2, 5, 4}, ACL_INT64, ACL_FORMAT_NCHW).ValueRange(-50, 50);
196
197	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
198	}
199	TEST_F(l2_cummax_test, l2_cummax_out_int32_self_discontinues) {
200	int64_t dim = 0;
201	aclDataType dtype = ACL_FLOAT;
202	auto self_tensor =
203	TensorDesc({2, 2, 5, 4}, dtype, ACL_FORMAT_ND, {40, 20, 1, 5}, 0, {2, 2, 4, 5}).ValueRange(-50, 50);
204	auto values_tensor = TensorDesc({2, 2, 5, 4}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
205	auto indices_tensor = TensorDesc({2, 2, 5, 4}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
206
207	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
208	}
209
210	TEST_F(l2_cummax_test, l2_cummax_out_int64_out_discontinues) {
211	int64_t dim = 0;
212	aclDataType dtype = ACL_FLOAT;
213	auto self_tensor = TensorDesc({2, 2, 5, 4}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
214	auto values_tensor =
215	TensorDesc({2, 2, 5, 4}, dtype, ACL_FORMAT_ND, {40, 20, 1, 5}, 0, {2, 2, 4, 5}).ValueRange(-50, 50);
216	auto indices_tensor =
217	TensorDesc({2, 2, 5, 4}, ACL_INT64, ACL_FORMAT_ND, {40, 20, 1, 5}, 0, {2, 2, 4, 5}).ValueRange(-50, 50);
218
219	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
220	}
221
222	// Abnormal Scenarios
223	TEST_F(l2_cummax_test, l2_cummax_self_datatype_not_support) {
224	vector<aclDataType> dtypes{ACL_COMPLEX64, ACL_COMPLEX128};
225	int64_t dim = 1;
226	for (auto dtype : dtypes) {
227	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
228	auto values_tensor = TensorDesc({2, 2, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-50, 50);
229	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
230
231	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
232	uint64_t workspace_size = 0;
233	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
234	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
235	}
236	}
237
238	TEST_F(l2_cummax_test, l2_cummax_values_datatype_not_support) {
239	vector<aclDataType> dtypes{ACL_COMPLEX64, ACL_COMPLEX128};
240	int64_t dim = 1;
241	for (auto dtype : dtypes) {
242	auto self_tensor = TensorDesc({2, 2, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-50, 50);
243	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
244	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
245
246	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
247	uint64_t workspace_size = 0;
248	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
249	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
250	}
251	}
252
253	TEST_F(l2_cummax_test, l2_cummax_indices_datatype_not_support) {
254	vector<aclDataType> dtypes{ACL_FLOAT, ACL_FLOAT16, ACL_DOUBLE, ACL_UINT8, ACL_INT8,
255	ACL_INT16, ACL_BOOL, ACL_COMPLEX64, ACL_COMPLEX128};
256	int64_t dim = 1;
257	for (auto dtype : dtypes) {
258	auto self_tensor = TensorDesc({2, 2, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-50, 50);
259	auto values_tensor = TensorDesc({2, 2, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-50, 50);
260	auto indices_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
261
262	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
263	uint64_t workspace_size = 0;
264	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
265	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
266	}
267	}
268
269	TEST_F(l2_cummax_test, l2_cummax_values_shape_not_support_out_int32) {
270	aclDataType dtype = ACL_FLOAT;
271	int64_t dim = 1;
272
273	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
274	auto values_tensor = TensorDesc({2, 2, 2, 4}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
275	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
276
277	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
278	uint64_t workspace_size = 0;
279	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
280	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
281	}
282
283	TEST_F(l2_cummax_test, l2_cummax_values_shape_not_support_out_int64) {
284	aclDataType dtype = ACL_FLOAT;
285	int64_t dim = 1;
286
287	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
288	auto values_tensor = TensorDesc({2, 2, 2, 4}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
289	auto indices_tensor = TensorDesc({2, 2, 2, 3}, ACL_INT64, ACL_FORMAT_ND).ValueRange(-50, 50);
290
291	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
292	uint64_t workspace_size = 0;
293	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
294	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
295	}
296
297	TEST_F(l2_cummax_test, l2_cummax_indices_shape_not_support_out_int32) {
298	aclDataType dtype = ACL_FLOAT;
299	int64_t dim = 1;
300
301	auto self_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
302	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
303	auto indices_tensor = TensorDesc({2, 2, 2, 4}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
304
305	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
306	uint64_t workspace_size = 0;
307	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
308	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
309	}
310
311	TEST_F(l2_cummax_test, l2_cummax_self_nullptr) {
312	aclDataType dtype = ACL_FLOAT;
313	int64_t dim = 1;
314
315	auto self_tensor = nullptr;
316	auto values_tensor = TensorDesc({2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
317	auto indices_tensor = TensorDesc({2, 2, 2, 4}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
318
319	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
320	uint64_t workspace_size = 0;
321	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
322	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
323	}
324
325	TEST_F(l2_cummax_test, l2_cummax_self_9_dims) {
326	aclDataType dtype = ACL_FLOAT;
327	int64_t dim = 1;
328
329	auto self_tensor = TensorDesc({1, 1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
330	auto values_tensor = TensorDesc({1, 1, 1, 1, 1, 2, 2, 2, 3}, dtype, ACL_FORMAT_ND).ValueRange(-50, 50);
331	auto indices_tensor = TensorDesc({1, 1, 1, 1, 1, 2, 2, 2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-50, 50);
332
333	auto ut = OP_API_UT(aclnnCummax, INPUT(self_tensor, dim), OUTPUT(values_tensor, indices_tensor));
334	uint64_t workspace_size = 0;
335	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
336	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
337	}

Mmath/cumprod/CMakeLists.txt+3-12

	@@ -1,20 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11		10
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE cumprod ACLNNTYPE aclnn_exclude)
13	if(NOT ENABLE_TEST AND NOT BENCHMARK)
14	list(REMOVE_ITEM CURRENT_DIRS tests)
15	endif()
16	foreach(SUB_DIR ${CURRENT_DIRS})
17	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
18	add_subdirectory(${SUB_DIR})
19	endif()
20	endforeach()

Amath/cumprod/op_api/aclnn_cumprod.cpp+177-0

@@ -0,0 +1,177 @@
	1	/**
	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10
	11	#include "aclnn_cumprod.h"
	12	#include "cumprod.h"
	13	#include "aclnn_kernels/common/op_error_check.h"
	14	#include "aclnn_kernels/contiguous.h"
	15	#include "op_api/op_api_def.h"
	16	#include "aclnn_kernels/cast.h"
	17	#include "opdev/make_op_executor.h"
	18	#include "opdev/platform.h"
	19	#include "opdev/op_dfx.h"
	20	#include "opdev/op_executor.h"
	21	#include "aclnn_kernels/reshape.h"
	22
	23	using namespace op;
	24	namespace {
	25	static const std::initializer_list<DataType> DTYPE_SUPPORT_LIST = {
	26	DataType::DT_FLOAT, DataType::DT_FLOAT16, DataType::DT_BF16, DataType::DT_DOUBLE,
	27	DataType::DT_INT8, DataType::DT_INT16, DataType::DT_INT32, DataType::DT_INT64,
	28	DataType::DT_UINT8, DataType::DT_UINT16, DataType::DT_UINT32, DataType::DT_UINT64};
	29
	30	static const std::initializer_list<DataType> DTYPE_SUPPORT_LIST_INT = {DataType::DT_INT32, DataType::DT_INT64};
	31	} // namespace
	32	#ifdef __cplusplus
	33	extern "C" {
	34	#endif
	35
	36	static constexpr int INDEX_0 = 0;
	37	static constexpr int DIM_NUM_0 = 0;
	38	static constexpr int DIM_NUM_1 = 1;
	39	static constexpr size_t SFDA_DIM0_SIZE = 3;
	40
	41	static inline bool CheckNotNull(const aclTensor* input, const aclScalar* inputDim, const uint64_t* workspaceSize)
	42	{
	43	OP_CHECK_NULL(input, return false);
	44	OP_CHECK_NULL(inputDim, return false);
	45	if (workspaceSize == nullptr) {
	46	return false;
	47	}
	48	return true;
	49	}
	50
	51	static inline bool CheckDtypeValid(const aclTensor* input, const aclTensor* out, const aclScalar* inputDim)
	52	{
	53	OP_CHECK_DTYPE_NOT_SUPPORT(input, DTYPE_SUPPORT_LIST, return false);
	54	OP_CHECK_DTYPE_NOT_SUPPORT(out, DTYPE_SUPPORT_LIST, return false);
	55	OP_CHECK_DTYPE_NOT_SUPPORT(inputDim, DTYPE_SUPPORT_LIST_INT, return false);
	56	return true;
	57	}
	58
	59	static inline bool CheckShape(const aclTensor* input, const aclTensor* out, const aclScalar* axis)
	60	{
	61	int32_t inputDim = input->GetViewShape().GetDimNum();
	62	int32_t inputAxis = axis->ToInt32();
	63	if (inputDim == 0 && inputAxis != 0 && inputAxis != -1) {
	64	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dimension out of range (expected to be in range of [-1, 0], but got %d)",
	65	inputAxis);
	66	return false;
	67	} else if (inputDim > 0 && (inputAxis > inputDim - 1 \|\| inputAxis < -inputDim)) {
	68	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "input dim(%d) out of range(%d,%d)", inputAxis, -inputDim, inputDim - 1);
	69	return false;
	70	}
	71	OP_CHECK_SHAPE_NOT_EQUAL(out, input, return false);
	72	return true;
	73	}
	74
	75	static aclnnStatus CheckParams(const aclTensor* input, const aclTensor* out, const aclScalar* inputDim,
	76	uint64_t* workspaceSize)
	77	{
	78	// 1. 检查参数是否为空指针
	79	CHECK_RET(CheckNotNull(input, inputDim, workspaceSize), ACLNN_ERR_PARAM_NULLPTR);
	80	// 2. 检查参数的数据类型是否符合预期
	81	CHECK_RET(CheckDtypeValid(input, out, inputDim), ACLNN_ERR_PARAM_INVALID);
	82	// 3. 检查输入tensor的shape
	83	CHECK_RET(CheckShape(input, out, inputDim), ACLNN_ERR_PARAM_INVALID);
	84	return ACLNN_SUCCESS;
	85	}
	86
	87	namespace {
	88	static const aclTensor* AdaptInputZeroDimTensor(const aclTensor* self, int64_t dimNum, aclOpExecutor* executor)
	89	{
	90	if (dimNum != 0) {
	91	return self;
	92	}
	93	int64_t selfShapeValue[1] = {1};
	94	aclIntArray* selfShape = executor->AllocIntArray(selfShapeValue, 1);
	95	auto selfReshape = l0op::Reshape(self, selfShape, executor);
	96	return selfReshape;
	97	}
	98	} // namespace
	99
	100	static aclnnStatus doGetWorkspaceSize(aclTensor* input, const aclScalar* inputDim, const aclDataType dtype,
	101	aclTensor* out, uint64_t* workspaceSize, aclOpExecutor** executor)
	102	{
	103	// 固定写法，创建OpExecutor
	104	auto uniqueExecutor = CREATE_EXECUTOR();
	105	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
	106	// 检查Format
	107	if (input->GetStorageFormat() != Format::FORMAT_ND) {
	108	OP_LOGW("Format only support ND");
	109	}
	110	// 参数检查
	111	auto ret = CheckParams(input, out, inputDim, workspaceSize);
	112	CHECK_RET(ret == ACLNN_SUCCESS, ret);
	113
	114	auto tensorType = op::ToOpDataType(dtype);
	115	if (tensorType == DataType::DT_UNDEFINED) {
	116	tensorType = out->GetDataType();
	117	}
	118	OP_CHECK_DTYPE_NOT_MATCH(out, tensorType, return false);
	119
	120	// 空tensor处理
	121	if (input->IsEmpty() \|\| out->IsEmpty()) {
	122	*workspaceSize = 0;
	123	uniqueExecutor.ReleaseTo(executor);
	124	return ACLNN_SUCCESS;
	125	}
	126
	127	auto inputContinuous = l0op::Contiguous(input, uniqueExecutor.get());
	128	CHECK_RET(inputContinuous != nullptr, ACLNN_ERR_INNER_NULLPTR);
	129
	130	int64_t dimNum = static_cast<int64_t>(inputContinuous->GetViewShape().GetDimNum());
	131	auto inputReshape = AdaptInputZeroDimTensor(inputContinuous, dimNum, uniqueExecutor.get());
	132	CHECK_RET(inputReshape != nullptr, ACLNN_ERR_INNER_NULLPTR);
	133
	134	if (input->GetDataType() != tensorType) {
	135	inputReshape = l0op::Cast(inputReshape, tensorType, uniqueExecutor.get());
	136	CHECK_RET(inputReshape != nullptr, ACLNN_ERR_INNER_NULLPTR);
	137	}
	138	// 执行L0算子
	139	auto cumprodResult = l0op::Cumprod(inputReshape, inputDim, false, false, uniqueExecutor.get());
	140	CHECK_RET(cumprodResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
	141
	142	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor
	143	auto result = l0op::ViewCopy(cumprodResult, out, uniqueExecutor.get());
	144	CHECK_RET(result != nullptr, ACLNN_ERR_INNER_NULLPTR);
	145	// 获取计算过程中需要使用的workspace大小
	146	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
	147	uniqueExecutor.ReleaseTo(executor);
	148	return ACLNN_SUCCESS;
	149	}
	150
	151	aclnnStatus aclnnCumprodGetWorkspaceSize(const aclTensor* input, const aclScalar* dim, const aclDataType dtype,
	152	aclTensor* out, uint64_t* workspaceSize, aclOpExecutor** executor)
	153	{
	154	L2_DFX_PHASE_1(aclnnCumprod, DFX_IN(input, dim, dtype), DFX_OUT(out));
	155	auto inputNonConst = const_cast<aclTensor*>(input);
	156	return doGetWorkspaceSize(inputNonConst, dim, dtype, out, workspaceSize, executor);
	157	}
	158
	159	aclnnStatus aclnnInplaceCumprodGetWorkspaceSize(aclTensor* input, const aclScalar* dim, uint64_t* workspaceSize,
	160	aclOpExecutor** executor)
	161	{
	162	L2_DFX_PHASE_1(aclnnInplaceCumprod, DFX_IN(input, dim), DFX_OUT(input));
	163	return doGetWorkspaceSize(input, dim, ToAclDataType(input->GetDataType()), input, workspaceSize, executor);
	164	}
	165	aclnnStatus aclnnCumprod(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
	166	{
	167	L2_DFX_PHASE_2(aclnnCumprod);
	168	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
	169	}
	170	aclnnStatus aclnnInplaceCumprod(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
	171	{
	172	L2_DFX_PHASE_2(aclnnInplaceCumprod);
	173	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
	174	}
	175	#ifdef __cplusplus
	176	}
	177	#endif

Rmath/cumprod/op_host/op_api/aclnn_cumprod.h→math/cumprod/op_api/aclnn_cumprod.h+16-12

	@@ -22,8 +22,9 @@ extern "C" {
22	* @brief aclnnCumprod的第一段接口，根据具体的计算流程，计算workspace大小。	22	* @brief aclnnCumprod的第一段接口，根据具体的计算流程，计算workspace大小。
23	* @domain aclnn_ops_train	23	* @domain aclnn_ops_train
24	* 算子功能：计算输入张量（Tensor）input沿着指定维度的累积乘积。它返回一个新的张量，其形状与输入张量相同	24	* 算子功能：计算输入张量（Tensor）input沿着指定维度的累积乘积。它返回一个新的张量，其形状与输入张量相同
25	* @param [in] input: device侧的aclTensor，表示要进行累积乘积运算的输入张量，数据类型支持DT_FLOAT32, DT_FLOAT16, DT_BFLOAT16, DT_DOUBLE,	25	* @param [in] input: device侧的aclTensor，表示要进行累积乘积运算的输入张量，数据类型支持DT_FLOAT32, DT_FLOAT16,
26	DT_INT8, DT_INT16, DT_INT32, DT_INT64, DT_UINT8, DT_UINT16, DT_UINT32, DT_UINT64, DT_COMPLEX128, DT_COMPLEX64	26	DT_BFLOAT16, DT_DOUBLE, DT_INT8, DT_INT16, DT_INT32, DT_INT64, DT_UINT8, DT_UINT16, DT_UINT32, DT_UINT64,
		27	DT_COMPLEX128, DT_COMPLEX64
27	* @param [in] dim: npu device侧的aclScalar，用于指定沿着哪个维度进行累积乘积运算,数据类型支持DT_INT32	28	* @param [in] dim: npu device侧的aclScalar，用于指定沿着哪个维度进行累积乘积运算,数据类型支持DT_INT32
28	* @param [in] dtype host侧的aclDataType，输出tensor的数据类型，需要与out数据类型一致	29	* @param [in] dtype host侧的aclDataType，输出tensor的数据类型，需要与out数据类型一致
29	* @param [in] out: 返回一个新的张量，其形状与输入张量相同,包含累积乘积。	30	* @param [in] out: 返回一个新的张量，其形状与输入张量相同,包含累积乘积。
	@@ -31,21 +32,24 @@ extern "C" {
31	* @param [out] executor: 返回op执行器，包含算子计算流程。	32	* @param [out] executor: 返回op执行器，包含算子计算流程。
32	* @return aclnnStatus: 返回状态码	33	* @return aclnnStatus: 返回状态码
33	*/	34	*/
34	ACLNN_API aclnnStatus aclnnCumprodGetWorkspaceSize(const aclTensor input, const aclScalar dim, const aclDataType dtype,	35	ACLNN_API aclnnStatus aclnnCumprodGetWorkspaceSize(const aclTensor* input, const aclScalar* dim,
35	aclTensor out, uint64_t workspaceSize, aclOpExecutor **executor);	36	const aclDataType dtype, aclTensor* out, uint64_t* workspaceSize,
		37	aclOpExecutor** executor);
36		38
37	/**	39	/**
38	* @brief aclnnCumprod的第一段接口，根据具体的计算流程，计算workspace大小。	40	* @brief aclnnCumprod的第一段接口，根据具体的计算流程，计算workspace大小。
39	* @domain aclnn_ops_train	41	* @domain aclnn_ops_train
40	* 算子功能：计算输入张量（Tensor）input沿着指定维度的累积乘积。它返回一个新的张量，其形状与输入张量相同	42	* 算子功能：计算输入张量（Tensor）input沿着指定维度的累积乘积。它返回一个新的张量，其形状与输入张量相同
41	* @param [in] input: device侧的aclTensor，表示要进行累积乘积运算的输入张量，数据类型支持DT_FLOAT32, DT_FLOAT16, DT_BFLOAT16, DT_DOUBLE,	43	* @param [in] input: device侧的aclTensor，表示要进行累积乘积运算的输入张量，数据类型支持DT_FLOAT32, DT_FLOAT16,
42	DT_INT8, DT_INT16, DT_INT32, DT_INT64, DT_UINT8, DT_UINT16, DT_UINT32, DT_UINT64, DT_COMPLEX128, DT_COMPLEX64	44	DT_BFLOAT16, DT_DOUBLE, DT_INT8, DT_INT16, DT_INT32, DT_INT64, DT_UINT8, DT_UINT16, DT_UINT32, DT_UINT64,
		45	DT_COMPLEX128, DT_COMPLEX64
43	* @param [in] dim: npu device侧的aclScalar，用于指定沿着哪个维度进行累积乘积运算,数据类型支持DT_INT32	46	* @param [in] dim: npu device侧的aclScalar，用于指定沿着哪个维度进行累积乘积运算,数据类型支持DT_INT32
44	* @param [out] workspaceSize: 返回用户需要在npu device侧申请的workspace大小。	47	* @param [out] workspaceSize: 返回用户需要在npu device侧申请的workspace大小。
45	* @param [out] executor: 返回op执行器，包含算子计算流程。	48	* @param [out] executor: 返回op执行器，包含算子计算流程。
46	* @return aclnnStatus: 返回状态码	49	* @return aclnnStatus: 返回状态码
47	*/	50	*/
48	ACLNN_API aclnnStatus aclnnInplaceCumprodGetWorkspaceSize(aclTensor input, const aclScalar dim, uint64_t workspaceSize, aclOpExecutor *executor);	51	ACLNN_API aclnnStatus aclnnInplaceCumprodGetWorkspaceSize(aclTensor* input, const aclScalar* dim,
		52	uint64_t* workspaceSize, aclOpExecutor** executor);
49		53
50	/**	54	/**
51	* @brief: aclnnCumprod的第二段接口，用于执行计算	55	* @brief: aclnnCumprod的第二段接口，用于执行计算
	@@ -58,8 +62,8 @@ ACLNN_API aclnnStatus aclnnInplaceCumprodGetWorkspaceSize(aclTensor *input, cons
58	* @param [in] executor: op执行器，包含了算子计算流程。	62	* @param [in] executor: op执行器，包含了算子计算流程。
59	* @return aclnnStatus: 返回状态码。	63	* @return aclnnStatus: 返回状态码。
60	*/	64	*/
61	ACLNN_API aclnnStatus aclnnCumprod(void workspace, uint64_t workspaceSize, aclOpExecutor executor,	65	ACLNN_API aclnnStatus aclnnCumprod(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor,
62	aclrtStream stream);	66	aclrtStream stream);
63		67
64	/**	68	/**
65	* @brief: aclnnCumprod的第二段接口，用于执行计算原地更新输入参数	69	* @brief: aclnnCumprod的第二段接口，用于执行计算原地更新输入参数
	@@ -72,10 +76,10 @@ ACLNN_API aclnnStatus aclnnCumprod(void *workspace, uint64_t workspaceSize, aclO
72	* @param [in] executor: op执行器，包含了算子计算流程。	76	* @param [in] executor: op执行器，包含了算子计算流程。
73	* @return aclnnStatus: 返回状态码。	77	* @return aclnnStatus: 返回状态码。
74	*/	78	*/
75	ACLNN_API aclnnStatus aclnnInplaceCumprod(void workspace, uint64_t workspaceSize, aclOpExecutor executor,	79	ACLNN_API aclnnStatus aclnnInplaceCumprod(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor,
76	aclrtStream stream);	80	aclrtStream stream);
77	#ifdef __cplusplus	81	#ifdef __cplusplus
78	}	82	}
79	#endif	83	#endif
80		84
81	#endif // OP_API_INC_LEVEL2_ACLNN_CUMPROD_H_	85	#endif // OP_API_INC_LEVEL2_ACLNN_CUMPROD_H_

Rmath/cumprod/op_host/op_api/cumprod.cpp→math/cumprod/op_api/cumprod.cpp+16-18

	@@ -17,22 +17,20 @@ using namespace op;
17	namespace l0op {	17	namespace l0op {
18	OP_TYPE_REGISTER(Cumprod);	18	OP_TYPE_REGISTER(Cumprod);
19		19
20	const aclTensor* Cumprod(const aclTensor x, const aclScalar axis, bool exclusive, bool reverse,	20	const aclTensor* Cumprod(const aclTensor* x, const aclScalar* axis, bool exclusive, bool reverse,
21	aclOpExecutor *executor) {	21	aclOpExecutor* executor)
22	auto out = executor->AllocTensor(x->GetViewShape(), x->GetDataType(), Format::FORMAT_ND);	22	{
23	if (out == nullptr) {	23	auto out = executor->AllocTensor(x->GetViewShape(), x->GetDataType(), Format::FORMAT_ND);
24	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "alloc out tensor allocation failed.");	24	if (out == nullptr) {
25	return nullptr;	25	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "alloc out tensor allocation failed.");
26	}	26	return nullptr;
27	L0_DFX(Cumprod, x, axis, exclusive, reverse, out);	27	}
28	static internal::AicpuTaskSpace space("Cumprod", ge::DEPEND_IN_SHAPE, true);	28	L0_DFX(Cumprod, x, axis, exclusive, reverse, out);
29	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(Cumprod,	29	static internal::AicpuTaskSpace space("Cumprod", ge::DEPEND_IN_SHAPE, true);
30	OP_ATTR_NAMES({"exclusive", "reverse", "Tidx"}),	30	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(Cumprod, OP_ATTR_NAMES({"exclusive", "reverse", "Tidx"}), OP_INPUT(x, axis),
31	OP_INPUT(x, axis),	31	OP_OUTPUT(out), OP_ATTR(exclusive, reverse, ge::DataType::DT_INT32));
32	OP_OUTPUT(out),	32	OP_LOGI("cumprod ret:%d, out:%p\n", ret, out);
33	OP_ATTR(exclusive, reverse, ge::DataType::DT_INT32));	33	CHECK_RET(ret == ACLNN_SUCCESS, nullptr);
34	OP_LOGI("cumprod ret:%d, out:%p\n", ret, out);	34	return out;
35	CHECK_RET(ret == ACLNN_SUCCESS, nullptr);
36	return out;
37	}	35	}
38	} // namespace l0op	36	} // namespace l0op

Rmath/cumprod/op_host/op_api/cumprod.h→math/cumprod/op_api/cumprod.h+2-3

	@@ -14,9 +14,8 @@
14	#include "opdev/op_executor.h"	14	#include "opdev/op_executor.h"
15		15
16	namespace l0op {	16	namespace l0op {
17	const aclTensor Cumprod(const aclTensor x, const aclScalar *axis,	17	const aclTensor* Cumprod(const aclTensor* x, const aclScalar* axis, bool exclusive, bool reverse,
18	bool exclusive, bool reverse, aclOpExecutor *executor);	18	aclOpExecutor* executor);
19	} // namespace l0op	19	} // namespace l0op
20		20
21	#endif // OP_API_INC_LEVEL0_CUMPROD_H_	21	#endif // OP_API_INC_LEVEL0_CUMPROD_H_
22

Dmath/cumprod/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources(OPTYPE cumprod ACLNNTYPE aclnn_exclude)

Dmath/cumprod/op_host/op_api/aclnn_cumprod.cpp+0-162

	@@ -1,162 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10
11	#include "aclnn_cumprod.h"
12	#include "cumprod.h"
13	#include "aclnn_kernels/common/op_error_check.h"
14	#include "aclnn_kernels/contiguous.h"
15	#include "op_api/op_api_def.h"
16	#include "aclnn_kernels/cast.h"
17	#include "opdev/make_op_executor.h"
18	#include "opdev/platform.h"
19	#include "opdev/op_dfx.h"
20	#include "opdev/op_executor.h"
21	#include "aclnn_kernels/reshape.h"
22
23	using namespace op;
24	namespace {
25	static const std::initializer_list<DataType> DTYPE_SUPPORT_LIST = {DataType::DT_FLOAT, DataType::DT_FLOAT16,DataType::DT_BF16,DataType::DT_DOUBLE,DataType::DT_INT8,DataType::DT_INT16,DataType::DT_INT32,DataType::DT_INT64,DataType::DT_UINT8,DataType::DT_UINT16,DataType::DT_UINT32,DataType::DT_UINT64};
26
27	static const std::initializer_list<DataType> DTYPE_SUPPORT_LIST_INT = {DataType::DT_INT32,DataType::DT_INT64};
28	}
29	#ifdef __cplusplus
30	extern "C" {
31	#endif
32
33	static constexpr int INDEX_0 = 0;
34	static constexpr int DIM_NUM_0 = 0;
35	static constexpr int DIM_NUM_1 = 1;
36	static constexpr size_t SFDA_DIM0_SIZE = 3;
37
38	static inline bool CheckNotNull(const aclTensor input, const aclScalar inputDim, const uint64_t *workspaceSize) {
39	OP_CHECK_NULL(input, return false);
40	OP_CHECK_NULL(inputDim, return false);
41	if (workspaceSize == nullptr) {
42	return false;
43	}
44	return true;
45	}
46
47	static inline bool CheckDtypeValid(const aclTensor input, const aclTensor out, const aclScalar *inputDim) {
48	OP_CHECK_DTYPE_NOT_SUPPORT(input, DTYPE_SUPPORT_LIST, return false);
49	OP_CHECK_DTYPE_NOT_SUPPORT(out, DTYPE_SUPPORT_LIST, return false);
50	OP_CHECK_DTYPE_NOT_SUPPORT(inputDim, DTYPE_SUPPORT_LIST_INT, return false);
51	return true;
52	}
53
54	static inline bool CheckShape(const aclTensor input, const aclTensor out, const aclScalar *axis) {
55	int32_t inputDim = input->GetViewShape().GetDimNum();
56	int32_t inputAxis = axis->ToInt32();
57	if (inputDim == 0 && inputAxis != 0 && inputAxis != -1) {
58	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dimension out of range (expected to be in range of [-1, 0], but got %d)", inputAxis);
59	return false;
60	} else if(inputDim > 0 && (inputAxis > inputDim - 1 \|\| inputAxis < -inputDim)) {
61	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "input dim(%d) out of range(%d,%d)", inputAxis, -inputDim, inputDim - 1);
62	return false;
63	}
64	OP_CHECK_SHAPE_NOT_EQUAL(out,input,return false);
65	return true;
66	}
67
68	static aclnnStatus CheckParams(const aclTensor input, const aclTensor out, const aclScalar inputDim, uint64_t workspaceSize) {
69	// 1. 检查参数是否为空指针
70	CHECK_RET(CheckNotNull(input, inputDim, workspaceSize), ACLNN_ERR_PARAM_NULLPTR);
71	// 2. 检查参数的数据类型是否符合预期
72	CHECK_RET(CheckDtypeValid(input, out, inputDim), ACLNN_ERR_PARAM_INVALID);
73	// 3. 检查输入tensor的shape
74	CHECK_RET(CheckShape(input, out, inputDim), ACLNN_ERR_PARAM_INVALID);
75	return ACLNN_SUCCESS;
76	}
77
78	namespace {
79	static const aclTensor AdaptInputZeroDimTensor(const aclTensor self, int64_t dimNum, aclOpExecutor *executor) {
80	if (dimNum != 0) {
81	return self;
82	}
83	int64_t selfShapeValue[1] = {1};
84	aclIntArray *selfShape = executor->AllocIntArray(selfShapeValue, 1);
85	auto selfReshape = l0op::Reshape(self, selfShape, executor);
86	return selfReshape;
87	}
88	}
89
90	static aclnnStatus doGetWorkspaceSize(aclTensor input, const aclScalar inputDim, const aclDataType dtype, aclTensor *out,
91	uint64_t workspaceSize, aclOpExecutor *executor) {
92	// 固定写法，创建OpExecutor
93	auto uniqueExecutor = CREATE_EXECUTOR();
94	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
95	// 检查Format
96	if(input->GetStorageFormat() != Format::FORMAT_ND){
97	OP_LOGW("Format only support ND");
98	}
99	// 参数检查
100	auto ret = CheckParams(input, out, inputDim, workspaceSize);
101	CHECK_RET(ret == ACLNN_SUCCESS, ret);
102
103	auto tensorType = op::ToOpDataType(dtype);
104	if(tensorType == DataType::DT_UNDEFINED){
105	tensorType = out->GetDataType();
106	}
107	OP_CHECK_DTYPE_NOT_MATCH(out, tensorType, return false);
108
109	// 空tensor处理
110	if (input->IsEmpty() \|\| out->IsEmpty()) {
111	*workspaceSize = 0;
112	uniqueExecutor.ReleaseTo(executor);
113	return ACLNN_SUCCESS;
114	}
115
116	auto inputContinuous = l0op::Contiguous(input, uniqueExecutor.get());
117	CHECK_RET(inputContinuous != nullptr, ACLNN_ERR_INNER_NULLPTR);
118
119	int64_t dimNum = static_cast<int64_t>(inputContinuous->GetViewShape().GetDimNum());
120	auto inputReshape = AdaptInputZeroDimTensor(inputContinuous, dimNum, uniqueExecutor.get());
121	CHECK_RET(inputReshape != nullptr, ACLNN_ERR_INNER_NULLPTR);
122
123	if(input->GetDataType() != tensorType){
124	inputReshape = l0op::Cast(inputReshape, tensorType, uniqueExecutor.get());
125	CHECK_RET(inputReshape != nullptr, ACLNN_ERR_INNER_NULLPTR);
126	}
127	// 执行L0算子
128	auto cumprodResult = l0op::Cumprod(inputReshape, inputDim, false, false, uniqueExecutor.get());
129	CHECK_RET(cumprodResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
130
131	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor
132	auto result = l0op::ViewCopy(cumprodResult, out, uniqueExecutor.get());
133	CHECK_RET(result != nullptr, ACLNN_ERR_INNER_NULLPTR);
134	// 获取计算过程中需要使用的workspace大小
135	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
136	uniqueExecutor.ReleaseTo(executor);
137	return ACLNN_SUCCESS;
138	}
139
140	aclnnStatus aclnnCumprodGetWorkspaceSize(const aclTensor input, const aclScalar dim, const aclDataType dtype,
141	aclTensor out, uint64_t workspaceSize, aclOpExecutor **executor) {
142	L2_DFX_PHASE_1(aclnnCumprod, DFX_IN(input, dim, dtype), DFX_OUT(out));
143	auto inputNonConst = const_cast<aclTensor*>(input);
144	return doGetWorkspaceSize(inputNonConst, dim, dtype, out, workspaceSize, executor);
145	}
146
147	aclnnStatus aclnnInplaceCumprodGetWorkspaceSize(aclTensor input, const aclScalar dim, uint64_t *workspaceSize,
148	aclOpExecutor **executor) {
149	L2_DFX_PHASE_1(aclnnInplaceCumprod, DFX_IN(input, dim), DFX_OUT(input));
150	return doGetWorkspaceSize(input, dim, ToAclDataType(input->GetDataType()), input, workspaceSize, executor);
151	}
152	aclnnStatus aclnnCumprod(void workspace, uint64_t workspaceSize, aclOpExecutor executor, aclrtStream stream) {
153	L2_DFX_PHASE_2(aclnnCumprod);
154	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
155	}
156	aclnnStatus aclnnInplaceCumprod(void workspace, uint64_t workspaceSize, aclOpExecutor executor, aclrtStream stream) {
157	L2_DFX_PHASE_2(aclnnInplaceCumprod);
158	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
159	}
160	#ifdef __cplusplus
161	}
162	#endif

Dmath/cumprod/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/cumprod/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/cumprod/tests/ut/op_host/CMakeLists.txt+0-20

	@@ -1,20 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()
18
19	if(OP_API_UT OR (UT_TEST_ALL AND NOT AICPU_ONLY))
20	endif()

Dmath/cumprod/tests/ut/op_host/op_api/CMakeLists.txt+0-10

	@@ -1,10 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------

Mmath/histogram_v2/CMakeLists.txt+3-11

	@@ -3,17 +3,9 @@
3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	# CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
7	# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
10		10
11	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE histogram_v2 ACLNNTYPE aclnn_exclude)
12	if(NOT ENABLE_TEST)
13	list(REMOVE_ITEM CURRENT_DIRS tests)
14	endif()
15	foreach(SUB_DIR ${CURRENT_DIRS})
16	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
17	add_subdirectory(${SUB_DIR})
18	endif()
19	endforeach()

Rmath/histogram_v2/op_host/op_api/aclnn_histc.cpp→math/histogram_v2/op_api/aclnn_histc.cpp+13-14

	@@ -16,9 +16,9 @@
16	#include "aclnn_kernels/contiguous.h"	16	#include "aclnn_kernels/contiguous.h"
17	#include "aclnn_histc.h"	17	#include "aclnn_histc.h"
18	#include "histogram.h"	18	#include "histogram.h"
19	#include "../../../zero_op/op_api/zero_op.h"	19	#include "../../zero_op/op_api/zero_op.h"
20	#include "../../../reduce_min/op_api/reduce_min.h"	20	#include "../../reduce_min/op_api/reduce_min.h"
21	#include "../../../reduce_max/op_api/reduce_max.h"	21	#include "../../reduce_max/op_api/reduce_max.h"
22	#include "aclnn/aclnn_base.h"	22	#include "aclnn/aclnn_base.h"
23	#include "aclnn_kernels/common/op_error_check.h"	23	#include "aclnn_kernels/common/op_error_check.h"
24	#include "opdev/common_types.h"	24	#include "opdev/common_types.h"
	@@ -78,9 +78,8 @@ static bool CheckDtypeValid(const aclTensor* self, const aclTensor* out)
78	static bool CheckPromoteType(const aclTensor* self, const aclTensor* out, op::DataType promoteType)	78	static bool CheckPromoteType(const aclTensor* self, const aclTensor* out, op::DataType promoteType)
79	{	79	{
80	if (promoteType == DataType::DT_UNDEFINED) {	80	if (promoteType == DataType::DT_UNDEFINED) {
81	OP_LOGE(	81	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Self dtype %s can not cast to promote dtype %s.",
82	ACLNN_ERR_PARAM_INVALID, "Self dtype %s can not cast to promote dtype %s.",	82	op::ToString(self->GetDataType()).GetString(), op::ToString(DataType::DT_UNDEFINED).GetString());
83	op::ToString(self->GetDataType()).GetString(), op::ToString(DataType::DT_UNDEFINED).GetString());
84	return false;	83	return false;
85	}	84	}
86		85
	@@ -201,8 +200,8 @@ static std::tuple<const aclTensor, const aclTensor> AllMinMax(const aclTensor*
201	return std::tuple<const aclTensor, const aclTensor>(min, max);	200	return std::tuple<const aclTensor, const aclTensor>(min, max);
202	}	201	}
203		202
204	static aclnnStatus CheckHistcParams(	203	static aclnnStatus CheckHistcParams(const aclTensor* self, int64_t bins, const aclScalar* min, const aclScalar* max,
205	const aclTensor* self, int64_t bins, const aclScalar* min, const aclScalar* max, aclTensor* out)	204	aclTensor* out)
206	{	205	{
207	// 检查参数是否为空指针	206	// 检查参数是否为空指针
208	CHECK_RET(CheckNotNull(self, min, max, out), ACLNN_ERR_PARAM_NULLPTR);	207	CHECK_RET(CheckNotNull(self, min, max, out), ACLNN_ERR_PARAM_NULLPTR);
	@@ -239,16 +238,16 @@ static aclnnStatus EmptyTensor(aclTensor* out, aclOpExecutor* executor)
239	return ACLNN_SUCCESS;	238	return ACLNN_SUCCESS;
240	}	239	}
241		240
242	static void CheckFormat(const aclTensor* self) {	241	static void CheckFormat(const aclTensor* self)
		242	{
243	ge::Format selfStorageFormat = self->GetStorageFormat();	243	ge::Format selfStorageFormat = self->GetStorageFormat();
244	if (selfStorageFormat == ge::Format::FORMAT_FRACTAL_NZ) {	244	if (selfStorageFormat == ge::Format::FORMAT_FRACTAL_NZ) {
245	OP_LOGW("aclnnHistc doesn't support format NZ.");	245	OP_LOGW("aclnnHistc doesn't support format NZ.");
246	}	246	}
247	}	247	}
248		248
249	aclnnStatus aclnnHistcGetWorkspaceSize(	249	aclnnStatus aclnnHistcGetWorkspaceSize(const aclTensor* self, int64_t bins, const aclScalar* min, const aclScalar* max,
250	const aclTensor* self, int64_t bins, const aclScalar* min, const aclScalar* max, aclTensor* out,	250	aclTensor* out, uint64_t* workspaceSize, aclOpExecutor** executor)
251	uint64_t* workspaceSize, aclOpExecutor** executor)
252	{	251	{
253	OP_CHECK_COMM_INPUT(workspaceSize, executor);	252	OP_CHECK_COMM_INPUT(workspaceSize, executor);
254		253
	@@ -294,8 +293,8 @@ aclnnStatus aclnnHistcGetWorkspaceSize(
294	float maxValue = max->ToFloat();	293	float maxValue = max->ToFloat();
295		294
296	// 调用Histogram算子kernel	295	// 调用Histogram算子kernel
297	auto HistogramCal =	296	auto HistogramCal = l0op::Histogram(selfContiguous, minTensor, maxTensor, out, bins, minValue, maxValue,
298	l0op::Histogram(selfContiguous, minTensor, maxTensor, out, bins, minValue, maxValue, uniqueExecutor.get());	297	uniqueExecutor.get());
299	CHECK_RET(HistogramCal != nullptr, ACLNN_ERR_INNER_NULLPTR);	298	CHECK_RET(HistogramCal != nullptr, ACLNN_ERR_INNER_NULLPTR);
300		299
301	// 将计算结果转换成输出out的数据类型	300	// 将计算结果转换成输出out的数据类型

Rmath/histogram_v2/op_host/op_api/aclnn_histc.h→math/histogram_v2/op_api/aclnn_histc.h+7-5

	@@ -20,18 +20,20 @@ extern "C" {
20	/**	20	/**
21	* @brief aclnnHistc的第一段接口，根据具体的计算流程，计算workspace大小。	21	* @brief aclnnHistc的第一段接口，根据具体的计算流程，计算workspace大小。
22	* @domain aclnn_ops_infer	22	* @domain aclnn_ops_infer
23	* @param [in] self: npu device侧的aclTensor，数据类型支持FLOAT16、FLOAT32、INT32、INT64、INT16、INT8、UINT8。支持非连续的Tensor，数据格式支持ND	23	* @param [in] self: npu
		24	* device侧的aclTensor，数据类型支持FLOAT16、FLOAT32、INT32、INT64、INT16、INT8、UINT8。支持非连续的Tensor，数据格式支持ND
24	* @param [in] bins: 直方图bins的数量，数据类型INT64	25	* @param [in] bins: 直方图bins的数量，数据类型INT64
25	* @param [in] min: 直方图统计下限（包括），host侧的aclScalar，数据类型需要可转换成FLOAT的数据类型。	26	* @param [in] min: 直方图统计下限（包括），host侧的aclScalar，数据类型需要可转换成FLOAT的数据类型。
26	* @param [in] max: 直方图统计上限（包括），host侧的aclScalar，数据类型需要可转换成FLOAT的数据类型。	27	* @param [in] max: 直方图统计上限（包括），host侧的aclScalar，数据类型需要可转换成FLOAT的数据类型。
27	* @param [in] out: npu device侧的aclTensor，数据类型支持FLOAT16、FLOAT32、INT32、INT64、INT16、INT8、UINT8。且数据类型是self可转化的数据类型。数据格式支持ND	28	* @param [in] out: npu
		29	* device侧的aclTensor，数据类型支持FLOAT16、FLOAT32、INT32、INT64、INT16、INT8、UINT8。且数据类型是self可转化的数据类型。数据格式支持ND
28	* @param [out] workspaceSize: 返回用户需要在npu device侧申请的workspace大小。	30	* @param [out] workspaceSize: 返回用户需要在npu device侧申请的workspace大小。
29	* @param [out] executor: 返回op执行器，包含算子计算流程。	31	* @param [out] executor: 返回op执行器，包含算子计算流程。
30	* @return aclnnStatus: 返回状态码。	32	* @return aclnnStatus: 返回状态码。
31	*/	33	*/
32	ACLNN_API aclnnStatus aclnnHistcGetWorkspaceSize(	34	ACLNN_API aclnnStatus aclnnHistcGetWorkspaceSize(const aclTensor* self, int64_t bins, const aclScalar* min,
33	const aclTensor* self, int64_t bins, const aclScalar* min, const aclScalar* max, aclTensor* out,	35	const aclScalar* max, aclTensor* out, uint64_t* workspaceSize,
34	uint64_t* workspaceSize, aclOpExecutor** executor);	36	aclOpExecutor** executor);
35		37
36	/**	38	/**
37	* @brief aclnnHistc的第二段接口，用于执行计算。	39	* @brief aclnnHistc的第二段接口，用于执行计算。

Rmath/histogram_v2/op_host/op_api/histogram.cpp→math/histogram_v2/op_api/histogram.cpp+18-21

	@@ -52,46 +52,43 @@ static bool IsAiCoreSupport(const aclTensor* self, const aclTensor* out)
52	}	52	}
53		53
54	// AiCore的执行逻辑	54	// AiCore的执行逻辑
55	inline const aclTensor* HistogramAiCore(	55	inline const aclTensor* HistogramAiCore(const aclTensor* self, const aclTensor* min, const aclTensor* max,
56	const aclTensor* self, const aclTensor* min, const aclTensor* max, const aclTensor* out, int64_t bins,	56	const aclTensor* out, int64_t bins, aclOpExecutor* executor)
57	aclOpExecutor* executor)
58	{	57	{
59	L0_DFX(HistogramAiCore, self, min, max, out, bins);	58	L0_DFX(HistogramAiCore, self, min, max, out, bins);
60	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(	59	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(HistogramV2, OP_INPUT(self, min, max), OP_OUTPUT(out), OP_ATTR(bins));
61	HistogramV2, OP_INPUT(self, min, max), OP_OUTPUT(out), OP_ATTR(bins));	60	OP_CHECK(ret == ACLNN_SUCCESS,
62	OP_CHECK(	61	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "HistogramAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."), return nullptr);
63	ret == ACLNN_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "HistogramAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."),
64	return nullptr);
65	return out;	62	return out;
66	}	63	}
67		64
68	// AiCPU的执行逻辑	65	// AiCPU的执行逻辑
69	inline const aclTensor* HistogramAiCPU(	66	inline const aclTensor* HistogramAiCPU(const aclTensor* self, const aclTensor* out, int64_t bins, float min, float max,
70	const aclTensor* self, const aclTensor* out, int64_t bins, float min, float max, aclOpExecutor* executor)	67	aclOpExecutor* executor)
71	{	68	{
72	L0_DFX(HistogramAiCPU, self, bins, min, max, out);	69	L0_DFX(HistogramAiCPU, self, bins, min, max, out);
73	auto desDtype = (self->GetDataType() == op::DataType::DT_FLOAT16) ? op::DataType::DT_FLOAT : self->GetDataType();	70	auto desDtype = (self->GetDataType() == op::DataType::DT_FLOAT16) ? op::DataType::DT_FLOAT : self->GetDataType();
74	auto histogramOut = executor->AllocTensor(out->GetViewShape(), desDtype);	71	auto histogramOut = executor->AllocTensor(out->GetViewShape(), desDtype);
75		72
76	static internal::AicpuTaskSpace space("Histogram");	73	static internal::AicpuTaskSpace space("Histogram");
77	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(	74	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(Histogram, OP_ATTR_NAMES({"bins", "min", "max"}), OP_INPUT(self),
78	Histogram, OP_ATTR_NAMES({"bins", "min", "max"}), OP_INPUT(self), OP_OUTPUT(histogramOut),	75	OP_OUTPUT(histogramOut), OP_ATTR(bins, min, max));
79	OP_ATTR(bins, min, max));	76	OP_CHECK(ret == ACLNN_SUCCESS,
80	OP_CHECK(	77	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "HistogramAiCPU ADD_TO_LAUNCHER_LIST_AICPU failed."), return nullptr);
81	ret == ACLNN_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "HistogramAiCPU ADD_TO_LAUNCHER_LIST_AICPU failed."),
82	return nullptr);
83	return histogramOut;	78	return histogramOut;
84	}	79	}
85		80
86	const aclTensor* Histogram(	81	const aclTensor* Histogram(const aclTensor* self, const aclTensor* min, const aclTensor* max, const aclTensor* out,
87	const aclTensor* self, const aclTensor* min, const aclTensor* max, const aclTensor* out, int64_t bins,	82	int64_t bins, float minValue, float maxValue, aclOpExecutor* executor)
88	float minValue, float maxValue, aclOpExecutor* executor)
89	{	83	{
90	if (IsAiCoreSupport(self, out)) {	84	if (IsAiCoreSupport(self, out)) {
91	auto npuArch = op::GetCurrentPlatformInfo().GetCurNpuArch();	85	auto npuArch = op::GetCurrentPlatformInfo().GetCurNpuArch();
92	// 当前950支持输出int32和f32，其他芯片只支持int32	86	// 当前950支持输出int32和f32，其他芯片只支持int32
93	auto desDtype = ((out->GetDataType() == op::DataType::DT_FLOAT16 \|\| out->GetDataType() == op::DataType::DT_FLOAT) && IsRegBase(npuArch))	87	auto desDtype = ((out->GetDataType() == op::DataType::DT_FLOAT16 \|\|
94	? op::DataType::DT_FLOAT : op::DataType::DT_INT32;	88	out->GetDataType() == op::DataType::DT_FLOAT) &&
		89	IsRegBase(npuArch)) ?
		90	op::DataType::DT_FLOAT :
		91	op::DataType::DT_INT32;
95	auto outAiCore = executor->AllocTensor(out->GetViewShape(), desDtype);	92	auto outAiCore = executor->AllocTensor(out->GetViewShape(), desDtype);
96	return HistogramAiCore(self, min, max, outAiCore, bins, executor);	93	return HistogramAiCore(self, min, max, outAiCore, bins, executor);
97	} else {	94	} else {

Rmath/histogram_v2/op_host/op_api/histogram.h→math/histogram_v2/op_api/histogram.h+2-3

	@@ -13,8 +13,7 @@
13	#include "opdev/op_executor.h"	13	#include "opdev/op_executor.h"
14		14
15	namespace l0op {	15	namespace l0op {
16	const aclTensor* Histogram(	16	const aclTensor* Histogram(const aclTensor* self, const aclTensor* min, const aclTensor* max, const aclTensor* out,
17	const aclTensor* self, const aclTensor* min, const aclTensor* max, const aclTensor* out, int64_t bins,	17	int64_t bins, float minValue, float maxValue, aclOpExecutor* executor);
18	float minValue, float maxValue, aclOpExecutor* executor);
19	}	18	}
20	#endif // OP_API_INC_LEVEL0_OP_HISTOGRAM_OP_H_	19	#endif // OP_API_INC_LEVEL0_OP_HISTOGRAM_OP_H_

Dmath/histogram_v2/op_host/CMakeLists.txt+0-11

	@@ -1,11 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# Copyright (c) 2025-2026 Huawei Technologies Co., Ltd.
3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	# CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------
10
11	add_modules_sources(OPTYPE histogram_v2 ACLNNTYPE aclnn_exclude)

Dmath/histogram_v2/tests/CMakeLists.txt+0-16

	@@ -1,16 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# Copyright (c) 2025-2026 Huawei Technologies Co., Ltd.
3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	# CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------
10
11	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
12	foreach(SUB_DIR ${CURRENT_DIRS})
13	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
14	add_subdirectory(${SUB_DIR})
15	endif()
16	endforeach()

Dmath/histogram_v2/tests/ut/CMakeLists.txt+0-16

	@@ -1,16 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# Copyright (c) 2025-2026 Huawei Technologies Co., Ltd.
3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	# CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------
10
11	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
12	foreach(SUB_DIR ${CURRENT_DIRS})
13	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
14	add_subdirectory(${SUB_DIR})
15	endif()
16	endforeach()

Dmath/histogram_v2/tests/ut/op_api/CMakeLists.txt+0-13

	@@ -1,13 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# Copyright (c) 2025-2026 Huawei Technologies Co., Ltd.
3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	# CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------
10
11	if(UT_TEST_ALL OR OP_API_UT)
12	add_modules_ut_sources(UT_NAME ${OP_API_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
13	endif()

Mmath/histogram_v2/tests/ut/op_api/test_aclnn_histc.cpp+1-1

	@@ -13,7 +13,7 @@
13	#include <limits>	13	#include <limits>
14	#include "gtest/gtest.h"	14	#include "gtest/gtest.h"
15		15
16	#include "../../../op_host/op_api/aclnn_histc.h"	16	#include "../../../op_api/aclnn_histc.h"
17		17
18	#include "op_api_ut_common/op_api_ut.h"	18	#include "op_api_ut_common/op_api_ut.h"
19	#include "op_api_ut_common/scalar_desc.h"	19	#include "op_api_ut_common/scalar_desc.h"

Dmath/histogram_v2/tests/ut/op_host/CMakeLists.txt+0-35

	@@ -1,35 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# Copyright (c) 2025-2026 Huawei Technologies Co., Ltd.
3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	# CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------
10
11	if(UT_TEST_ALL OR OP_HOST_UT)
12	# HistogramV2 has two tiling templates selected at runtime by SoC (IsRegbaseSocVersion):
13	# RegBase (ascend950) -> arch35 (HistogramV2SimtTiling)
14	# non-RegBase (ascend310p/910_93/910b) -> arch32 (HistogramV2MembaseTiling)
15	# Both arch UTs are compiled unconditionally: each test case fakes the SoC it needs via
16	# TilingContextPara::socVersion_ (arch35 -> "ascend950", arch32 -> "ascend910b"), so a single
17	# build (any BUILD_SOC_VERSION) exercises BOTH templates and covers both tiling sources.
18	add_modules_ut_sources(UT_NAME ${OP_TILING_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR} TILING_DIR arch35)
19	add_modules_ut_sources(UT_NAME ${OP_TILING_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR} TILING_DIR arch32)
20	add_modules_ut_sources(UT_NAME ${OP_INFERSHAPE_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
21	# histogram_v2_tiling_ut_util.h fetches/runs tiling via the op-impl space registry (to fake the
22	# SoC per case). That header lives under ${ASCEND_DIR}/pkg_inc, which the shared tiling common
23	# obj already includes but the cases obj does not — add it here just for this op's cases obj.
24	# The registry symbols themselves come from libs the UT already links.
25	if(TARGET ${OP_TILING_MODULE_NAME}_cases_obj)
26	target_include_directories(${OP_TILING_MODULE_NAME}_cases_obj PRIVATE ${ASCEND_DIR}/pkg_inc)
27	endif()
28	endif()
29
30	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
31	foreach(SUB_DIR ${CURRENT_DIRS})
32	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
33	add_subdirectory(${SUB_DIR})
34	endif()
35	endforeach()

Mmath/lin_space/CMakeLists.txt+6-20

	@@ -1,32 +1,18 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
		7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
10		10
11	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE lin_space ACLNNTYPE aclnn_exclude)
12	if(NOT ENABLE_TEST)
13	list(REMOVE_ITEM CURRENT_DIRS tests)
14	endif()
15	foreach(SUB_DIR ${CURRENT_DIRS})
16	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
17	if(DISABLE_AICPU)
18	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/op_kernel_aicpu" AND IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/op_kernel_aicpu")
19	MESSAGE(STATUS "disable aicpu kernel lin_space, skip it.")
20	continue()
21	endif()
22	endif()
23	add_subdirectory(${SUB_DIR})
24	endif()
25	endforeach()
26		12
27	if(ENABLE_TEST AND (UT_TEST_ALL OR OP_KERNEL_AICPU_UT))	13	if(ENABLE_TEST AND (UT_TEST_ALL OR OP_KERNEL_AICPU_UT))
28	list(FIND ASCEND_OP_NAME lin_space LIN_SPACE_INDEX)	14	list(FIND ASCEND_OP_NAME lin_space LIN_SPACE_INDEX)
29	if("${ASCEND_OP_NAME}" STREQUAL "" OR NOT LIN_SPACE_INDEX EQUAL -1)	15	if("${ASCEND_OP_NAME}" STREQUAL "" OR NOT LIN_SPACE_INDEX EQUAL -1)
30	add_aicpu_op_test_case(lin_space)	16	add_aicpu_op_test_case(lin_space)
31	endif()	17	endif()
32	endif()	18	endif()

Rmath/lin_space/op_host/op_api/aclnn_linspace.cpp→math/lin_space/op_api/aclnn_linspace.cpp+53-49

	@@ -45,39 +45,39 @@ extern "C" {
45		45
46	// 算子支持的所有dtype	46	// 算子支持的所有dtype
47	static const std::initializer_list<op::DataType> ASCEND910_DTYPE_SUPPORT_LIST = {	47	static const std::initializer_list<op::DataType> ASCEND910_DTYPE_SUPPORT_LIST = {
48	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16,	48	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_INT32, op::DataType::DT_INT8,
49	op::DataType::DT_INT32, op::DataType::DT_INT8,	49	op::DataType::DT_UINT8,
50	op::DataType::DT_UINT8,	50	// AiCpu支持数据类型
51	// AiCpu支持数据类型	51	op::DataType::DT_DOUBLE};
52	op::DataType::DT_DOUBLE};
53		52
54	static const std::initializer_list<op::DataType> ASCEND910B_DTYPE_SUPPORT_LIST = {	53	static const std::initializer_list<op::DataType> ASCEND910B_DTYPE_SUPPORT_LIST = {
55	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16,	54	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16, op::DataType::DT_INT32,
56	op::DataType::DT_INT32, op::DataType::DT_INT16, op::DataType::DT_INT8,	55	op::DataType::DT_INT16, op::DataType::DT_INT8, op::DataType::DT_UINT8, op::DataType::DT_INT64,
57	op::DataType::DT_UINT8, op::DataType::DT_INT64,	56	// AiCpu支持数据类型
58	// AiCpu支持数据类型	57	op::DataType::DT_DOUBLE};
59	op::DataType::DT_DOUBLE};
60		58
61	static const inline std::initializer_list<DataType>& GetSupportDtypeList(NpuArch npuArch) {	59	static const inline std::initializer_list<DataType>& GetSupportDtypeList(NpuArch npuArch)
62	static const std::initializer_list<DataType> emptyDtypes = {};	60	{
63	if (npuArch == NpuArch::DAV_2201 \|\| IsRegBase(npuArch)) {	61	static const std::initializer_list<DataType> emptyDtypes = {};
64	return ASCEND910B_DTYPE_SUPPORT_LIST;	62	if (npuArch == NpuArch::DAV_2201 \|\| IsRegBase(npuArch)) {
65	}	63	return ASCEND910B_DTYPE_SUPPORT_LIST;
66	if (npuArch == NpuArch::DAV_1001 \|\| npuArch == NpuArch::DAV_2002) {	64	}
67	return ASCEND910_DTYPE_SUPPORT_LIST;	65	if (npuArch == NpuArch::DAV_1001 \|\| npuArch == NpuArch::DAV_2002) {
68	}	66	return ASCEND910_DTYPE_SUPPORT_LIST;
69	return emptyDtypes;	67	}
		68	return emptyDtypes;
70	}	69	}
71		70
72	// 检查输入是否是空指针	71	// 检查输入是否是空指针
73	inline static bool CheckNotNull(const aclScalar start, const aclScalar end, const aclTensor *out) {	72	inline static bool CheckNotNull(const aclScalar* start, const aclScalar* end, const aclTensor* out)
74	OP_CHECK_NULL(start, return false);	73	{
75	OP_CHECK_NULL(end, return false);	74	OP_CHECK_NULL(start, return false);
76	OP_CHECK_NULL(out, return false);	75	OP_CHECK_NULL(end, return false);
77	return true;	76	OP_CHECK_NULL(out, return false);
		77	return true;
78	}	78	}
79		79
80	inline static bool CheckDtypeValid(const aclTensor *out)	80	inline static bool CheckDtypeValid(const aclTensor* out)
81	{	81	{
82	auto socVersion = GetCurrentPlatformInfo().GetSocVersion();	82	auto socVersion = GetCurrentPlatformInfo().GetSocVersion();
83	auto npuArch = op::GetCurrentPlatformInfo().GetCurNpuArch();	83	auto npuArch = op::GetCurrentPlatformInfo().GetCurNpuArch();
	@@ -91,33 +91,32 @@ inline static bool CheckDtypeValid(const aclTensor *out)
91	return true;	91	return true;
92	}	92	}
93		93
94	inline static bool CheckScalarDtypeValid(const aclScalar *scalar)	94	inline static bool CheckScalarDtypeValid(const aclScalar* scalar)
95	{	95	{
96	if (IsComplexType(scalar->GetDataType())) {	96	if (IsComplexType(scalar->GetDataType())) {
97	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "complex for input is not implemented.");	97	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "complex for input is not implemented.");
98	return false;	98	return false;
99	}	99	}
100	return true;	100	return true;
101	}	101	}
102		102
103	// 判断out数据类型，非COMPLEX则返回原数据类型，否则按情况返回	103	// 判断out数据类型，非COMPLEX则返回原数据类型，否则按情况返回
104	inline static DataType OutPromoteType(DataType outDataType) {	104	inline static DataType OutPromoteType(DataType outDataType)
		105	{
105	if (outDataType == op::DataType::DT_COMPLEX128) {	106	if (outDataType == op::DataType::DT_COMPLEX128) {
106	return op::DataType::DT_DOUBLE;	107	return op::DataType::DT_DOUBLE;
107	}	108	} else if (outDataType == op::DataType::DT_COMPLEX64) {
108	else if (outDataType == op::DataType::DT_COMPLEX64) {
109	return op::DataType::DT_FLOAT;	109	return op::DataType::DT_FLOAT;
110	}	110	} else if (outDataType == op::DataType::DT_INT64) {
111	else if (outDataType == op::DataType::DT_INT64) {	111	return op::DataType::DT_FLOAT;
112	return op::DataType::DT_FLOAT;	112	} else {
113	}
114	else {
115	return outDataType;	113	return outDataType;
116	}	114	}
117	}	115	}
118		116
119	// 检查参数是否符合算子的逻辑	117	// 检查参数是否符合算子的逻辑
120	inline static aclnnStatus CheckParamsLogic(const aclTensor *out, int64_t steps) {	118	inline static aclnnStatus CheckParamsLogic(const aclTensor* out, int64_t steps)
		119	{
121	// steps不能小于0	120	// steps不能小于0
122	if (steps < 0) {	121	if (steps < 0) {
123	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "number of steps must be non-negative.");	122	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "number of steps must be non-negative.");
	@@ -138,7 +137,8 @@ inline static aclnnStatus CheckParamsLogic(const aclTensor *out, int64_t steps)
138	return ACLNN_SUCCESS;	137	return ACLNN_SUCCESS;
139	}	138	}
140		139
141	static aclnnStatus FillScalar(const aclTensor out, const aclScalar start, aclOpExecutor *executor) {	140	static aclnnStatus FillScalar(const aclTensor* out, const aclScalar* start, aclOpExecutor* executor)
		141	{
142	FVector<int64_t> tmp = {1};	142	FVector<int64_t> tmp = {1};
143	auto dims = executor->ConvertToTensor(tmp.data(), tmp.size(), DataType::DT_INT64);	143	auto dims = executor->ConvertToTensor(tmp.data(), tmp.size(), DataType::DT_INT64);
144	auto shapeArray = executor->AllocIntArray(tmp.data(), tmp.size());	144	auto shapeArray = executor->AllocIntArray(tmp.data(), tmp.size());
	@@ -153,15 +153,15 @@ static aclnnStatus FillScalar(const aclTensor out, const aclScalar start, aclO
153	return ACLNN_SUCCESS;	153	return ACLNN_SUCCESS;
154	}	154	}
155		155
156	static aclnnStatus CheckParams(const aclScalar start, const aclScalar end, int64_t steps,	156	static aclnnStatus CheckParams(const aclScalar* start, const aclScalar* end, int64_t steps, const aclTensor* out)
157	const aclTensor *out) {	157	{
158	// 1. 检查参数是否为空指针	158	// 1. 检查参数是否为空指针
159	CHECK_RET(CheckNotNull(start, end, out), ACLNN_ERR_INNER_NULLPTR);	159	CHECK_RET(CheckNotNull(start, end, out), ACLNN_ERR_INNER_NULLPTR);
160		160
161	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验	161	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验
162	CHECK_RET(CheckScalarDtypeValid(start), ACLNN_ERR_PARAM_INVALID);	162	CHECK_RET(CheckScalarDtypeValid(start), ACLNN_ERR_PARAM_INVALID);
163	CHECK_RET(CheckScalarDtypeValid(end), ACLNN_ERR_PARAM_INVALID);	163	CHECK_RET(CheckScalarDtypeValid(end), ACLNN_ERR_PARAM_INVALID);
164	CHECK_RET(CheckDtypeValid(out), ACLNN_ERR_PARAM_INVALID);	164	CHECK_RET(CheckDtypeValid(out), ACLNN_ERR_PARAM_INVALID);
165		165
166	// 3. 检查输入的数据的值是否合理	166	// 3. 检查输入的数据的值是否合理
167	CHECK_RET(CheckParamsLogic(out, steps) == ACLNN_SUCCESS, ACLNN_ERR_PARAM_INVALID);	167	CHECK_RET(CheckParamsLogic(out, steps) == ACLNN_SUCCESS, ACLNN_ERR_PARAM_INVALID);
	@@ -169,8 +169,9 @@ static aclnnStatus CheckParams(const aclScalar start, const aclScalar end, int
169	return ACLNN_SUCCESS;	169	return ACLNN_SUCCESS;
170	}	170	}
171		171
172	aclnnStatus aclnnLinspaceGetWorkspaceSize(const aclScalar start, const aclScalar end, int64_t steps,	172	aclnnStatus aclnnLinspaceGetWorkspaceSize(const aclScalar* start, const aclScalar* end, int64_t steps, aclTensor* out,
173	aclTensor out, uint64_t workspaceSize, aclOpExecutor **executor) {	173	uint64_t* workspaceSize, aclOpExecutor** executor)
		174	{
174	L2_DFX_PHASE_1(aclnnLinspace, DFX_IN(start, end, steps), DFX_OUT(out));	175	L2_DFX_PHASE_1(aclnnLinspace, DFX_IN(start, end, steps), DFX_OUT(out));
175	// 创建OpExcutor	176	// 创建OpExcutor
176	auto uniqueExecutor = CREATE_EXECUTOR();	177	auto uniqueExecutor = CREATE_EXECUTOR();
	@@ -184,9 +185,11 @@ aclnnStatus aclnnLinspaceGetWorkspaceSize(const aclScalar *start, const aclScala
184	float startFloatValue = start->ToFloat();	185	float startFloatValue = start->ToFloat();
185	float endFloatValue = end->ToFloat();	186	float endFloatValue = end->ToFloat();
186	auto startWithBool = (start->GetDataType() == op::DataType::DT_BOOL) ?	187	auto startWithBool = (start->GetDataType() == op::DataType::DT_BOOL) ?
187	(uniqueExecutor.get()->AllocScalar(startFloatValue)) : start;	188	(uniqueExecutor.get()->AllocScalar(startFloatValue)) :
		189	start;
188	auto endWithBool = (end->GetDataType() == op::DataType::DT_BOOL) ?	190	auto endWithBool = (end->GetDataType() == op::DataType::DT_BOOL) ?
189	(uniqueExecutor.get()->AllocScalar(endFloatValue)) : end;	191	(uniqueExecutor.get()->AllocScalar(endFloatValue)) :
		192	end;
190		193
191	// steps等于0时返回空tensor, steps等于1时返回start。	194	// steps等于0时返回空tensor, steps等于1时返回start。
192	if (steps == 0) {	195	if (steps == 0) {
	@@ -208,7 +211,7 @@ aclnnStatus aclnnLinspaceGetWorkspaceSize(const aclScalar *start, const aclScala
208	// 执行L0算子，进行Linspace计算	211	// 执行L0算子，进行Linspace计算
209	auto linspaceOutRet = l0op::Linspace(startTensor, endTensor, steps, uniqueExecutor.get());	212	auto linspaceOutRet = l0op::Linspace(startTensor, endTensor, steps, uniqueExecutor.get());
210	CHECK_RET(linspaceOutRet != nullptr, ACLNN_ERR_INNER_NULLPTR);	213	CHECK_RET(linspaceOutRet != nullptr, ACLNN_ERR_INNER_NULLPTR);
211		214
212	// 将计算结果转换成输出out的数据类型	215	// 将计算结果转换成输出out的数据类型
213	auto castOut = l0op::Cast(linspaceOutRet, out->GetDataType(), uniqueExecutor.get());	216	auto castOut = l0op::Cast(linspaceOutRet, out->GetDataType(), uniqueExecutor.get());
214	CHECK_RET(castOut != nullptr, ACLNN_ERR_INNER_NULLPTR);	217	CHECK_RET(castOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
	@@ -224,7 +227,8 @@ aclnnStatus aclnnLinspaceGetWorkspaceSize(const aclScalar *start, const aclScala
224	return ACLNN_SUCCESS;	227	return ACLNN_SUCCESS;
225	}	228	}
226		229
227	aclnnStatus aclnnLinspace(void workspace, uint64_t workspaceSize, aclOpExecutor executor, aclrtStream stream) {	230	aclnnStatus aclnnLinspace(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
		231	{
228	L2_DFX_PHASE_2(aclnnLinspace);	232	L2_DFX_PHASE_2(aclnnLinspace);
229	// 调用框架能力，完成计算	233	// 调用框架能力，完成计算
230	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	234	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);

Rmath/lin_space/op_host/op_api/aclnn_linspace.h→math/lin_space/op_api/aclnn_linspace.h+1-1

	@@ -64,4 +64,4 @@ ACLNN_API aclnnStatus aclnnLinspace(void* workspace, uint64_t workspaceSize, acl
64	}	64	}
65	#endif	65	#endif
66		66
67	#endif	67	#endif

Rmath/lin_space/op_host/op_api/linspace.cpp→math/lin_space/op_api/linspace.cpp+40-36

	@@ -26,54 +26,58 @@ namespace l0op {
26	OP_TYPE_REGISTER(LinSpace);	26	OP_TYPE_REGISTER(LinSpace);
27		27
28	static const std::initializer_list<op::DataType> ASCEND910_AICORE_DTYPE_SUPPORT_LIST = {	28	static const std::initializer_list<op::DataType> ASCEND910_AICORE_DTYPE_SUPPORT_LIST = {
29	op::DataType::DT_INT32, op::DataType::DT_FLOAT16, op::DataType::DT_FLOAT,	29	op::DataType::DT_INT32, op::DataType::DT_FLOAT16, op::DataType::DT_FLOAT, op::DataType::DT_INT8,
30	op::DataType::DT_INT8, op::DataType::DT_UINT8};	30	op::DataType::DT_UINT8};
31		31
32	static const std::initializer_list<op::DataType> ASCEND910B_AICORE_DTYPE_SUPPORT_LIST = {	32	static const std::initializer_list<op::DataType> ASCEND910B_AICORE_DTYPE_SUPPORT_LIST = {
33	op::DataType::DT_INT32, op::DataType::DT_FLOAT16, op::DataType::DT_FLOAT,	33	op::DataType::DT_INT32, op::DataType::DT_FLOAT16, op::DataType::DT_FLOAT, op::DataType::DT_INT16,
34	op::DataType::DT_INT16, op::DataType::DT_INT8, op::DataType::DT_UINT8,	34	op::DataType::DT_INT8, op::DataType::DT_UINT8, op::DataType::DT_BF16};
35	op::DataType::DT_BF16};
36		35
37	// 根据芯片类型、dtype判断算子是否支持走AiCore	36	// 根据芯片类型、dtype判断算子是否支持走AiCore
38	static bool IsAiCoreSupport(const aclTensor *start) {	37	static bool IsAiCoreSupport(const aclTensor* start)
39	// 获取芯片类型	38	{
40	auto npuArch = op::GetCurrentPlatformInfo().GetCurNpuArch();	39	// 获取芯片类型
41	if (npuArch == NpuArch::DAV_2201 \|\| IsRegBase(npuArch)) {	40	auto npuArch = op::GetCurrentPlatformInfo().GetCurNpuArch();
42	return CheckType(start->GetDataType(), ASCEND910B_AICORE_DTYPE_SUPPORT_LIST);	41	if (npuArch == NpuArch::DAV_2201 \|\| IsRegBase(npuArch)) {
43	}	42	return CheckType(start->GetDataType(), ASCEND910B_AICORE_DTYPE_SUPPORT_LIST);
44	return CheckType(start->GetDataType(), ASCEND910_AICORE_DTYPE_SUPPORT_LIST);	43	}
		44	return CheckType(start->GetDataType(), ASCEND910_AICORE_DTYPE_SUPPORT_LIST);
45	}	45	}
46		46
47	// AICPU算子kernel	47	// AICPU算子kernel
48	static const aclTensor* LinspaceAiCpu(const aclTensor* start, const aclTensor* end, const aclTensor* steps,	48	static const aclTensor* LinspaceAiCpu(const aclTensor* start, const aclTensor* end, const aclTensor* steps,
49	aclTensor* out, aclOpExecutor* executor) {	49	aclTensor* out, aclOpExecutor* executor)
50	L0_DFX(LinspaceAiCpu, start, end, steps, out);	50	{
51	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICPU，将AiCpu Linspace算子加入任务队列	51	L0_DFX(LinspaceAiCpu, start, end, steps, out);
52	static internal::AicpuTaskSpace space("LinSpace");	52	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICPU，将AiCpu Linspace算子加入任务队列
53	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(LinSpace, OP_ATTR_NAMES({"Tidx"}), OP_INPUT(start, end, steps), OP_OUTPUT(out),	53	static internal::AicpuTaskSpace space("LinSpace");
54	OP_ATTR(start->GetDataType()));	54	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(LinSpace, OP_ATTR_NAMES({"Tidx"}), OP_INPUT(start, end, steps),
55	OP_CHECK(ret == ACLNN_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "LinspaceAiCpu ADD_TO_LAUNCHER_LIST_AICPU failed."), return nullptr);	55	OP_OUTPUT(out), OP_ATTR(start->GetDataType()));
56	return out;	56	OP_CHECK(ret == ACLNN_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "LinspaceAiCpu ADD_TO_LAUNCHER_LIST_AICPU failed."),
		57	return nullptr);
		58	return out;
57	}	59	}
58		60
59	// AICORE算子kernel	61	// AICORE算子kernel
60	static const aclTensor* LinspaceAiCore(const aclTensor* start, const aclTensor* end, const aclTensor* steps,	62	static const aclTensor* LinspaceAiCore(const aclTensor* start, const aclTensor* end, const aclTensor* steps,
61	aclTensor* out, aclOpExecutor* executor) {	63	aclTensor* out, aclOpExecutor* executor)
62	L0_DFX(LinspaceAiCore, start, end, steps, out);	64	{
63	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICORE，将AiCore Linspace算子加入任务队列	65	L0_DFX(LinspaceAiCore, start, end, steps, out);
64	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(LinSpace, OP_INPUT(start, end, steps), OP_OUTPUT(out));	66	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICORE，将AiCore Linspace算子加入任务队列
65	OP_CHECK(ret == ACLNN_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "LinspaceAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."), return nullptr);	67	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(LinSpace, OP_INPUT(start, end, steps), OP_OUTPUT(out));
66	return out;	68	OP_CHECK(ret == ACLNN_SUCCESS,
		69	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "LinspaceAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."), return nullptr);
		70	return out;
67	}	71	}
68		72
69	const aclTensor* Linspace(const aclTensor* start, const aclTensor* end, int64_t steps,	73	const aclTensor* Linspace(const aclTensor* start, const aclTensor* end, int64_t steps, aclOpExecutor* executor)
70	aclOpExecutor* executor) {	74	{
71	auto out = executor->AllocTensor({op::Shape({steps})}, start->GetDataType());	75	auto out = executor->AllocTensor({op::Shape({steps})}, start->GetDataType());
72	auto stepsTensor = executor->ConvertToTensor(executor->AllocScalar(steps), op::DataType::DT_INT32);	76	auto stepsTensor = executor->ConvertToTensor(executor->AllocScalar(steps), op::DataType::DT_INT32);
73	if (IsAiCoreSupport(start)) {	77	if (IsAiCoreSupport(start)) {
74	return LinspaceAiCore(start, end, stepsTensor, out, executor);	78	return LinspaceAiCore(start, end, stepsTensor, out, executor);
75	} else {	79	} else {
76	return LinspaceAiCpu(start, end, stepsTensor, out, executor);	80	return LinspaceAiCpu(start, end, stepsTensor, out, executor);
77	}	81	}
78	}	82	}
79	} // namespace l0op	83	} // namespace l0op

Rmath/lin_space/op_host/op_api/linspace.h→math/lin_space/op_api/linspace.h+1-2

	@@ -14,8 +14,7 @@
14	#include "opdev/op_executor.h"	14	#include "opdev/op_executor.h"
15		15
16	namespace l0op {	16	namespace l0op {
17	const aclTensor* Linspace(const aclTensor* start, const aclTensor* end, int64_t steps,	17	const aclTensor* Linspace(const aclTensor* start, const aclTensor* end, int64_t steps, aclOpExecutor* executor);
18	aclOpExecutor* executor);
19	}	18	}
20		19
21	#endif // OP_API_INC_LEVEL0_OP_LINSPACE_OP_H_	20	#endif // OP_API_INC_LEVEL0_OP_LINSPACE_OP_H_

Dmath/lin_space/op_host/CMakeLists.txt+0-11

	@@ -1,11 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# Copyright (c) 2025-2026 Huawei Technologies Co., Ltd.
3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	# CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------
10
11	add_modules_sources(OPTYPE lin_space ACLNNTYPE aclnn_exclude)

Dmath/lin_space/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/lin_space/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/lin_space/tests/ut/op_api/CMakeLists.txt+0-14

	@@ -1,14 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. See LICENSE in the root of
9	# the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	if(UT_TEST_ALL OR OP_API_UT)
13	add_modules_ut_sources(UT_NAME ${OP_API_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
14	endif()

Mmath/lin_space/tests/ut/op_api/test_aclnn_linspace.cpp+4-13

	@@ -12,7 +12,7 @@
12	#include <vector>	12	#include <vector>
13	#include "gtest/gtest.h"	13	#include "gtest/gtest.h"
14		14
15	#include "math/lin_space/op_host/op_api/aclnn_linspace.h"	15	#include "math/lin_space/op_api/aclnn_linspace.h"
16		16
17	#include "op_api_ut_common/op_api_ut.h"	17	#include "op_api_ut_common/op_api_ut.h"
18	#include "op_api_ut_common/scalar_desc.h"	18	#include "op_api_ut_common/scalar_desc.h"
	@@ -43,7 +43,6 @@ TEST_F(l2_linspace_test, aclnnLinspace_input_uint8)
43	uint64_t workspace_size = 0;	43	uint64_t workspace_size = 0;
44	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	44	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
45	EXPECT_EQ(aclRet, ACL_SUCCESS);	45	EXPECT_EQ(aclRet, ACL_SUCCESS);
46
47	}	46	}
48		47
49	// 输入int8	48	// 输入int8
	@@ -61,7 +60,6 @@ TEST_F(l2_linspace_test, aclnnLinspace_input_int8)
61	uint64_t workspace_size = 0;	60	uint64_t workspace_size = 0;
62	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	61	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
63	EXPECT_EQ(aclRet, ACL_SUCCESS);	62	EXPECT_EQ(aclRet, ACL_SUCCESS);
64
65	}	63	}
66		64
67	// 输入int32	65	// 输入int32
	@@ -79,7 +77,6 @@ TEST_F(l2_linspace_test, aclnnLinspace_input_int32)
79	uint64_t workspace_size = 0;	77	uint64_t workspace_size = 0;
80	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	78	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
81	EXPECT_EQ(aclRet, ACL_SUCCESS);	79	EXPECT_EQ(aclRet, ACL_SUCCESS);
82
83	}	80	}
84		81
85	// 输入int64	82	// 输入int64
	@@ -114,7 +111,6 @@ TEST_F(l2_linspace_test, aclnnLinspace_output_int64)
114	uint64_t workspace_size = 0;	111	uint64_t workspace_size = 0;
115	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	112	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
116	EXPECT_EQ(aclRet, ACL_SUCCESS);	113	EXPECT_EQ(aclRet, ACL_SUCCESS);
117
118	}	114	}
119		115
120	// 输入float16	116	// 输入float16
	@@ -149,7 +145,6 @@ TEST_F(l2_linspace_test, aclnnLinspace_input_float)
149	uint64_t workspace_size = 0;	145	uint64_t workspace_size = 0;
150	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	146	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
151	EXPECT_EQ(aclRet, ACL_SUCCESS);	147	EXPECT_EQ(aclRet, ACL_SUCCESS);
152
153	}	148	}
154		149
155	// 输出float	150	// 输出float
	@@ -167,7 +162,6 @@ TEST_F(l2_linspace_test, aclnnLinspace_output_float)
167	uint64_t workspace_size = 0;	162	uint64_t workspace_size = 0;
168	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	163	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
169	EXPECT_EQ(aclRet, ACL_SUCCESS);	164	EXPECT_EQ(aclRet, ACL_SUCCESS);
170
171	}	165	}
172		166
173	// 输出complex64	167	// 输出complex64
	@@ -236,10 +230,9 @@ TEST_F(l2_linspace_test, aclnnLinspace_steps_0)
236	uint64_t workspace_size = 0;	230	uint64_t workspace_size = 0;
237	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	231	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
238	EXPECT_EQ(aclRet, ACL_SUCCESS);	232	EXPECT_EQ(aclRet, ACL_SUCCESS);
239
240	}	233	}
241		234
242	// 输入out != step	235	// 输入out != step
243	TEST_F(l2_linspace_test, aclnnLinspace_steps_out)	236	TEST_F(l2_linspace_test, aclnnLinspace_steps_out)
244	{	237	{
245	auto start = ScalarDesc(static_cast<float>(3));	238	auto start = ScalarDesc(static_cast<float>(3));
	@@ -254,7 +247,6 @@ TEST_F(l2_linspace_test, aclnnLinspace_steps_out)
254	uint64_t workspace_size = 0;	247	uint64_t workspace_size = 0;
255	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	248	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
256	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);	249	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
257
258	}	250	}
259		251
260	// 输入step = 1	252	// 输入step = 1
	@@ -272,7 +264,6 @@ TEST_F(l2_linspace_test, aclnnLinspace_steps_1)
272	uint64_t workspace_size = 0;	264	uint64_t workspace_size = 0;
273	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	265	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
274	EXPECT_EQ(aclRet, ACL_SUCCESS);	266	EXPECT_EQ(aclRet, ACL_SUCCESS);
275
276	}	267	}
277		268
278	// start 空指针	269	// start 空指针
	@@ -326,7 +317,7 @@ TEST_F(l2_linspace_test, aclnnLinspace_start_greater_than_end)
326	EXPECT_EQ(aclRet, ACL_SUCCESS);	317	EXPECT_EQ(aclRet, ACL_SUCCESS);
327	}	318	}
328		319
329	// step = -2	320	// step = -2
330	TEST_F(l2_linspace_test, aclnnLinspace_steps_less_than_0)	321	TEST_F(l2_linspace_test, aclnnLinspace_steps_less_than_0)
331	{	322	{
332	auto start = ScalarDesc(static_cast<int>(3));	323	auto start = ScalarDesc(static_cast<int>(3));
	@@ -341,4 +332,4 @@ TEST_F(l2_linspace_test, aclnnLinspace_steps_less_than_0)
341	uint64_t workspace_size = 0;	332	uint64_t workspace_size = 0;
342	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	333	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
343	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);	334	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
344	}	335	}

Dmath/lin_space/tests/ut/op_host/CMakeLists.txt+0-21

	@@ -1,21 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# Copyright (c) 2025-2026 Huawei Technologies Co., Ltd.
3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	# CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------
10
11	if(UT_TEST_ALL OR OP_HOST_UT)
12	add_modules_ut_sources(UT_NAME ${OP_TILING_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
13	add_modules_ut_sources(UT_NAME ${OP_INFERSHAPE_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
14	endif()
15
16	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
17	foreach(SUB_DIR ${CURRENT_DIRS})
18	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
19	add_subdirectory(${SUB_DIR})
20	endif()
21	endforeach()

Dmath/log_add_exp/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/log_add_exp/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Amath/log_add_exp/tests/ut/op_api/test_logaddexp.cpp+456-0

@@ -0,0 +1,456 @@
	1	/**
	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10	#include <array>
	11	#include <vector>
	12	#include "gtest/gtest.h"
	13
	14	#include "../../../op_api/aclnn_logaddexp.h"
	15
	16	#include "op_api_ut_common/op_api_ut.h"
	17	#include "op_api_ut_common/tensor_desc.h"
	18
	19	using namespace std;
	20
	21	class l2_logaddexp_test : public testing::Test {
	22	protected:
	23	static void SetUpTestCase() { cout << "logaddexp_test SetUp" << endl; }
	24
	25	static void TearDownTestCase() { cout << "logaddexp_test TearDown" << endl; }
	26	};
	27
	28	TEST_F(l2_logaddexp_test, case_nullptr_input)
	29	{
	30	auto tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT, ACL_FORMAT_NCHW);
	31
	32	auto ut = OP_API_UT(aclnnLogAddExp, INPUT((aclTensor)nullptr, (aclTensor)nullptr), OUTPUT(tensor_desc));
	33
	34	// SAMPLE: only test GetWorkspaceSize
	35	uint64_t workspace_size = 0;
	36	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	37	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	38	}
	39
	40	TEST_F(l2_logaddexp_test, case_nullptr_output)
	41	{
	42	auto self_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	43	auto other_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	44
	45	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT((aclTensor*)nullptr));
	46
	47	// SAMPLE: only test GetWorkspaceSize
	48	uint64_t workspace_size = 0;
	49	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	50	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	51	}
	52
	53	TEST_F(l2_logaddexp_test, case_dtype_notsupport)
	54	{
	55	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_NHWC).ValueRange(-1, 1);
	56	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_NHWC).ValueRange(-1, 1);
	57	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_NHWC);
	58
	59	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	60
	61	// SAMPLE: only test GetWorkspaceSize
	62	uint64_t workspace_size = 0;
	63	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	64	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	65	}
	66
	67	TEST_F(l2_logaddexp_test, case_dtype_input_int_out_fp)
	68	{
	69	auto self_tensor_desc = TensorDesc({2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-1, 1);
	70	auto other_tensor_desc = TensorDesc({2, 3}, ACL_INT8, ACL_FORMAT_ND).ValueRange(-1, 1);
	71	auto out_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND);
	72
	73	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	74
	75	// SAMPLE: only test GetWorkspaceSize
	76	uint64_t workspace_size = 0;
	77	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	78	EXPECT_EQ(aclRet, ACL_SUCCESS);
	79
	80	// SAMPLE: precision simulate
	81	// ut.TestPrecision();
	82	}
	83
	84	TEST_F(l2_logaddexp_test, case_dtype_input_bool_out_fp)
	85	{
	86	auto self_tensor_desc = TensorDesc({2, 3}, ACL_BOOL, ACL_FORMAT_ND).ValueRange(-1, 1);
	87	auto other_tensor_desc = TensorDesc({2, 3}, ACL_BOOL, ACL_FORMAT_ND).ValueRange(-1, 1);
	88	auto out_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT16, ACL_FORMAT_ND);
	89
	90	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	91
	92	// SAMPLE: only test GetWorkspaceSize
	93	uint64_t workspace_size = 0;
	94	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	95	EXPECT_EQ(aclRet, ACL_SUCCESS);
	96
	97	// SAMPLE: precision simulate
	98	// ut.TestPrecision();
	99	}
	100
	101	TEST_F(l2_logaddexp_test, case_dtype_fp32)
	102	{
	103	auto self_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	104	auto other_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	105	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
	106
	107	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	108
	109	// SAMPLE: only test GetWorkspaceSize
	110	uint64_t workspace_size = 0;
	111	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	112	EXPECT_EQ(aclRet, ACL_SUCCESS);
	113
	114	// SAMPLE: precision simulate
	115	// ut.TestPrecision();
	116	}
	117
	118	TEST_F(l2_logaddexp_test, case_dtype_fp16)
	119	{
	120	auto self_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-1, 1);
	121	auto other_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-1, 1);
	122	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
	123
	124	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	125
	126	// SAMPLE: only test GetWorkspaceSize
	127	uint64_t workspace_size = 0;
	128	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	129	EXPECT_EQ(aclRet, ACL_SUCCESS);
	130
	131	// ut.TestPrecision();
	132	}
	133
	134	TEST_F(l2_logaddexp_test, case_dtype_double)
	135	{
	136	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_DOUBLE, ACL_FORMAT_NHWC).ValueRange(-1, 1);
	137	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_DOUBLE, ACL_FORMAT_NHWC).ValueRange(-1, 1);
	138	auto out_tensor_desc = TensorDesc(self_tensor_desc);
	139
	140	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	141
	142	// SAMPLE: only test GetWorkspaceSize
	143	uint64_t workspace_size = 0;
	144	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	145	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	146
	147	// ut.TestPrecision();
	148	}
	149
	150	TEST_F(l2_logaddexp_test, case_format_HWCN)
	151	{
	152	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_HWCN).ValueRange(-1, 1);
	153	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_HWCN).ValueRange(-1, 1);
	154	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
	155
	156	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	157
	158	// SAMPLE: only test GetWorkspaceSize
	159	uint64_t workspace_size = 0;
	160	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	161	EXPECT_EQ(aclRet, ACL_SUCCESS);
	162
	163	// ut.TestPrecision();
	164	}
	165
	166	TEST_F(l2_logaddexp_test, case_format_NDHWC)
	167	{
	168	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NDHWC).ValueRange(-1, 1);
	169	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NDHWC).ValueRange(-1, 1);
	170	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
	171
	172	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	173
	174	// SAMPLE: only test GetWorkspaceSize
	175	uint64_t workspace_size = 0;
	176	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	177	EXPECT_EQ(aclRet, ACL_SUCCESS);
	178
	179	// ut.TestPrecision();
	180	}
	181
	182	TEST_F(l2_logaddexp_test, case_format_NCDHW)
	183	{
	184	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NCDHW).ValueRange(-1, 1);
	185	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NCDHW).ValueRange(-1, 1);
	186	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
	187
	188	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	189
	190	// SAMPLE: only test GetWorkspaceSize
	191	uint64_t workspace_size = 0;
	192	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	193	EXPECT_EQ(aclRet, ACL_SUCCESS);
	194
	195	// ut.TestPrecision();
	196	}
	197
	198	TEST_F(l2_logaddexp_test, case_promoteType_ok)
	199	{
	200	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
	201	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	202	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	203
	204	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	205
	206	// SAMPLE: only test GetWorkspaceSize
	207	uint64_t workspace_size = 0;
	208	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	209	EXPECT_EQ(aclRet, ACL_SUCCESS);
	210
	211	// ut.TestPrecision();
	212	}
	213
	214	TEST_F(l2_logaddexp_test, case_promoteType_nok)
	215	{
	216	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
	217	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	218	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_ND).Precision(0.001, 0.001);
	219
	220	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	221
	222	// SAMPLE: only test GetWorkspaceSize
	223	uint64_t workspace_size = 0;
	224	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	225	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	226	}
	227
	228	TEST_F(l2_logaddexp_test, case_invalid_shape)
	229	{
	230	auto self_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	231	auto other_tensor_desc = TensorDesc({1, 1, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	232	auto out_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	233
	234	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	235
	236	// SAMPLE: only test GetWorkspaceSize
	237	uint64_t workspace_size = 0;
	238	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	239	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	240	}
	241
	242	TEST_F(l2_logaddexp_test, case_broadcast_ok)
	243	{
	244	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	245	auto other_tensor_desc = TensorDesc({4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	246	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	247
	248	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	249
	250	// SAMPLE: only test GetWorkspaceSize
	251	uint64_t workspace_size = 0;
	252	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	253	EXPECT_EQ(aclRet, ACL_SUCCESS);
	254
	255	// ut.TestPrecision();
	256	}
	257
	258	TEST_F(l2_logaddexp_test, case_broadcast_nok)
	259	{
	260	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	261	auto other_tensor_desc = TensorDesc({3, 4, 8}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	262	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	263
	264	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	265
	266	// SAMPLE: only test GetWorkspaceSize
	267	uint64_t workspace_size = 0;
	268	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	269	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	270	}
	271
	272	TEST_F(l2_logaddexp_test, case_dim_1)
	273	{
	274	auto self_tensor_desc = TensorDesc({1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	275	auto other_tensor_desc = TensorDesc({1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	276	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
	277
	278	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	279
	280	// SAMPLE: only test GetWorkspaceSize
	281	uint64_t workspace_size = 0;
	282	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	283	EXPECT_EQ(aclRet, ACL_SUCCESS);
	284
	285	// SAMPLE: precision simulate
	286	// ut.TestPrecision();
	287	}
	288
	289	TEST_F(l2_logaddexp_test, case_dim_3)
	290	{
	291	auto self_tensor_desc = TensorDesc({1, 2, 3}, ACL_FLOAT, ACL_FORMAT_NCL).ValueRange(-2, 2);
	292	auto other_tensor_desc = TensorDesc({1, 2, 3}, ACL_FLOAT, ACL_FORMAT_NCL).ValueRange(-2, 2);
	293	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
	294
	295	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	296
	297	// SAMPLE: only test GetWorkspaceSize
	298	uint64_t workspace_size = 0;
	299	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	300	EXPECT_EQ(aclRet, ACL_SUCCESS);
	301
	302	// SAMPLE: precision simulate
	303	// ut.TestPrecision();
	304	}
	305
	306	TEST_F(l2_logaddexp_test, case_dim_4)
	307	{
	308	auto self_tensor_desc = TensorDesc({1, 2, 3, 4}, ACL_FLOAT, ACL_FORMAT_NCHW).ValueRange(-2, 2);
	309	auto other_tensor_desc = TensorDesc({1, 2, 3, 4}, ACL_FLOAT, ACL_FORMAT_NCHW).ValueRange(-2, 2);
	310	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
	311
	312	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	313
	314	// SAMPLE: only test GetWorkspaceSize
	315	uint64_t workspace_size = 0;
	316	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	317	EXPECT_EQ(aclRet, ACL_SUCCESS);
	318
	319	// SAMPLE: precision simulate
	320	// ut.TestPrecision();
	321	}
	322
	323	TEST_F(l2_logaddexp_test, case_dim_8)
	324	{
	325	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	326	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	327	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
	328
	329	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	330
	331	// SAMPLE: only test GetWorkspaceSize
	332	uint64_t workspace_size = 0;
	333	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	334	EXPECT_EQ(aclRet, ACL_SUCCESS);
	335
	336	// SAMPLE: precision simulate
	337	// ut.TestPrecision();
	338	}
	339
	340	TEST_F(l2_logaddexp_test, case_dim_9)
	341	{
	342	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	343	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	344	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
	345
	346	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	347
	348	// SAMPLE: only test GetWorkspaceSize
	349	uint64_t workspace_size = 0;
	350	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	351	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	352	}
	353
	354	TEST_F(l2_logaddexp_test, case_empty_empty_empty)
	355	{
	356	auto self_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	357	auto other_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	358	auto out_tensor_desc = TensorDesc({0, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	359
	360	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	361
	362	// SAMPLE: only test GetWorkspaceSize
	363	uint64_t workspace_size = 0;
	364	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	365	EXPECT_EQ(aclRet, ACL_SUCCESS);
	366
	367	// ut.TestPrecision();
	368	}
	369
	370	TEST_F(l2_logaddexp_test, case_empty_noempty_empty)
	371	{
	372	auto self_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
	373	auto other_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
	374	auto out_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	375
	376	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	377
	378	// SAMPLE: only test GetWorkspaceSize
	379	uint64_t workspace_size = 0;
	380	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	381	EXPECT_EQ(aclRet, ACL_SUCCESS);
	382
	383	// ut.TestPrecision();
	384	}
	385
	386	TEST_F(l2_logaddexp_test, case_noempty_empty_empty)
	387	{
	388	auto self_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	389	auto other_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	390	auto out_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT16, ACL_FORMAT_ND).Precision(0.001, 0.001);
	391
	392	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	393
	394	// SAMPLE: only test GetWorkspaceSize
	395	uint64_t workspace_size = 0;
	396	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	397	EXPECT_EQ(aclRet, ACL_SUCCESS);
	398
	399	// ut.TestPrecision();
	400	}
	401
	402	TEST_F(l2_logaddexp_test, case_noempty_noempty_empty)
	403	{
	404	auto self_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	405	auto other_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	406	auto out_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	407
	408	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	409
	410	// SAMPLE: only test GetWorkspaceSize
	411	uint64_t workspace_size = 0;
	412	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	413	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	414	}
	415
	416	TEST_F(l2_logaddexp_test, case_empty_empty_noempty)
	417	{
	418	auto self_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	419	auto other_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	420	auto out_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	421
	422	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	423
	424	// SAMPLE: only test GetWorkspaceSize
	425	uint64_t workspace_size = 0;
	426	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	427	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	428	}
	429
	430	TEST_F(l2_logaddexp_test, case_noempty_empty_noempty)
	431	{
	432	auto self_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	433	auto other_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	434	auto out_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	435
	436	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	437
	438	// SAMPLE: only test GetWorkspaceSize
	439	uint64_t workspace_size = 0;
	440	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	441	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	442	}
	443
	444	TEST_F(l2_logaddexp_test, case_empty_noempty_noempty)
	445	{
	446	auto self_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	447	auto other_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	448	auto out_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
	449
	450	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	451
	452	// SAMPLE: only test GetWorkspaceSize
	453	uint64_t workspace_size = 0;
	454	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	455	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	456	}

Amath/log_add_exp/tests/ut/op_api/test_logaddexp2.cpp+456-0

@@ -0,0 +1,456 @@
	1	/**
	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10	#include <array>
	11	#include <vector>
	12	#include "gtest/gtest.h"
	13
	14	#include "../../..//op_api/aclnn_logaddexp2.h"
	15
	16	#include "op_api_ut_common/op_api_ut.h"
	17	#include "op_api_ut_common/tensor_desc.h"
	18
	19	using namespace std;
	20
	21	class l2_logaddexp2_test : public testing::Test {
	22	protected:
	23	static void SetUpTestCase() { cout << "logaddexp2_test SetUp" << endl; }
	24
	25	static void TearDownTestCase() { cout << "logaddexp2_test TearDown" << endl; }
	26	};
	27
	28	TEST_F(l2_logaddexp2_test, case_nullptr_input)
	29	{
	30	auto tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT, ACL_FORMAT_NCHW);
	31
	32	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT((aclTensor)nullptr, (aclTensor)nullptr), OUTPUT(tensor_desc));
	33
	34	// SAMPLE: only test GetWorkspaceSize
	35	uint64_t workspace_size = 0;
	36	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	37	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	38	}
	39
	40	TEST_F(l2_logaddexp2_test, case_nullptr_output)
	41	{
	42	auto self_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	43	auto other_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	44
	45	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT((aclTensor*)nullptr));
	46
	47	// SAMPLE: only test GetWorkspaceSize
	48	uint64_t workspace_size = 0;
	49	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	50	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	51	}
	52
	53	TEST_F(l2_logaddexp2_test, case_dtype_notsupport)
	54	{
	55	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_NHWC).ValueRange(-1, 1);
	56	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_NHWC).ValueRange(-1, 1);
	57	auto out_tensor_desc = TensorDesc(self_tensor_desc);
	58
	59	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	60
	61	// SAMPLE: only test GetWorkspaceSize
	62	uint64_t workspace_size = 0;
	63	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	64	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	65	}
	66
	67	TEST_F(l2_logaddexp2_test, case_dtype_input_int_out_fp)
	68	{
	69	auto self_tensor_desc = TensorDesc({2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-1, 1);
	70	auto other_tensor_desc = TensorDesc({2, 3}, ACL_INT8, ACL_FORMAT_ND).ValueRange(-1, 1);
	71	auto out_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND);
	72
	73	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	74
	75	// SAMPLE: only test GetWorkspaceSize
	76	uint64_t workspace_size = 0;
	77	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	78	EXPECT_EQ(aclRet, ACL_SUCCESS);
	79
	80	// SAMPLE: precision simulate
	81	// ut.TestPrecision();
	82	}
	83
	84	TEST_F(l2_logaddexp2_test, case_dtype_input_bool_out_fp)
	85	{
	86	auto self_tensor_desc = TensorDesc({2, 3}, ACL_BOOL, ACL_FORMAT_ND).ValueRange(-1, 1);
	87	auto other_tensor_desc = TensorDesc({2, 3}, ACL_BOOL, ACL_FORMAT_ND).ValueRange(-1, 1);
	88	auto out_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT16, ACL_FORMAT_ND);
	89
	90	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	91
	92	// SAMPLE: only test GetWorkspaceSize
	93	uint64_t workspace_size = 0;
	94	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	95	EXPECT_EQ(aclRet, ACL_SUCCESS);
	96
	97	// SAMPLE: precision simulate
	98	// ut.TestPrecision();
	99	}
	100
	101	TEST_F(l2_logaddexp2_test, case_dtype_fp32)
	102	{
	103	auto self_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	104	auto other_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
	105	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
	106
	107	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	108
	109	// SAMPLE: only test GetWorkspaceSize
	110	uint64_t workspace_size = 0;
	111	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	112	EXPECT_EQ(aclRet, ACL_SUCCESS);
	113
	114	// SAMPLE: precision simulate
	115	// ut.TestPrecision();
	116	}
	117
	118	TEST_F(l2_logaddexp2_test, case_dtype_fp16)
	119	{
	120	auto self_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-1, 1);
	121	auto other_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-1, 1);
	122	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
	123
	124	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	125
	126	// SAMPLE: only test GetWorkspaceSize
	127	uint64_t workspace_size = 0;
	128	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	129	EXPECT_EQ(aclRet, ACL_SUCCESS);
	130
	131	// ut.TestPrecision();
	132	}
	133
	134	TEST_F(l2_logaddexp2_test, case_dtype_double)
	135	{
	136	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_DOUBLE, ACL_FORMAT_NHWC).ValueRange(-1, 1);
	137	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_DOUBLE, ACL_FORMAT_NHWC).ValueRange(-1, 1);
	138	auto out_tensor_desc = TensorDesc(self_tensor_desc);
	139
	140	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	141
	142	// SAMPLE: only test GetWorkspaceSize
	143	uint64_t workspace_size = 0;
	144	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	145	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	146
	147	// ut.TestPrecision();
	148	}
	149
	150	TEST_F(l2_logaddexp2_test, case_format_HWCN)
	151	{
	152	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_HWCN).ValueRange(-1, 1);
	153	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_HWCN).ValueRange(-1, 1);
	154	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
	155
	156	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	157
	158	// SAMPLE: only test GetWorkspaceSize
	159	uint64_t workspace_size = 0;
	160	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	161	EXPECT_EQ(aclRet, ACL_SUCCESS);
	162
	163	// ut.TestPrecision();
	164	}
	165
	166	TEST_F(l2_logaddexp2_test, case_format_NDHWC)
	167	{
	168	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NDHWC).ValueRange(-1, 1);
	169	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NDHWC).ValueRange(-1, 1);
	170	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
	171
	172	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	173
	174	// SAMPLE: only test GetWorkspaceSize
	175	uint64_t workspace_size = 0;
	176	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	177	EXPECT_EQ(aclRet, ACL_SUCCESS);
	178
	179	// ut.TestPrecision();
	180	}
	181
	182	TEST_F(l2_logaddexp2_test, case_format_NCDHW)
	183	{
	184	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NCDHW).ValueRange(-1, 1);
	185	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NCDHW).ValueRange(-1, 1);
	186	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
	187
	188	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	189
	190	// SAMPLE: only test GetWorkspaceSize
	191	uint64_t workspace_size = 0;
	192	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	193	EXPECT_EQ(aclRet, ACL_SUCCESS);
	194
	195	// ut.TestPrecision();
	196	}
	197
	198	TEST_F(l2_logaddexp2_test, case_promoteType_ok)
	199	{
	200	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
	201	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	202	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
	203
	204	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	205
	206	// SAMPLE: only test GetWorkspaceSize
	207	uint64_t workspace_size = 0;
	208	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	209	EXPECT_EQ(aclRet, ACL_SUCCESS);
	210
	211	// ut.TestPrecision();
	212	}
	213
	214	TEST_F(l2_logaddexp2_test, case_promoteType_nok)
	215	{
	216	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
	217	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	218	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_ND).Precision(0.005, 0.005);
	219
	220	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	221
	222	// SAMPLE: only test GetWorkspaceSize
	223	uint64_t workspace_size = 0;
	224	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	225	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	226	}
	227
	228	TEST_F(l2_logaddexp2_test, case_invalid_shape)
	229	{
	230	auto self_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	231	auto other_tensor_desc = TensorDesc({1, 1, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	232	auto out_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
	233
	234	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	235
	236	// SAMPLE: only test GetWorkspaceSize
	237	uint64_t workspace_size = 0;
	238	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	239	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	240	}
	241
	242	TEST_F(l2_logaddexp2_test, case_broadcast_ok)
	243	{
	244	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	245	auto other_tensor_desc = TensorDesc({4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	246	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
	247
	248	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	249
	250	// SAMPLE: only test GetWorkspaceSize
	251	uint64_t workspace_size = 0;
	252	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	253	EXPECT_EQ(aclRet, ACL_SUCCESS);
	254
	255	// ut.TestPrecision();
	256	}
	257
	258	TEST_F(l2_logaddexp2_test, case_broadcast_nok)
	259	{
	260	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	261	auto other_tensor_desc = TensorDesc({3, 4, 8}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	262	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
	263
	264	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	265
	266	// SAMPLE: only test GetWorkspaceSize
	267	uint64_t workspace_size = 0;
	268	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	269	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	270	}
	271
	272	TEST_F(l2_logaddexp2_test, case_dim_1)
	273	{
	274	auto self_tensor_desc = TensorDesc({1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	275	auto other_tensor_desc = TensorDesc({1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	276	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
	277
	278	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	279
	280	// SAMPLE: only test GetWorkspaceSize
	281	uint64_t workspace_size = 0;
	282	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	283	EXPECT_EQ(aclRet, ACL_SUCCESS);
	284
	285	// SAMPLE: precision simulate
	286	// ut.TestPrecision();
	287	}
	288
	289	TEST_F(l2_logaddexp2_test, case_dim_3)
	290	{
	291	auto self_tensor_desc = TensorDesc({1, 2, 3}, ACL_FLOAT, ACL_FORMAT_NCL).ValueRange(-2, 2);
	292	auto other_tensor_desc = TensorDesc({1, 2, 3}, ACL_FLOAT, ACL_FORMAT_NCL).ValueRange(-2, 2);
	293	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
	294
	295	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	296
	297	// SAMPLE: only test GetWorkspaceSize
	298	uint64_t workspace_size = 0;
	299	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	300	EXPECT_EQ(aclRet, ACL_SUCCESS);
	301
	302	// SAMPLE: precision simulate
	303	// ut.TestPrecision();
	304	}
	305
	306	TEST_F(l2_logaddexp2_test, case_dim_4)
	307	{
	308	auto self_tensor_desc = TensorDesc({1, 2, 3, 4}, ACL_FLOAT, ACL_FORMAT_NCHW).ValueRange(-2, 2);
	309	auto other_tensor_desc = TensorDesc({1, 2, 3, 4}, ACL_FLOAT, ACL_FORMAT_NCHW).ValueRange(-2, 2);
	310	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
	311
	312	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	313
	314	// SAMPLE: only test GetWorkspaceSize
	315	uint64_t workspace_size = 0;
	316	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	317	EXPECT_EQ(aclRet, ACL_SUCCESS);
	318
	319	// SAMPLE: precision simulate
	320	// ut.TestPrecision();
	321	}
	322
	323	TEST_F(l2_logaddexp2_test, case_dim_8)
	324	{
	325	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	326	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	327	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
	328
	329	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	330
	331	// SAMPLE: only test GetWorkspaceSize
	332	uint64_t workspace_size = 0;
	333	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	334	EXPECT_EQ(aclRet, ACL_SUCCESS);
	335
	336	// SAMPLE: precision simulate
	337	// ut.TestPrecision();
	338	}
	339
	340	TEST_F(l2_logaddexp2_test, case_dim_9)
	341	{
	342	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	343	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	344	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
	345
	346	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	347
	348	// SAMPLE: only test GetWorkspaceSize
	349	uint64_t workspace_size = 0;
	350	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	351	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	352	}
	353
	354	TEST_F(l2_logaddexp2_test, case_empty_empty_empty)
	355	{
	356	auto self_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	357	auto other_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	358	auto out_tensor_desc = TensorDesc({0, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
	359
	360	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	361
	362	// SAMPLE: only test GetWorkspaceSize
	363	uint64_t workspace_size = 0;
	364	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	365	EXPECT_EQ(aclRet, ACL_SUCCESS);
	366
	367	// ut.TestPrecision();
	368	}
	369
	370	TEST_F(l2_logaddexp2_test, case_empty_noempty_empty)
	371	{
	372	auto self_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	373	auto other_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	374	auto out_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
	375
	376	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	377
	378	// SAMPLE: only test GetWorkspaceSize
	379	uint64_t workspace_size = 0;
	380	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	381	EXPECT_EQ(aclRet, ACL_SUCCESS);
	382
	383	// ut.TestPrecision();
	384	}
	385
	386	TEST_F(l2_logaddexp2_test, case_noempty_empty_empty)
	387	{
	388	auto self_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	389	auto other_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	390	auto out_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
	391
	392	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	393
	394	// SAMPLE: only test GetWorkspaceSize
	395	uint64_t workspace_size = 0;
	396	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	397	EXPECT_EQ(aclRet, ACL_SUCCESS);
	398
	399	// ut.TestPrecision();
	400	}
	401
	402	TEST_F(l2_logaddexp2_test, case_noempty_noempty_empty)
	403	{
	404	auto self_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	405	auto other_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	406	auto out_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
	407
	408	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	409
	410	// SAMPLE: only test GetWorkspaceSize
	411	uint64_t workspace_size = 0;
	412	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	413	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	414	}
	415
	416	TEST_F(l2_logaddexp2_test, case_empty_empty_noempty)
	417	{
	418	auto self_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	419	auto other_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	420	auto out_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
	421
	422	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	423
	424	// SAMPLE: only test GetWorkspaceSize
	425	uint64_t workspace_size = 0;
	426	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	427	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	428	}
	429
	430	TEST_F(l2_logaddexp2_test, case_noempty_empty_noempty)
	431	{
	432	auto self_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	433	auto other_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	434	auto out_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
	435
	436	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	437
	438	// SAMPLE: only test GetWorkspaceSize
	439	uint64_t workspace_size = 0;
	440	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	441	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	442	}
	443
	444	TEST_F(l2_logaddexp2_test, case_empty_noempty_noempty)
	445	{
	446	auto self_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	447	auto other_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
	448	auto out_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
	449
	450	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
	451
	452	// SAMPLE: only test GetWorkspaceSize
	453	uint64_t workspace_size = 0;
	454	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	455	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	456	}

Dmath/log_add_exp/tests/ut/op_host/CMakeLists.txt+0-20

	@@ -1,20 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()
18
19	if(OP_API_UT OR (UT_TEST_ALL AND NOT AICPU_ONLY))
20	endif()

Dmath/log_add_exp/tests/ut/op_host/op_api/CMakeLists.txt+0-11

	@@ -1,11 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11

Dmath/log_add_exp/tests/ut/op_host/op_api/test_logaddexp.cpp+0-433

	@@ -1,433 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10	#include <array>
11	#include <vector>
12	#include "gtest/gtest.h"
13
14	#include "../../../../op_host/op_api/aclnn_logaddexp.h"
15
16	#include "op_api_ut_common/op_api_ut.h"
17	#include "op_api_ut_common/tensor_desc.h"
18
19
20	using namespace std;
21
22	class l2_logaddexp_test : public testing::Test {
23	protected:
24	static void SetUpTestCase() {
25	cout << "logaddexp_test SetUp" << endl;
26	}
27
28	static void TearDownTestCase() {
29	cout << "logaddexp_test TearDown" << endl;
30	}
31	};
32
33	TEST_F(l2_logaddexp_test, case_nullptr_input) {
34	auto tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT, ACL_FORMAT_NCHW);
35
36	auto ut = OP_API_UT(aclnnLogAddExp, INPUT((aclTensor)nullptr, (aclTensor)nullptr), OUTPUT(tensor_desc));
37
38	// SAMPLE: only test GetWorkspaceSize
39	uint64_t workspace_size = 0;
40	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
41	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
42	}
43
44	TEST_F(l2_logaddexp_test, case_nullptr_output) {
45	auto self_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
46	auto other_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
47
48	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT((aclTensor*)nullptr));
49
50	// SAMPLE: only test GetWorkspaceSize
51	uint64_t workspace_size = 0;
52	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
53	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
54	}
55
56	TEST_F(l2_logaddexp_test, case_dtype_notsupport) {
57	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_NHWC).ValueRange(-1, 1);
58	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_NHWC).ValueRange(-1, 1);
59	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_NHWC);
60
61	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
62
63	// SAMPLE: only test GetWorkspaceSize
64	uint64_t workspace_size = 0;
65	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
66	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
67	}
68
69	TEST_F(l2_logaddexp_test, case_dtype_input_int_out_fp) {
70	auto self_tensor_desc = TensorDesc({2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-1, 1);
71	auto other_tensor_desc = TensorDesc({2, 3}, ACL_INT8, ACL_FORMAT_ND).ValueRange(-1, 1);
72	auto out_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND);
73
74	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
75
76	// SAMPLE: only test GetWorkspaceSize
77	uint64_t workspace_size = 0;
78	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
79	EXPECT_EQ(aclRet, ACL_SUCCESS);
80
81	// SAMPLE: precision simulate
82	// ut.TestPrecision();
83	}
84
85	TEST_F(l2_logaddexp_test, case_dtype_input_bool_out_fp) {
86	auto self_tensor_desc = TensorDesc({2, 3}, ACL_BOOL, ACL_FORMAT_ND).ValueRange(-1, 1);
87	auto other_tensor_desc = TensorDesc({2, 3}, ACL_BOOL, ACL_FORMAT_ND).ValueRange(-1, 1);
88	auto out_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT16, ACL_FORMAT_ND);
89
90	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
91
92	// SAMPLE: only test GetWorkspaceSize
93	uint64_t workspace_size = 0;
94	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
95	EXPECT_EQ(aclRet, ACL_SUCCESS);
96
97	// SAMPLE: precision simulate
98	// ut.TestPrecision();
99	}
100
101	TEST_F(l2_logaddexp_test, case_dtype_fp32) {
102	auto self_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
103	auto other_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
104	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
105
106	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
107
108	// SAMPLE: only test GetWorkspaceSize
109	uint64_t workspace_size = 0;
110	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
111	EXPECT_EQ(aclRet, ACL_SUCCESS);
112
113	// SAMPLE: precision simulate
114	// ut.TestPrecision();
115	}
116
117	TEST_F(l2_logaddexp_test, case_dtype_fp16) {
118	auto self_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-1, 1);
119	auto other_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-1, 1);
120	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
121
122	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
123
124	// SAMPLE: only test GetWorkspaceSize
125	uint64_t workspace_size = 0;
126	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
127	EXPECT_EQ(aclRet, ACL_SUCCESS);
128
129	// ut.TestPrecision();
130	}
131
132	TEST_F(l2_logaddexp_test, case_dtype_double) {
133	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_DOUBLE, ACL_FORMAT_NHWC).ValueRange(-1, 1);
134	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_DOUBLE, ACL_FORMAT_NHWC).ValueRange(-1, 1);
135	auto out_tensor_desc = TensorDesc(self_tensor_desc);
136
137	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
138
139	// SAMPLE: only test GetWorkspaceSize
140	uint64_t workspace_size = 0;
141	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
142	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
143
144	// ut.TestPrecision();
145	}
146
147	TEST_F(l2_logaddexp_test, case_format_HWCN) {
148	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_HWCN).ValueRange(-1, 1);
149	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_HWCN).ValueRange(-1, 1);
150	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
151
152	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
153
154	// SAMPLE: only test GetWorkspaceSize
155	uint64_t workspace_size = 0;
156	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
157	EXPECT_EQ(aclRet, ACL_SUCCESS);
158
159	// ut.TestPrecision();
160	}
161
162	TEST_F(l2_logaddexp_test, case_format_NDHWC) {
163	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NDHWC).ValueRange(-1, 1);
164	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NDHWC).ValueRange(-1, 1);
165	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
166
167	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
168
169	// SAMPLE: only test GetWorkspaceSize
170	uint64_t workspace_size = 0;
171	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
172	EXPECT_EQ(aclRet, ACL_SUCCESS);
173
174	// ut.TestPrecision();
175	}
176
177	TEST_F(l2_logaddexp_test, case_format_NCDHW) {
178	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NCDHW).ValueRange(-1, 1);
179	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NCDHW).ValueRange(-1, 1);
180	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
181
182	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
183
184	// SAMPLE: only test GetWorkspaceSize
185	uint64_t workspace_size = 0;
186	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
187	EXPECT_EQ(aclRet, ACL_SUCCESS);
188
189	// ut.TestPrecision();
190	}
191
192	TEST_F(l2_logaddexp_test, case_promoteType_ok) {
193	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
194	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
195	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
196
197	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
198
199	// SAMPLE: only test GetWorkspaceSize
200	uint64_t workspace_size = 0;
201	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
202	EXPECT_EQ(aclRet, ACL_SUCCESS);
203
204	// ut.TestPrecision();
205	}
206
207	TEST_F(l2_logaddexp_test, case_promoteType_nok) {
208	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
209	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
210	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_ND).Precision(0.001, 0.001);
211
212	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
213
214	// SAMPLE: only test GetWorkspaceSize
215	uint64_t workspace_size = 0;
216	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
217	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
218	}
219
220	TEST_F(l2_logaddexp_test, case_invalid_shape) {
221	auto self_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
222	auto other_tensor_desc = TensorDesc({1, 1, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
223	auto out_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
224
225	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
226
227	// SAMPLE: only test GetWorkspaceSize
228	uint64_t workspace_size = 0;
229	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
230	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
231	}
232
233	TEST_F(l2_logaddexp_test, case_broadcast_ok) {
234	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
235	auto other_tensor_desc = TensorDesc({4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
236	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
237
238	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
239
240	// SAMPLE: only test GetWorkspaceSize
241	uint64_t workspace_size = 0;
242	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
243	EXPECT_EQ(aclRet, ACL_SUCCESS);
244
245	// ut.TestPrecision();
246	}
247
248	TEST_F(l2_logaddexp_test, case_broadcast_nok) {
249	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
250	auto other_tensor_desc = TensorDesc({3, 4, 8}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
251	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
252
253	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
254
255	// SAMPLE: only test GetWorkspaceSize
256	uint64_t workspace_size = 0;
257	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
258	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
259	}
260
261	TEST_F(l2_logaddexp_test, case_dim_1) {
262	auto self_tensor_desc = TensorDesc({1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
263	auto other_tensor_desc = TensorDesc({1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
264	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
265
266	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
267
268	// SAMPLE: only test GetWorkspaceSize
269	uint64_t workspace_size = 0;
270	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
271	EXPECT_EQ(aclRet, ACL_SUCCESS);
272
273	// SAMPLE: precision simulate
274	// ut.TestPrecision();
275	}
276
277	TEST_F(l2_logaddexp_test, case_dim_3) {
278	auto self_tensor_desc = TensorDesc({1, 2, 3}, ACL_FLOAT, ACL_FORMAT_NCL).ValueRange(-2, 2);
279	auto other_tensor_desc = TensorDesc({1, 2, 3}, ACL_FLOAT, ACL_FORMAT_NCL).ValueRange(-2, 2);
280	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
281
282	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
283
284	// SAMPLE: only test GetWorkspaceSize
285	uint64_t workspace_size = 0;
286	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
287	EXPECT_EQ(aclRet, ACL_SUCCESS);
288
289	// SAMPLE: precision simulate
290	// ut.TestPrecision();
291	}
292
293	TEST_F(l2_logaddexp_test, case_dim_4) {
294	auto self_tensor_desc = TensorDesc({1, 2, 3, 4}, ACL_FLOAT, ACL_FORMAT_NCHW).ValueRange(-2, 2);
295	auto other_tensor_desc = TensorDesc({1, 2, 3, 4}, ACL_FLOAT, ACL_FORMAT_NCHW).ValueRange(-2, 2);
296	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
297
298	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
299
300	// SAMPLE: only test GetWorkspaceSize
301	uint64_t workspace_size = 0;
302	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
303	EXPECT_EQ(aclRet, ACL_SUCCESS);
304
305	// SAMPLE: precision simulate
306	// ut.TestPrecision();
307	}
308
309	TEST_F(l2_logaddexp_test, case_dim_8) {
310	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
311	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
312	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
313
314	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
315
316	// SAMPLE: only test GetWorkspaceSize
317	uint64_t workspace_size = 0;
318	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
319	EXPECT_EQ(aclRet, ACL_SUCCESS);
320
321	// SAMPLE: precision simulate
322	// ut.TestPrecision();
323	}
324
325	TEST_F(l2_logaddexp_test, case_dim_9) {
326	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
327	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
328	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.001, 0.001);
329
330	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
331
332	// SAMPLE: only test GetWorkspaceSize
333	uint64_t workspace_size = 0;
334	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
335	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
336	}
337
338	TEST_F(l2_logaddexp_test, case_empty_empty_empty) {
339	auto self_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
340	auto other_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
341	auto out_tensor_desc = TensorDesc({0, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
342
343	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
344
345	// SAMPLE: only test GetWorkspaceSize
346	uint64_t workspace_size = 0;
347	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
348	EXPECT_EQ(aclRet, ACL_SUCCESS);
349
350	// ut.TestPrecision();
351	}
352
353	TEST_F(l2_logaddexp_test, case_empty_noempty_empty) {
354	auto self_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
355	auto other_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
356	auto out_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
357
358	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
359
360	// SAMPLE: only test GetWorkspaceSize
361	uint64_t workspace_size = 0;
362	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
363	EXPECT_EQ(aclRet, ACL_SUCCESS);
364
365	// ut.TestPrecision();
366	}
367
368	TEST_F(l2_logaddexp_test, case_noempty_empty_empty) {
369	auto self_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
370	auto other_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
371	auto out_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT16, ACL_FORMAT_ND).Precision(0.001, 0.001);
372
373	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
374
375	// SAMPLE: only test GetWorkspaceSize
376	uint64_t workspace_size = 0;
377	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
378	EXPECT_EQ(aclRet, ACL_SUCCESS);
379
380	// ut.TestPrecision();
381	}
382
383	TEST_F(l2_logaddexp_test, case_noempty_noempty_empty) {
384	auto self_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
385	auto other_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
386	auto out_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
387
388	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
389
390	// SAMPLE: only test GetWorkspaceSize
391	uint64_t workspace_size = 0;
392	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
393	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
394	}
395
396	TEST_F(l2_logaddexp_test, case_empty_empty_noempty) {
397	auto self_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
398	auto other_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
399	auto out_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
400
401	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
402
403	// SAMPLE: only test GetWorkspaceSize
404	uint64_t workspace_size = 0;
405	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
406	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
407	}
408
409	TEST_F(l2_logaddexp_test, case_noempty_empty_noempty) {
410	auto self_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
411	auto other_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
412	auto out_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
413
414	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
415
416	// SAMPLE: only test GetWorkspaceSize
417	uint64_t workspace_size = 0;
418	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
419	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
420	}
421
422	TEST_F(l2_logaddexp_test, case_empty_noempty_noempty) {
423	auto self_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
424	auto other_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
425	auto out_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
426
427	auto ut = OP_API_UT(aclnnLogAddExp, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
428
429	// SAMPLE: only test GetWorkspaceSize
430	uint64_t workspace_size = 0;
431	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
432	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
433	}

Dmath/log_add_exp/tests/ut/op_host/op_api/test_logaddexp2.cpp+0-433

	@@ -1,433 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10	#include <array>
11	#include <vector>
12	#include "gtest/gtest.h"
13
14	#include "../../../../op_host/op_api/aclnn_logaddexp2.h"
15
16	#include "op_api_ut_common/op_api_ut.h"
17	#include "op_api_ut_common/tensor_desc.h"
18
19
20	using namespace std;
21
22	class l2_logaddexp2_test : public testing::Test {
23	protected:
24	static void SetUpTestCase() {
25	cout << "logaddexp2_test SetUp" << endl;
26	}
27
28	static void TearDownTestCase() {
29	cout << "logaddexp2_test TearDown" << endl;
30	}
31	};
32
33	TEST_F(l2_logaddexp2_test, case_nullptr_input) {
34	auto tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT, ACL_FORMAT_NCHW);
35
36	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT((aclTensor)nullptr, (aclTensor)nullptr), OUTPUT(tensor_desc));
37
38	// SAMPLE: only test GetWorkspaceSize
39	uint64_t workspace_size = 0;
40	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
41	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
42	}
43
44	TEST_F(l2_logaddexp2_test, case_nullptr_output) {
45	auto self_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
46	auto other_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
47
48	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT((aclTensor*)nullptr));
49
50	// SAMPLE: only test GetWorkspaceSize
51	uint64_t workspace_size = 0;
52	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
53	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
54	}
55
56	TEST_F(l2_logaddexp2_test, case_dtype_notsupport) {
57	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_NHWC).ValueRange(-1, 1);
58	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_NHWC).ValueRange(-1, 1);
59	auto out_tensor_desc = TensorDesc(self_tensor_desc);
60
61	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
62
63	// SAMPLE: only test GetWorkspaceSize
64	uint64_t workspace_size = 0;
65	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
66	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
67	}
68
69	TEST_F(l2_logaddexp2_test, case_dtype_input_int_out_fp) {
70	auto self_tensor_desc = TensorDesc({2, 3}, ACL_INT32, ACL_FORMAT_ND).ValueRange(-1, 1);
71	auto other_tensor_desc = TensorDesc({2, 3}, ACL_INT8, ACL_FORMAT_ND).ValueRange(-1, 1);
72	auto out_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND);
73
74	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
75
76	// SAMPLE: only test GetWorkspaceSize
77	uint64_t workspace_size = 0;
78	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
79	EXPECT_EQ(aclRet, ACL_SUCCESS);
80
81	// SAMPLE: precision simulate
82	// ut.TestPrecision();
83	}
84
85	TEST_F(l2_logaddexp2_test, case_dtype_input_bool_out_fp) {
86	auto self_tensor_desc = TensorDesc({2, 3}, ACL_BOOL, ACL_FORMAT_ND).ValueRange(-1, 1);
87	auto other_tensor_desc = TensorDesc({2, 3}, ACL_BOOL, ACL_FORMAT_ND).ValueRange(-1, 1);
88	auto out_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT16, ACL_FORMAT_ND);
89
90	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
91
92	// SAMPLE: only test GetWorkspaceSize
93	uint64_t workspace_size = 0;
94	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
95	EXPECT_EQ(aclRet, ACL_SUCCESS);
96
97	// SAMPLE: precision simulate
98	// ut.TestPrecision();
99	}
100
101	TEST_F(l2_logaddexp2_test, case_dtype_fp32) {
102	auto self_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
103	auto other_tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-1, 1);
104	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
105
106	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
107
108	// SAMPLE: only test GetWorkspaceSize
109	uint64_t workspace_size = 0;
110	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
111	EXPECT_EQ(aclRet, ACL_SUCCESS);
112
113	// SAMPLE: precision simulate
114	// ut.TestPrecision();
115	}
116
117	TEST_F(l2_logaddexp2_test, case_dtype_fp16) {
118	auto self_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-1, 1);
119	auto other_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-1, 1);
120	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
121
122	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
123
124	// SAMPLE: only test GetWorkspaceSize
125	uint64_t workspace_size = 0;
126	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
127	EXPECT_EQ(aclRet, ACL_SUCCESS);
128
129	// ut.TestPrecision();
130	}
131
132	TEST_F(l2_logaddexp2_test, case_dtype_double) {
133	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_DOUBLE, ACL_FORMAT_NHWC).ValueRange(-1, 1);
134	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_DOUBLE, ACL_FORMAT_NHWC).ValueRange(-1, 1);
135	auto out_tensor_desc = TensorDesc(self_tensor_desc);
136
137	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
138
139	// SAMPLE: only test GetWorkspaceSize
140	uint64_t workspace_size = 0;
141	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
142	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
143
144	// ut.TestPrecision();
145	}
146
147	TEST_F(l2_logaddexp2_test, case_format_HWCN) {
148	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_HWCN).ValueRange(-1, 1);
149	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_HWCN).ValueRange(-1, 1);
150	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
151
152	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
153
154	// SAMPLE: only test GetWorkspaceSize
155	uint64_t workspace_size = 0;
156	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
157	EXPECT_EQ(aclRet, ACL_SUCCESS);
158
159	// ut.TestPrecision();
160	}
161
162	TEST_F(l2_logaddexp2_test, case_format_NDHWC) {
163	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NDHWC).ValueRange(-1, 1);
164	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NDHWC).ValueRange(-1, 1);
165	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
166
167	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
168
169	// SAMPLE: only test GetWorkspaceSize
170	uint64_t workspace_size = 0;
171	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
172	EXPECT_EQ(aclRet, ACL_SUCCESS);
173
174	// ut.TestPrecision();
175	}
176
177	TEST_F(l2_logaddexp2_test, case_format_NCDHW) {
178	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NCDHW).ValueRange(-1, 1);
179	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_NCDHW).ValueRange(-1, 1);
180	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
181
182	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
183
184	// SAMPLE: only test GetWorkspaceSize
185	uint64_t workspace_size = 0;
186	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
187	EXPECT_EQ(aclRet, ACL_SUCCESS);
188
189	// ut.TestPrecision();
190	}
191
192	TEST_F(l2_logaddexp2_test, case_promoteType_ok) {
193	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
194	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
195	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
196
197	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
198
199	// SAMPLE: only test GetWorkspaceSize
200	uint64_t workspace_size = 0;
201	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
202	EXPECT_EQ(aclRet, ACL_SUCCESS);
203
204	// ut.TestPrecision();
205	}
206
207	TEST_F(l2_logaddexp2_test, case_promoteType_nok) {
208	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
209	auto other_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
210	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_INT32, ACL_FORMAT_ND).Precision(0.005, 0.005);
211
212	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
213
214	// SAMPLE: only test GetWorkspaceSize
215	uint64_t workspace_size = 0;
216	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
217	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
218	}
219
220	TEST_F(l2_logaddexp2_test, case_invalid_shape) {
221	auto self_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
222	auto other_tensor_desc = TensorDesc({1, 1, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
223	auto out_tensor_desc = TensorDesc({1, 1, 1, 3}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
224
225	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
226
227	// SAMPLE: only test GetWorkspaceSize
228	uint64_t workspace_size = 0;
229	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
230	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
231	}
232
233	TEST_F(l2_logaddexp2_test, case_broadcast_ok) {
234	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
235	auto other_tensor_desc = TensorDesc({4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
236	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
237
238	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
239
240	// SAMPLE: only test GetWorkspaceSize
241	uint64_t workspace_size = 0;
242	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
243	EXPECT_EQ(aclRet, ACL_SUCCESS);
244
245	// ut.TestPrecision();
246	}
247
248	TEST_F(l2_logaddexp2_test, case_broadcast_nok) {
249	auto self_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
250	auto other_tensor_desc = TensorDesc({3, 4, 8}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
251	auto out_tensor_desc = TensorDesc({2, 3, 4, 5}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
252
253	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
254
255	// SAMPLE: only test GetWorkspaceSize
256	uint64_t workspace_size = 0;
257	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
258	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
259	}
260
261	TEST_F(l2_logaddexp2_test, case_dim_1) {
262	auto self_tensor_desc = TensorDesc({1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
263	auto other_tensor_desc = TensorDesc({1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
264	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
265
266	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
267
268	// SAMPLE: only test GetWorkspaceSize
269	uint64_t workspace_size = 0;
270	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
271	EXPECT_EQ(aclRet, ACL_SUCCESS);
272
273	// SAMPLE: precision simulate
274	// ut.TestPrecision();
275	}
276
277	TEST_F(l2_logaddexp2_test, case_dim_3) {
278	auto self_tensor_desc = TensorDesc({1, 2, 3}, ACL_FLOAT, ACL_FORMAT_NCL).ValueRange(-2, 2);
279	auto other_tensor_desc = TensorDesc({1, 2, 3}, ACL_FLOAT, ACL_FORMAT_NCL).ValueRange(-2, 2);
280	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
281
282	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
283
284	// SAMPLE: only test GetWorkspaceSize
285	uint64_t workspace_size = 0;
286	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
287	EXPECT_EQ(aclRet, ACL_SUCCESS);
288
289	// SAMPLE: precision simulate
290	// ut.TestPrecision();
291	}
292
293	TEST_F(l2_logaddexp2_test, case_dim_4) {
294	auto self_tensor_desc = TensorDesc({1, 2, 3, 4}, ACL_FLOAT, ACL_FORMAT_NCHW).ValueRange(-2, 2);
295	auto other_tensor_desc = TensorDesc({1, 2, 3, 4}, ACL_FLOAT, ACL_FORMAT_NCHW).ValueRange(-2, 2);
296	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
297
298	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
299
300	// SAMPLE: only test GetWorkspaceSize
301	uint64_t workspace_size = 0;
302	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
303	EXPECT_EQ(aclRet, ACL_SUCCESS);
304
305	// SAMPLE: precision simulate
306	// ut.TestPrecision();
307	}
308
309	TEST_F(l2_logaddexp2_test, case_dim_8) {
310	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
311	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
312	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
313
314	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
315
316	// SAMPLE: only test GetWorkspaceSize
317	uint64_t workspace_size = 0;
318	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
319	EXPECT_EQ(aclRet, ACL_SUCCESS);
320
321	// SAMPLE: precision simulate
322	// ut.TestPrecision();
323	}
324
325	TEST_F(l2_logaddexp2_test, case_dim_9) {
326	auto self_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
327	auto other_tensor_desc = TensorDesc({1, 2, 3, 4, 5, 6, 7, 8, 9}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
328	auto out_tensor_desc = TensorDesc(self_tensor_desc).Precision(0.005, 0.005);
329
330	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
331
332	// SAMPLE: only test GetWorkspaceSize
333	uint64_t workspace_size = 0;
334	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
335	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
336	}
337
338	TEST_F(l2_logaddexp2_test, case_empty_empty_empty) {
339	auto self_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
340	auto other_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
341	auto out_tensor_desc = TensorDesc({0, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
342
343	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
344
345	// SAMPLE: only test GetWorkspaceSize
346	uint64_t workspace_size = 0;
347	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
348	EXPECT_EQ(aclRet, ACL_SUCCESS);
349
350	// ut.TestPrecision();
351	}
352
353	TEST_F(l2_logaddexp2_test, case_empty_noempty_empty) {
354	auto self_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
355	auto other_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
356	auto out_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
357
358	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
359
360	// SAMPLE: only test GetWorkspaceSize
361	uint64_t workspace_size = 0;
362	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
363	EXPECT_EQ(aclRet, ACL_SUCCESS);
364
365	// ut.TestPrecision();
366	}
367
368	TEST_F(l2_logaddexp2_test, case_noempty_empty_empty) {
369	auto self_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
370	auto other_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
371	auto out_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
372
373	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
374
375	// SAMPLE: only test GetWorkspaceSize
376	uint64_t workspace_size = 0;
377	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
378	EXPECT_EQ(aclRet, ACL_SUCCESS);
379
380	// ut.TestPrecision();
381	}
382
383	TEST_F(l2_logaddexp2_test, case_noempty_noempty_empty) {
384	auto self_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
385	auto other_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
386	auto out_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
387
388	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
389
390	// SAMPLE: only test GetWorkspaceSize
391	uint64_t workspace_size = 0;
392	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
393	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
394	}
395
396	TEST_F(l2_logaddexp2_test, case_empty_empty_noempty) {
397	auto self_tensor_desc = TensorDesc({0, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
398	auto other_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
399	auto out_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
400
401	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
402
403	// SAMPLE: only test GetWorkspaceSize
404	uint64_t workspace_size = 0;
405	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
406	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
407	}
408
409	TEST_F(l2_logaddexp2_test, case_noempty_empty_noempty) {
410	auto self_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
411	auto other_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
412	auto out_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
413
414	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
415
416	// SAMPLE: only test GetWorkspaceSize
417	uint64_t workspace_size = 0;
418	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
419	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
420	}
421
422	TEST_F(l2_logaddexp2_test, case_empty_noempty_noempty) {
423	auto self_tensor_desc = TensorDesc({1, 2, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
424	auto other_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(-2, 2);
425	auto out_tensor_desc = TensorDesc({1, 2, 1}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.005, 0.005);
426
427	auto ut = OP_API_UT(aclnnLogAddExp2, INPUT(self_tensor_desc, other_tensor_desc), OUTPUT(out_tensor_desc));
428
429	// SAMPLE: only test GetWorkspaceSize
430	uint64_t workspace_size = 0;
431	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
432	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
433	}

Mmath/logspace/op_api/aclnn_logspace.cpp+27-23

	@@ -24,63 +24,66 @@
24	#include "opdev/op_dfx.h"	24	#include "opdev/op_dfx.h"
25	#include "opdev/op_log.h"	25	#include "opdev/op_log.h"
26	#include "opdev/platform.h"	26	#include "opdev/platform.h"
27	#include "math/lin_space/op_host/op_api/linspace.h"	27	#include "math/lin_space/op_api/linspace.h"
28	#include "math/pow/op_api/pow.h"	28	#include "math/pow/op_api/pow.h"
29		29
30	using namespace op;	30	using namespace op;
31		31
32	static const std::initializer_list<DataType> LOGSPACE_DTYPE_SUPPORT_LIST = {	32	static const std::initializer_list<DataType> LOGSPACE_DTYPE_SUPPORT_LIST = {
33	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16	33	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};
34	};
35		34
36	static bool CheckNotNull(const aclScalar start, const aclScalar end, const aclTensor* result){	35	static bool CheckNotNull(const aclScalar* start, const aclScalar* end, const aclTensor* result)
		36	{
37	OP_CHECK_NULL(start, return false);	37	OP_CHECK_NULL(start, return false);
38	OP_CHECK_NULL(end, return false);	38	OP_CHECK_NULL(end, return false);
39	OP_CHECK_NULL(result,return false);	39	OP_CHECK_NULL(result, return false);
40	return true;	40	return true;
41	}	41	}
42		42
43	static bool CheckDtypeValid(const aclTensor* result){	43	static bool CheckDtypeValid(const aclTensor* result)
		44	{
44	DataType result_dtype = result->GetDataType();	45	DataType result_dtype = result->GetDataType();
45	return std::find(LOGSPACE_DTYPE_SUPPORT_LIST.begin(),	46	return std::find(LOGSPACE_DTYPE_SUPPORT_LIST.begin(), LOGSPACE_DTYPE_SUPPORT_LIST.end(), result_dtype) !=
46	LOGSPACE_DTYPE_SUPPORT_LIST.end(),	47	LOGSPACE_DTYPE_SUPPORT_LIST.end();
47	result_dtype) != LOGSPACE_DTYPE_SUPPORT_LIST.end();
48	}	48	}
49		49
50	static bool CheckStepsValid(int64_t steps){	50	static bool CheckStepsValid(int64_t steps)
		51	{
51	if (steps < 0) {	52	if (steps < 0) {
52	OP_LOGE(ACLNN_ERR_PARAM_INVALID,"LogSpace requires non-negative steps, given steps is %ld", steps);	53	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "LogSpace requires non-negative steps, given steps is %ld", steps);
53	return false;	54	return false;
54	}	55	}
55	return true;	56	return true;
56	}	57	}
57		58
58	static aclnnStatus CheckParams(const aclScalar start, const aclScalar end, int64_t steps, const aclTensor *result){	59	static aclnnStatus CheckParams(const aclScalar* start, const aclScalar* end, int64_t steps, const aclTensor* result)
59	CHECK_RET(CheckNotNull(start, end, result),ACLNN_ERR_INNER_NULLPTR);	60	{
60	//检查数据类型支持	61	CHECK_RET(CheckNotNull(start, end, result), ACLNN_ERR_INNER_NULLPTR);
		62	// 检查数据类型支持
61	CHECK_RET(CheckDtypeValid(result), ACLNN_ERR_PARAM_INVALID);	63	CHECK_RET(CheckDtypeValid(result), ACLNN_ERR_PARAM_INVALID);
62	//检查steps有效性	64	// 检查steps有效性
63	CHECK_RET(CheckStepsValid(steps), ACLNN_ERR_PARAM_INVALID);	65	CHECK_RET(CheckStepsValid(steps), ACLNN_ERR_PARAM_INVALID);
64	return ACLNN_SUCCESS;	66	return ACLNN_SUCCESS;
65	}	67	}
66		68
67	static const aclTensor* ScalarToTensor(const aclScalar other, const op::DataType dataType, aclOpExecutor executor)	69	static const aclTensor* ScalarToTensor(const aclScalar* other, const op::DataType dataType, aclOpExecutor* executor)
68	{	70	{
69	auto otherTensor = executor->ConvertToTensor(other, dataType);	71	auto otherTensor = executor->ConvertToTensor(other, dataType);
70	return otherTensor;	72	return otherTensor;
71	}	73	}
72		74
73	aclnnStatus aclnnLogSpaceGetWorkspaceSize(const aclScalar start, const aclScalar end, int64_t steps, double base, const aclTensor *result,	75	aclnnStatus aclnnLogSpaceGetWorkspaceSize(const aclScalar* start, const aclScalar* end, int64_t steps, double base,
74	uint64_t workspaceSize, aclOpExecutor *executor){	76	const aclTensor* result, uint64_t* workspaceSize, aclOpExecutor** executor)
		77	{
75	OP_CHECK_COMM_INPUT(workspaceSize, executor);	78	OP_CHECK_COMM_INPUT(workspaceSize, executor);
76	L2_DFX_PHASE_1(aclnnLogSpace, DFX_IN(start, end, steps, base),DFX_OUT(result));	79	L2_DFX_PHASE_1(aclnnLogSpace, DFX_IN(start, end, steps, base), DFX_OUT(result));
77		80
78	auto uniqueExecutor = CREATE_EXECUTOR();	81	auto uniqueExecutor = CREATE_EXECUTOR();
79	CHECK_RET(uniqueExecutor.get() != nullptr,ACLNN_ERR_INNER_CREATE_EXECUTOR);	82	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
80	auto ret = CheckParams(start, end, steps, result);	83	auto ret = CheckParams(start, end, steps, result);
81	CHECK_RET(ret == ACLNN_SUCCESS, ret);	84	CHECK_RET(ret == ACLNN_SUCCESS, ret);
82		85
83	//如果steps为0，直接返回空张量	86	// 如果steps为0，直接返回空张量
84	if (steps == 0) {	87	if (steps == 0) {
85	*workspaceSize = 0;	88	*workspaceSize = 0;
86	uniqueExecutor.ReleaseTo(executor);	89	uniqueExecutor.ReleaseTo(executor);
	@@ -134,7 +137,8 @@ aclnnStatus aclnnLogSpaceGetWorkspaceSize(const aclScalar *start, const aclScala
134	return ACLNN_SUCCESS;	137	return ACLNN_SUCCESS;
135	}	138	}
136		139
137	aclnnStatus aclnnLogSpace(void* workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream){	140	aclnnStatus aclnnLogSpace(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream)
		141	{
138	L2_DFX_PHASE_2(aclnnLogSpace);	142	L2_DFX_PHASE_2(aclnnLogSpace);
139	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	143	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
140	}	144	}

Dmath/masked_scale/tests/ut/op_host/op_api/test_masked_scale.cpp+0-261

	@@ -1,261 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10
11	#include <array>
12	#include <vector>
13	#include "gtest/gtest.h"
14
15	#include "../../../../op_api/aclnn_masked_scale.h"
16
17	#include "op_api_ut_common/op_api_ut.h"
18	#include "op_api_ut_common/scalar_desc.h"
19	#include "op_api_ut_common/tensor_desc.h"
20	#include "op_api_ut_common/inner/types.h"
21	#include "opdev/platform.h"
22
23	using namespace op;
24
25	class l2_masked_scale_test : public testing::Test {
26	protected:
27	static void SetUpTestCase() { std::cout << "masked_scale_test SetUp" << std::endl; }
28
29	static void TearDownTestCase() { std::cout << "masked_scale_test TearDown" << std::endl; }
30	};
31
32	// test nullptr
33	TEST_F(l2_masked_scale_test, ascend950_case_nullptr) {
34	auto self = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
35	auto mask = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
36	auto out = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
37	float scale = 1.0;
38	uint64_t workspace_size = 0;
39
40	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(nullptr, mask, scale), OUTPUT(out));
41	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
42	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
43
44	auto ut1 = OP_API_UT(aclnnMaskedScale, INPUT(self, nullptr, scale), OUTPUT(out));
45	aclnnStatus aclRet1 = ut1.TestGetWorkspaceSize(&workspace_size);
46	EXPECT_EQ(aclRet1, ACLNN_ERR_PARAM_NULLPTR);
47
48	auto ut2 = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(nullptr));
49	aclnnStatus aclRet2 = ut2.TestGetWorkspaceSize(&workspace_size);
50	EXPECT_EQ(aclRet2, ACLNN_ERR_PARAM_NULLPTR);
51	}
52
53	// test xdtype:float16, maskdtype:int8
54	TEST_F(l2_masked_scale_test, ascend950_case_dtype_fp16_int8_01) {
55	auto self = TensorDesc({2, 2}, ACL_FLOAT16, ACL_FORMAT_ND);
56	auto mask = TensorDesc({2, 2}, ACL_INT8, ACL_FORMAT_ND);
57	auto out = TensorDesc({2, 2}, ACL_FLOAT16, ACL_FORMAT_ND);
58	float scale = 1.0;
59
60	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
61
62	uint64_t workspace_size = 0;
63	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
64	EXPECT_EQ(aclRet, ACL_SUCCESS);
65	}
66
67	// test xdtype:bfloat16, maskdtype:int8
68	TEST_F(l2_masked_scale_test, ascend950_case_dtype_bf16_int8_01) {
69	auto self = TensorDesc({2, 2}, ACL_BF16, ACL_FORMAT_ND);
70	auto mask = TensorDesc({2, 2}, ACL_INT8, ACL_FORMAT_ND);
71	auto out = TensorDesc({2, 2}, ACL_BF16, ACL_FORMAT_ND);
72	float scale = 1.0;
73
74	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
75
76	uint64_t workspace_size = 0;
77	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
78	EXPECT_EQ(aclRet, ACL_SUCCESS);
79	}
80
81	// test xdtype:float32, maskdtype:int8
82	TEST_F(l2_masked_scale_test, ascend950_case_dtype_fp32_int8_01) {
83	auto self = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
84	auto mask = TensorDesc({2, 2}, ACL_INT8, ACL_FORMAT_ND);
85	auto out = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
86	float scale = 1.0;
87
88	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
89
90	uint64_t workspace_size = 0;
91	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
92	EXPECT_EQ(aclRet, ACL_SUCCESS);
93	}
94
95	// test xdtype:float16, maskdtype:uint8
96	TEST_F(l2_masked_scale_test, ascend950_case_dtype_fp16_uint8_01) {
97	auto self = TensorDesc({2, 2}, ACL_FLOAT16, ACL_FORMAT_ND);
98	auto mask = TensorDesc({2, 2}, ACL_UINT8, ACL_FORMAT_ND);
99	auto out = TensorDesc({2, 2}, ACL_FLOAT16, ACL_FORMAT_ND);
100	float scale = 1.0;
101
102	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
103
104	uint64_t workspace_size = 0;
105	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
106	EXPECT_EQ(aclRet, ACL_SUCCESS);
107	}
108
109	// test xdtype:bfloat16, maskdtype:uint8
110	TEST_F(l2_masked_scale_test, ascend950_case_dtype_bf16_uint8_01) {
111	auto self = TensorDesc({2, 2}, ACL_BF16, ACL_FORMAT_ND);
112	auto mask = TensorDesc({2, 2}, ACL_UINT8, ACL_FORMAT_ND);
113	auto out = TensorDesc({2, 2}, ACL_BF16, ACL_FORMAT_ND);
114	float scale = 1.0;
115
116	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
117
118	uint64_t workspace_size = 0;
119	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
120	EXPECT_EQ(aclRet, ACL_SUCCESS);
121	}
122
123	// test xdtype:float32, maskdtype:uint8
124	TEST_F(l2_masked_scale_test, ascend950_case_dtype_fp32_uint8_01) {
125	auto self = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
126	auto mask = TensorDesc({2, 2}, ACL_UINT8, ACL_FORMAT_ND);
127	auto out = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
128	float scale = 1.0;
129
130	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
131
132	uint64_t workspace_size = 0;
133	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
134	EXPECT_EQ(aclRet, ACL_SUCCESS);
135	}
136
137	// test xdtype:float16, maskdtype:float16
138	TEST_F(l2_masked_scale_test, ascend950_case_dtype_fp16_fp16_01) {
139	auto self = TensorDesc({2, 2}, ACL_FLOAT16, ACL_FORMAT_ND);
140	auto mask = TensorDesc({2, 2}, ACL_FLOAT16, ACL_FORMAT_ND);
141	auto out = TensorDesc({2, 2}, ACL_FLOAT16, ACL_FORMAT_ND);
142	float scale = 1.0;
143
144	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
145
146	uint64_t workspace_size = 0;
147	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
148	EXPECT_EQ(aclRet, ACL_SUCCESS);
149	}
150
151	// test xdtype:bfloat16, maskdtype:float16
152	TEST_F(l2_masked_scale_test, ascend950_case_dtype_bf16_fp16_01) {
153	auto self = TensorDesc({2, 2}, ACL_BF16, ACL_FORMAT_ND);
154	auto mask = TensorDesc({2, 2}, ACL_FLOAT16, ACL_FORMAT_ND);
155	auto out = TensorDesc({2, 2}, ACL_BF16, ACL_FORMAT_ND);
156	float scale = 1.0;
157
158	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
159
160	uint64_t workspace_size = 0;
161	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
162	EXPECT_EQ(aclRet, ACL_SUCCESS);
163	}
164
165	// test xdtype:float32, maskdtype:float16
166	TEST_F(l2_masked_scale_test, ascend950_case_dtype_fp32_fp16_01) {
167	auto self = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
168	auto mask = TensorDesc({2, 2}, ACL_FLOAT16, ACL_FORMAT_ND);
169	auto out = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
170	float scale = 1.0;
171
172	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
173
174	uint64_t workspace_size = 0;
175	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
176	EXPECT_EQ(aclRet, ACL_SUCCESS);
177	}
178
179	// test xdtype:float16, maskdtype:float32
180	TEST_F(l2_masked_scale_test, ascend950_case_dtype_fp16_fp32_01) {
181	auto self = TensorDesc({2, 2}, ACL_FLOAT16, ACL_FORMAT_ND);
182	auto mask = TensorDesc({2, 2}, ACL_FLOAT16, ACL_FORMAT_ND);
183	auto out = TensorDesc({2, 2}, ACL_FLOAT16, ACL_FORMAT_ND);
184	float scale = 1.0;
185
186	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
187
188	uint64_t workspace_size = 0;
189	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
190	EXPECT_EQ(aclRet, ACL_SUCCESS);
191	}
192
193	// test xdtype:bfloat16, maskdtype:float32
194	TEST_F(l2_masked_scale_test, ascend950_case_dtype_bf16_fp32_01) {
195	auto self = TensorDesc({2, 2}, ACL_BF16, ACL_FORMAT_ND);
196	auto mask = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
197	auto out = TensorDesc({2, 2}, ACL_BF16, ACL_FORMAT_ND);
198	float scale = 1.0;
199
200	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
201
202	uint64_t workspace_size = 0;
203	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
204	EXPECT_EQ(aclRet, ACL_SUCCESS);
205	}
206
207	// test xdtype:float32, maskdtype:float32
208	TEST_F(l2_masked_scale_test, ascend950_case_dtype_fp32_fp32_01) {
209	auto self = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
210	auto mask = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
211	auto out = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
212	float scale = 1.0;
213
214	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
215
216	uint64_t workspace_size = 0;
217	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
218	EXPECT_EQ(aclRet, ACL_SUCCESS);
219	}
220
221	// 非法dype：不支持的dtype
222	TEST_F(l2_masked_scale_test, ascend950_case_dtype_invalid_0) {
223	auto self = TensorDesc({2, 2}, ACL_INT8, ACL_FORMAT_ND);
224	auto mask = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
225	auto out = TensorDesc({2, 2}, ACL_INT8, ACL_FORMAT_ND);
226	float scale = 1.0;
227
228	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
229
230	uint64_t workspace_size = 0;
231	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
232	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
233	}
234
235	// 非法shape：shape不一致
236	TEST_F(l2_masked_scale_test, ascend950_case_shape_invalid_1) {
237	auto self = TensorDesc({2, 2}, ACL_INT8, ACL_FORMAT_ND);
238	auto mask = TensorDesc({2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
239	auto out = TensorDesc({2, 3}, ACL_INT8, ACL_FORMAT_ND);
240	float scale = 1.0;
241
242	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
243
244	uint64_t workspace_size = 0;
245	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
246	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
247	}
248
249	// 非法shape：shape的dim超过8维
250	TEST_F(l2_masked_scale_test, ascend950_case_shape_invalid_2) {
251	auto self = TensorDesc({2, 2, 2, 1, 1, 1, 2, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
252	auto mask = TensorDesc({2, 2, 2, 1, 1, 1, 2, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
253	auto out = TensorDesc({2, 2, 2, 1, 1, 1, 2, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND);
254	float scale = 1.0;
255
256	auto ut = OP_API_UT(aclnnMaskedScale, INPUT(self, mask, scale), OUTPUT(out));
257
258	uint64_t workspace_size = 0;
259	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
260	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
261	}

Mmath/non_finite_check/CMakeLists.txt+3-12

	@@ -1,20 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11		10
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE non_finite_check ACLNNTYPE aclnn_exclude)
13	if(NOT ENABLE_TEST AND NOT BENCHMARK)
14	list(REMOVE_ITEM CURRENT_DIRS tests)
15	endif()
16	foreach(SUB_DIR ${CURRENT_DIRS})
17	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
18	add_subdirectory(${SUB_DIR})
19	endif()
20	endforeach()

Rmath/non_finite_check/op_host/op_api/non_finite_check.cpp→math/non_finite_check/op_api/non_finite_check.cpp+1-1

	@@ -17,4 +17,4 @@
17	namespace l0op {	17	namespace l0op {
18		18
19	OP_TYPE_REGISTER(NonFiniteCheck);	19	OP_TYPE_REGISTER(NonFiniteCheck);
20	}	20	}

Dmath/non_finite_check/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources(OPTYPE non_finite_check ACLNNTYPE aclnn_exclude)

Dmath/non_finite_check/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/non_finite_check/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/non_finite_check/tests/ut/op_host/CMakeLists.txt+0-23

	@@ -1,23 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	if(UT_TEST_ALL OR OP_HOST_UT)
13	add_modules_ut_sources(UT_NAME ${OP_TILING_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
14	add_modules_ut_sources(UT_NAME ${OP_INFERSHAPE_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
15	endif()
16
17	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
18	foreach(SUB_DIR ${CURRENT_DIRS})
19	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
20	add_subdirectory(${SUB_DIR})
21	endif()
22	endforeach()
23

Mmath/pdist/CMakeLists.txt+3-12

	@@ -1,20 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11		10
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE pdist ACLNNTYPE aclnn_exclude)
13	if(NOT ENABLE_TEST AND NOT BENCHMARK)
14	list(REMOVE_ITEM CURRENT_DIRS tests)
15	endif()
16	foreach(SUB_DIR ${CURRENT_DIRS})
17	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
18	add_subdirectory(${SUB_DIR})
19	endif()
20	endforeach()

Rmath/pdist/op_host/op_api/aclnn_pdist.cpp→math/pdist/op_api/aclnn_pdist.cpp+86-82

	@@ -24,118 +24,122 @@
24	#include "opdev/op_log.h"	24	#include "opdev/op_log.h"
25	#include "opdev/tensor_view_utils.h"	25	#include "opdev/tensor_view_utils.h"
26		26
27
28	using namespace op;	27	using namespace op;
29	#ifdef __cplusplus	28	#ifdef __cplusplus
30	extern "C" {	29	extern "C" {
31	#endif	30	#endif
32		31
33	static const std::initializer_list<op::DataType> DTYPE_SUPPORT_LIST = {	32	static const std::initializer_list<op::DataType> DTYPE_SUPPORT_LIST = {op::DataType::DT_FLOAT16,
34	op::DataType::DT_FLOAT16, op::DataType::DT_FLOAT	33	op::DataType::DT_FLOAT};
35	};
36		34
37	inline static bool CheckNotNull(const aclTensor self, const aclTensor out) {	35	inline static bool CheckNotNull(const aclTensor* self, const aclTensor* out)
38	OP_CHECK_NULL(self, return false);	36	{
39	OP_CHECK_NULL(out, return false);	37	OP_CHECK_NULL(self, return false);
40	return true;	38	OP_CHECK_NULL(out, return false);
		39	return true;
41	}	40	}
42		41
43	inline static bool CheckDtypeValid(const aclTensor self, const aclTensor out) {	42	inline static bool CheckDtypeValid(const aclTensor* self, const aclTensor* out)
44	// 检查self的数据类型是否在算子的支持列表内	43	{
45	OP_CHECK_DTYPE_NOT_SUPPORT(self, DTYPE_SUPPORT_LIST, return false);	44	// 检查self的数据类型是否在算子的支持列表内
		45	OP_CHECK_DTYPE_NOT_SUPPORT(self, DTYPE_SUPPORT_LIST, return false);
46		46
47	// 检查out的数据类型是否在算子的支持列表内	47	// 检查out的数据类型是否在算子的支持列表内
48	OP_CHECK_DTYPE_NOT_SUPPORT(out, DTYPE_SUPPORT_LIST, return false);	48	OP_CHECK_DTYPE_NOT_SUPPORT(out, DTYPE_SUPPORT_LIST, return false);
49		49
50	// 检查self和out的数据类型是否相等	50	// 检查self和out的数据类型是否相等
51	OP_CHECK_DTYPE_NOT_SAME(self, out, return false);	51	OP_CHECK_DTYPE_NOT_SAME(self, out, return false);
52	return true;	52	return true;
53	}	53	}
54		54
55	// 检查参数是否符合算子的逻辑	55	// 检查参数是否符合算子的逻辑
56	inline static aclnnStatus CheckParamsLogic(const aclTensor* self, float p, const aclTensor* out) {	56	inline static aclnnStatus CheckParamsLogic(const aclTensor* self, float p, const aclTensor* out)
57	// self的shape要求为2维	57	{
58	OP_CHECK_WRONG_DIMENSION(self, 2, return ACLNN_ERR_PARAM_INVALID);	58	// self的shape要求为2维
		59	OP_CHECK_WRONG_DIMENSION(self, 2, return ACLNN_ERR_PARAM_INVALID);
59		60
60	// out的shape要求为1维	61	// out的shape要求为1维
61	OP_CHECK_WRONG_DIMENSION(out, 1, return ACLNN_ERR_PARAM_INVALID);	62	OP_CHECK_WRONG_DIMENSION(out, 1, return ACLNN_ERR_PARAM_INVALID);
62		63
63	int64_t N = self->GetViewShape().GetDim(0);	64	int64_t N = self->GetViewShape().GetDim(0);
64	op::Shape expectOutShape = {N * (N - 1) / 2};	65	op::Shape expectOutShape = {N * (N - 1) / 2};
65	OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(out, expectOutShape, return ACLNN_ERR_PARAM_INVALID);	66	OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(out, expectOutShape, return ACLNN_ERR_PARAM_INVALID);
66		67
67	// 范数p要求为非负数	68	// 范数p要求为非负数
68	if (p < 0 \|\| std::isnan(p)) {	69	if (p < 0 \|\| std::isnan(p)) {
69	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "pdist only supports non-negative p values.");	70	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "pdist only supports non-negative p values.");
70	return ACLNN_ERR_PARAM_INVALID;	71	return ACLNN_ERR_PARAM_INVALID;
71	}	72	}
72	return ACLNN_SUCCESS;	73	return ACLNN_SUCCESS;
73	}	74	}
74		75
75	inline static aclnnStatus CheckParams(const aclTensor* self, float p, const aclTensor* out) {	76	inline static aclnnStatus CheckParams(const aclTensor* self, float p, const aclTensor* out)
76	// 1. 检查参数是否为空指针	77	{
77	CHECK_COND(CheckNotNull(self, out), ACLNN_ERR_PARAM_NULLPTR, "CheckNotNull failed!");	78	// 1. 检查参数是否为空指针
78	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验	79	CHECK_COND(CheckNotNull(self, out), ACLNN_ERR_PARAM_NULLPTR, "CheckNotNull failed!");
79	CHECK_COND(CheckDtypeValid(self, out), ACLNN_ERR_PARAM_INVALID, "CheckDtypeValid failed!");	80	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验
80	// 3. 检查输入的数据的值是否合理	81	CHECK_COND(CheckDtypeValid(self, out), ACLNN_ERR_PARAM_INVALID, "CheckDtypeValid failed!");
81	CHECK_COND(CheckParamsLogic(self, p, out) == ACLNN_SUCCESS, ACLNN_ERR_PARAM_INVALID, "CheckParamsLogic failed!");	82	// 3. 检查输入的数据的值是否合理
82	return ACLNN_SUCCESS;	83	CHECK_COND(CheckParamsLogic(self, p, out) == ACLNN_SUCCESS, ACLNN_ERR_PARAM_INVALID, "CheckParamsLogic failed!");
		84	return ACLNN_SUCCESS;
83	}	85	}
84		86
85	// 定义aclnnPdist的第一段接口	87	// 定义aclnnPdist的第一段接口
86	aclnnStatus aclnnPdistGetWorkspaceSize(const aclTensor* self, float p, aclTensor* out, uint64_t* workspaceSize,	88	aclnnStatus aclnnPdistGetWorkspaceSize(const aclTensor* self, float p, aclTensor* out, uint64_t* workspaceSize,
87	aclOpExecutor** executor) {	89	aclOpExecutor** executor)
88	OP_CHECK_COMM_INPUT(workspaceSize, executor);	90	{
		91	OP_CHECK_COMM_INPUT(workspaceSize, executor);
89		92
90	L2_DFX_PHASE_1(aclnnPdist, DFX_IN(self, p), DFX_OUT(out));	93	L2_DFX_PHASE_1(aclnnPdist, DFX_IN(self, p), DFX_OUT(out));
91		94
92	// 固定写法，创建OpExecutor	95	// 固定写法，创建OpExecutor
93	auto uniqueExecutor = CREATE_EXECUTOR();	96	auto uniqueExecutor = CREATE_EXECUTOR();
94	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);	97	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
95		98
96	// 参数检查	99	// 参数检查
97	auto ret = CheckParams(self, p, out);	100	auto ret = CheckParams(self, p, out);
98	CHECK_RET(ret == ACLNN_SUCCESS, ret);	101	CHECK_RET(ret == ACLNN_SUCCESS, ret);
99		102
100	const aclTensor* PdistOutRet = nullptr;	103	const aclTensor* PdistOutRet = nullptr;
101	// 2维self的第一维小于等于1，输出0维空tensor;	104	// 2维self的第一维小于等于1，输出0维空tensor;
102	if (self->GetViewShape().GetDim(0) <= 1) {	105	if (self->GetViewShape().GetDim(0) <= 1) {
103	*workspaceSize = 0;	106	*workspaceSize = 0;
		107	uniqueExecutor.ReleaseTo(executor);
		108	return ACLNN_SUCCESS;
		109	} else if (self->GetViewShape().GetDim(1) == 0) {
		110	// 执行L0 Fill算子
		111	aclScalar* scalar = uniqueExecutor.get()->AllocScalar(0);
		112	auto valueTensor = uniqueExecutor.get()->ConvertToTensor(scalar, out->GetDataType());
		113	auto outputDims = op::ToShapeVector(out->GetViewShape());
		114	aclIntArray* dimArray = uniqueExecutor.get()->AllocIntArray(outputDims.data(), outputDims.size());
		115	CHECK_RET(dimArray != nullptr, ACLNN_ERR_INNER_NULLPTR);
		116	auto dimTensor = uniqueExecutor.get()->ConvertToTensor(dimArray, op::DataType::DT_INT64);
		117	PdistOutRet = l0op::Fill(dimTensor, valueTensor, dimArray, uniqueExecutor.get());
		118	} else {
		119	// 固定写法，将输入self转换成连续的tensor
		120	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
		121	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
		122	// 执行L0 Pdist算子
		123	PdistOutRet = l0op::Pdist(selfContiguous, p, uniqueExecutor.get());
		124	}
		125	CHECK_RET(PdistOutRet != nullptr, ACLNN_ERR_INNER_NULLPTR);
		126
		127	// 将计算结果拷贝到输出out上
		128	auto viewCopyResult = l0op::ViewCopy(PdistOutRet, out, uniqueExecutor.get());
		129	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
		130
		131	// 获取计算过程中需要使用的workspace大小
		132	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
		133	// 需要把 uniqueExecutor持有executor转移给executor
104	uniqueExecutor.ReleaseTo(executor);	134	uniqueExecutor.ReleaseTo(executor);
105	return ACLNN_SUCCESS;	135	return ACLNN_SUCCESS;
106	} else if (self->GetViewShape().GetDim(1) == 0) {
107	// 执行L0 Fill算子
108	aclScalar* scalar = uniqueExecutor.get()->AllocScalar(0);
109	auto valueTensor = uniqueExecutor.get()->ConvertToTensor(scalar, out->GetDataType());
110	auto outputDims = op::ToShapeVector(out->GetViewShape());
111	aclIntArray* dimArray = uniqueExecutor.get()->AllocIntArray(outputDims.data(), outputDims.size());
112	CHECK_RET(dimArray != nullptr, ACLNN_ERR_INNER_NULLPTR);
113	auto dimTensor = uniqueExecutor.get()->ConvertToTensor(dimArray, op::DataType::DT_INT64);
114	PdistOutRet = l0op::Fill(dimTensor, valueTensor, dimArray, uniqueExecutor.get());
115	} else {
116	// 固定写法，将输入self转换成连续的tensor
117	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
118	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
119	// 执行L0 Pdist算子
120	PdistOutRet = l0op::Pdist(selfContiguous, p, uniqueExecutor.get());
121	}
122	CHECK_RET(PdistOutRet != nullptr, ACLNN_ERR_INNER_NULLPTR);
123
124	// 将计算结果拷贝到输出out上
125	auto viewCopyResult = l0op::ViewCopy(PdistOutRet, out, uniqueExecutor.get());
126	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
127
128	// 获取计算过程中需要使用的workspace大小
129	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
130	// 需要把 uniqueExecutor持有executor转移给executor
131	uniqueExecutor.ReleaseTo(executor);
132	return ACLNN_SUCCESS;
133	}	136	}
134		137
135	aclnnStatus aclnnPdist(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream) {	138	aclnnStatus aclnnPdist(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
136	L2_DFX_PHASE_2(aclnnPdist);	139	{
137	// 调用框架能力，完成计算	140	L2_DFX_PHASE_2(aclnnPdist);
138	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	141	// 调用框架能力，完成计算
		142	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
139	}	143	}
140		144
141	#ifdef __cplusplus	145	#ifdef __cplusplus

Rmath/pdist/op_host/op_api/aclnn_pdist.h→math/pdist/op_api/aclnn_pdist.h+1-1

	@@ -52,4 +52,4 @@ ACLNN_API aclnnStatus aclnnPdist(void* workspace, uint64_t workspaceSize, aclOpE
52	}	52	}
53	#endif	53	#endif
54		54
55	#endif // OP_API_INC_PDIST_H_	55	#endif // OP_API_INC_PDIST_H_

Rmath/pdist/op_host/op_api/aclnn_pdist_forward.cpp→math/pdist/op_api/aclnn_pdist_forward.cpp+27-23

	@@ -1,19 +1,18 @@
1	/**	1	/**
2	* This program is free software, you can redistribute it and/or modify it.
3	* Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	* This file is a part of the CANN Open Software.	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	* Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	* CANN Open Software License Agreement Version 2.0 (the "License").
6	* Please refer to the License for details. You may not use this file except in compliance with the License.	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
7	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	* BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. See LICENSE in the root of	7	* BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	* the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
10	*/	9	*/
11		10
12	#include "aclnn_pdist_forward.h"	11	#include "aclnn_pdist_forward.h"
13	#include "pdist.h"	12	#include "pdist.h"
14	#include "aclnn_kernels/cast.h"	13	#include "aclnn_kernels/cast.h"
15	#include "aclnn_kernels/contiguous.h"	14	#include "aclnn_kernels/contiguous.h"
16	#include "../../../../conversion/fill/op_api/fill.h"	15	#include "conversion/fill/op_api/fill.h"
17	#include "aclnn_kernels/common/op_error_check.h"	16	#include "aclnn_kernels/common/op_error_check.h"
18	#include "opdev/common_types.h"	17	#include "opdev/common_types.h"
19	#include "opdev/data_type_utils.h"	18	#include "opdev/data_type_utils.h"
	@@ -25,31 +24,32 @@
25	#include "opdev/tensor_view_utils.h"	24	#include "opdev/tensor_view_utils.h"
26	#include "opdev/platform.h"	25	#include "opdev/platform.h"
27		26
28
29	using namespace op;	27	using namespace op;
30	#ifdef __cplusplus	28	#ifdef __cplusplus
31	extern "C" {	29	extern "C" {
32	#endif	30	#endif
33		31
34	static const std::initializer_list<op::DataType> DTYPE_SUPPORT_LIST = {	32	static const std::initializer_list<op::DataType> DTYPE_SUPPORT_LIST = {op::DataType::DT_FLOAT,
35	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16	33	op::DataType::DT_FLOAT16};
36	};
37		34
38	static bool CheckNotNull(const aclTensor self, const aclScalar pScalar, const aclTensor *out) {	35	static bool CheckNotNull(const aclTensor* self, const aclScalar* pScalar, const aclTensor* out)
		36	{
39	OP_CHECK_NULL(self, return false);	37	OP_CHECK_NULL(self, return false);
40	OP_CHECK_NULL(pScalar, return false);	38	OP_CHECK_NULL(pScalar, return false);
41	OP_CHECK_NULL(out, return false);	39	OP_CHECK_NULL(out, return false);
42	return true;	40	return true;
43	}	41	}
44		42
45	static bool CheckDtypeValid(const aclTensor self, const aclTensor out) {	43	static bool CheckDtypeValid(const aclTensor* self, const aclTensor* out)
		44	{
46	OP_CHECK_DTYPE_NOT_SUPPORT(self, DTYPE_SUPPORT_LIST, return false);	45	OP_CHECK_DTYPE_NOT_SUPPORT(self, DTYPE_SUPPORT_LIST, return false);
47	OP_CHECK_DTYPE_NOT_SUPPORT(out, DTYPE_SUPPORT_LIST, return false);	46	OP_CHECK_DTYPE_NOT_SUPPORT(out, DTYPE_SUPPORT_LIST, return false);
48	OP_CHECK_DTYPE_NOT_MATCH(self, out->GetDataType(), return false);	47	OP_CHECK_DTYPE_NOT_MATCH(self, out->GetDataType(), return false);
49	return true;	48	return true;
50	}	49	}
51		50
52	static bool CheckShape(const aclTensor self, const aclTensor out) {	51	static bool CheckShape(const aclTensor* self, const aclTensor* out)
		52	{
53	OP_CHECK_WRONG_DIMENSION(self, 2, return false);	53	OP_CHECK_WRONG_DIMENSION(self, 2, return false);
54	OP_CHECK_WRONG_DIMENSION(out, 1, return false);	54	OP_CHECK_WRONG_DIMENSION(out, 1, return false);
55		55
	@@ -59,7 +59,8 @@ static bool CheckShape(const aclTensor self, const aclTensor out) {
59	return true;	59	return true;
60	}	60	}
61		61
62	static bool CheckPValid(const aclScalar *pScalar) {	62	static bool CheckPValid(const aclScalar* pScalar)
		63	{
63	float pVal = pScalar->ToFloat();	64	float pVal = pScalar->ToFloat();
64	if (pVal < 0) {	65	if (pVal < 0) {
65	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "pScalar only supports non-negative p values.");	66	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "pScalar only supports non-negative p values.");
	@@ -68,7 +69,8 @@ static bool CheckPValid(const aclScalar *pScalar) {
68	return true;	69	return true;
69	}	70	}
70		71
71	static aclnnStatus CheckParams(const aclTensor self, const aclScalar pScalar, const aclTensor *out) {	72	static aclnnStatus CheckParams(const aclTensor* self, const aclScalar* pScalar, const aclTensor* out)
		73	{
72	// 检查参数是否为空指针	74	// 检查参数是否为空指针
73	CHECK_COND(CheckNotNull(self, pScalar, out), ACLNN_ERR_INNER_NULLPTR, "CheckNotNull failed!");	75	CHECK_COND(CheckNotNull(self, pScalar, out), ACLNN_ERR_INNER_NULLPTR, "CheckNotNull failed!");
74		76
	@@ -84,7 +86,8 @@ static aclnnStatus CheckParams(const aclTensor self, const aclScalar pScalar,
84	return ACLNN_SUCCESS;	86	return ACLNN_SUCCESS;
85	}	87	}
86		88
87	static aclnnStatus FillScalar(int64_t shape, aclTensor out, float val, aclOpExecutor executor) {	89	static aclnnStatus FillScalar(int64_t shape, aclTensor* out, float val, aclOpExecutor* executor)
		90	{
88	FVector<int64_t> tmp = {shape};	91	FVector<int64_t> tmp = {shape};
89	auto dims = executor->ConvertToTensor(tmp.data(), tmp.size(), DataType::DT_INT64);	92	auto dims = executor->ConvertToTensor(tmp.data(), tmp.size(), DataType::DT_INT64);
90	auto shapeArray = executor->AllocIntArray(tmp.data(), tmp.size());	93	auto shapeArray = executor->AllocIntArray(tmp.data(), tmp.size());
	@@ -100,15 +103,17 @@ static aclnnStatus FillScalar(int64_t shape, aclTensor *out, float val, aclOpExe
100	return ACLNN_SUCCESS;	103	return ACLNN_SUCCESS;
101	}	104	}
102		105
103	static float CalculateValP(const aclScalar *pScalar) {	106	static float CalculateValP(const aclScalar* pScalar)
		107	{
104	float pVal = pScalar->ToFloat();	108	float pVal = pScalar->ToFloat();
105	return static_cast<float>(pVal);	109	return static_cast<float>(pVal);
106	}	110	}
107		111
108	aclnnStatus aclnnPdistForwardGetWorkspaceSize(const aclTensor* self, const aclScalar* pScalar,	112	aclnnStatus aclnnPdistForwardGetWorkspaceSize(const aclTensor* self, const aclScalar* pScalar, aclTensor* out,
109	aclTensor* out, uint64_t* workspaceSize, aclOpExecutor** executor) {	113	uint64_t* workspaceSize, aclOpExecutor** executor)
		114	{
110	OP_CHECK_COMM_INPUT(workspaceSize, executor);	115	OP_CHECK_COMM_INPUT(workspaceSize, executor);
111		116
112	L2_DFX_PHASE_1(aclnnPdistForward, DFX_IN(self, pScalar), DFX_OUT(out));	117	L2_DFX_PHASE_1(aclnnPdistForward, DFX_IN(self, pScalar), DFX_OUT(out));
113		118
114	// 创建OpExecutor	119	// 创建OpExecutor
	@@ -159,15 +164,14 @@ aclnnStatus aclnnPdistForwardGetWorkspaceSize(const aclTensor* self, const aclSc
159	return ACLNN_SUCCESS;	164	return ACLNN_SUCCESS;
160	}	165	}
161		166
162	aclnnStatus aclnnPdistForward(void workspace, uint64_t workspaceSize, aclOpExecutor executor, aclrtStream stream) {	167	aclnnStatus aclnnPdistForward(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
		168	{
163	L2_DFX_PHASE_2(aclnnPdistForward);	169	L2_DFX_PHASE_2(aclnnPdistForward);
164		170
165	// 调用框架能力，完成计算	171	// 调用框架能力，完成计算
166	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	172	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
167	}	173	}
168		174
169
170	#ifdef __cplusplus	175	#ifdef __cplusplus
171	}	176	}
172	#endif	177	#endif
173

Rmath/pdist/op_host/op_api/aclnn_pdist_forward.h→math/pdist/op_api/aclnn_pdist_forward.h+5-6

	@@ -1,12 +1,11 @@
1	/**	1	/**
2	* This program is free software, you can redistribute it and/or modify it.
3	* Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	* This file is a part of the CANN Open Software.	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	* Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	* CANN Open Software License Agreement Version 2.0 (the "License").
6	* Please refer to the License for details. You may not use this file except in compliance with the License.	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
7	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	* BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. See LICENSE in the root of	7	* BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	* the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
10	*/	9	*/
11		10
12	#ifndef OP_API_INC_PDIST_FORWARD_H_	11	#ifndef OP_API_INC_PDIST_FORWARD_H_
	@@ -36,4 +35,4 @@ ACLNN_API aclnnStatus aclnnPdistForward(void* workspace, uint64_t workspaceSize,
36	}	35	}
37	#endif	36	#endif
38		37
39	#endif	38	#endif

Rmath/pdist/op_host/op_api/pdist.cpp→math/pdist/op_api/pdist.cpp+15-19

	@@ -1,12 +1,11 @@
1	/**	1	/**
2	* This program is free software, you can redistribute it and/or modify it.
3	* Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	* This file is a part of the CANN Open Software.	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	* Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	* CANN Open Software License Agreement Version 2.0 (the "License").
6	* Please refer to the License for details. You may not use this file except in compliance with the License.	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
7	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	* BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. See LICENSE in the root of	7	* BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	* the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
10	*/	9	*/
11		10
12	#include "pdist.h"	11	#include "pdist.h"
	@@ -21,18 +20,15 @@ using namespace op;
21		20
22	namespace l0op {	21	namespace l0op {
23	OP_TYPE_REGISTER(Pdist);	22	OP_TYPE_REGISTER(Pdist);
24	const aclTensor Pdist(const aclTensor self, float p,	23	const aclTensor* Pdist(const aclTensor* self, float p, aclOpExecutor* executor)
25	aclOpExecutor *executor) {	24	{
26	L0_DFX(Pdist, self, p);	25	L0_DFX(Pdist, self, p);
27	auto pdistOut = executor->AllocTensor(self->GetDataType(), op::Format::FORMAT_ND, op::Format::FORMAT_ND);	26	auto pdistOut = executor->AllocTensor(self->GetDataType(), op::Format::FORMAT_ND, op::Format::FORMAT_ND);
28	CHECK_RET(pdistOut != nullptr, nullptr);	27	CHECK_RET(pdistOut != nullptr, nullptr);
29	INFER_SHAPE(Pdist, OP_INPUT(self), OP_OUTPUT(pdistOut), OP_ATTR(p));	28	INFER_SHAPE(Pdist, OP_INPUT(self), OP_OUTPUT(pdistOut), OP_ATTR(p));
30	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(Pdist,	29	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(Pdist, OP_INPUT(self), OP_ATTR(p), OP_OUTPUT(pdistOut));
31	OP_INPUT(self),	30	OP_CHECK(ret == ACLNN_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "PdistAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."),
32	OP_ATTR(p),	31	return nullptr);
33	OP_OUTPUT(pdistOut));	32	return pdistOut;
34	OP_CHECK(ret == ACLNN_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "PdistAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."),
35	return nullptr);
36	return pdistOut;
37	}	33	}
38	}	34	} // namespace l0op

Rmath/pdist/op_host/op_api/pdist.h→math/pdist/op_api/pdist.h+5-6

	@@ -1,12 +1,11 @@
1	/**	1	/**
2	* This program is free software, you can redistribute it and/or modify it.
3	* Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	* This file is a part of the CANN Open Software.	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	* Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	* CANN Open Software License Agreement Version 2.0 (the "License").
6	* Please refer to the License for details. You may not use this file except in compliance with the License.	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
7	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	* BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. See LICENSE in the root of	7	* BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	* the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
10	*/	9	*/
11	#ifndef OP_API_OP_API_COMMON_INC_LEVEL0_OP_PDIST_H_	10	#ifndef OP_API_OP_API_COMMON_INC_LEVEL0_OP_PDIST_H_
12	#define OP_API_OP_API_COMMON_INC_LEVEL0_OP_PDIST_H_	11	#define OP_API_OP_API_COMMON_INC_LEVEL0_OP_PDIST_H_
	@@ -14,7 +13,7 @@
14	#include "opdev/op_executor.h"	13	#include "opdev/op_executor.h"
15		14
16	namespace l0op {	15	namespace l0op {
17	const aclTensor Pdist(const aclTensor input, float p, aclOpExecutor *executor);	16	const aclTensor* Pdist(const aclTensor* input, float p, aclOpExecutor* executor);
18	}	17	}
19		18
20	#endif	19	#endif

Dmath/pdist/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources()

Dmath/pdist/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/pdist/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/pdist/tests/ut/op_host/CMakeLists.txt+0-20

	@@ -1,20 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()
18
19	if(OP_API_UT OR (UT_TEST_ALL AND NOT AICPU_ONLY))
20	endif()

Amath/polar/tests/ut/op_api/test_aclnn_polar.cpp+237-0

@@ -0,0 +1,237 @@
	1	/**
	2	* Copyright (c) 2026 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10	#include <array>
	11	#include <vector>
	12	#include "gtest/gtest.h"
	13
	14	#include "../../../op_api/aclnn_polar.h"
	15	#include "op_api_ut_common/op_api_ut.h"
	16	#include "op_api_ut_common/scalar_desc.h"
	17	#include "op_api_ut_common/tensor_desc.h"
	18	#include "opdev/platform.h"
	19
	20	using namespace std;
	21
	22	class l2_polar_test : public testing::Test {
	23	protected:
	24	static void SetUpTestCase() { cout << "polar_test SetUp" << endl; }
	25
	26	static void TearDownTestCase() { cout << "polar_test TearDown" << endl; }
	27	};
	28
	29	TEST_F(l2_polar_test, case_fp32)
	30	{
	31	// input
	32	auto inputDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	33	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	34	auto outDesc = TensorDesc({1, 2}, ACL_COMPLEX64, ACL_FORMAT_ND).ValueRange(0, 1);
	35
	36	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
	37	// SAMPLE: only test GetWorkspaceSize
	38	uint64_t workspaceSize = 0;
	39	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	40	EXPECT_EQ(aclRet, ACL_SUCCESS);
	41	}
	42
	43	TEST_F(l2_polar_test, case_mismatch_dtype)
	44	{
	45	// input
	46	auto inputDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	47	auto angleDesc = TensorDesc({1, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
	48	auto outDesc = TensorDesc({1, 2}, ACL_COMPLEX64, ACL_FORMAT_ND).ValueRange(0, 1);
	49
	50	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
	51	// SAMPLE: only test GetWorkspaceSize
	52	uint64_t workspaceSize = 0;
	53	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	54	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	55	}
	56
	57	TEST_F(l2_polar_test, case_empty)
	58	{
	59	// input
	60	auto inputDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	61	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	62	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	63
	64	auto ut = OP_API_UT(aclnnPolar, INPUT((aclTensor*)nullptr, angleDesc), OUTPUT(outDesc));
	65	// SAMPLE: only test GetWorkspaceSize
	66	uint64_t workspaceSize = 0;
	67	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	68	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	69	}
	70
	71	TEST_F(l2_polar_test, case_empty2)
	72	{
	73	// input
	74	auto inputDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	75	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	76	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	77
	78	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, (aclTensor*)nullptr), OUTPUT(outDesc));
	79	// SAMPLE: only test GetWorkspaceSize
	80	uint64_t workspaceSize = 0;
	81	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	82	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
	83	}
	84
	85	TEST_F(l2_polar_test, case_unsupport1)
	86	{
	87	// input
	88	auto inputDesc = TensorDesc({1, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
	89	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	90	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	91
	92	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
	93	// SAMPLE: only test GetWorkspaceSize
	94	uint64_t workspaceSize = 0;
	95	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	96	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	97	}
	98
	99	TEST_F(l2_polar_test, case_max_dim1)
	100	{
	101	// input
	102	auto inputDesc = TensorDesc({1, 1, 1, 1, 1, 1, 1, 5, 6}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
	103	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	104	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	105
	106	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
	107	// SAMPLE: only test GetWorkspaceSize
	108	uint64_t workspaceSize = 0;
	109	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	110	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	111	}
	112
	113	TEST_F(l2_polar_test, case_max_dim2)
	114	{
	115	// input
	116	auto inputDesc = TensorDesc({1, 1}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
	117	auto angleDesc = TensorDesc({1, 1, 1, 1, 1, 1, 1, 5, 6}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	118	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	119
	120	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
	121	// SAMPLE: only test GetWorkspaceSize
	122	uint64_t workspaceSize = 0;
	123	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	124	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	125	}
	126
	127	TEST_F(l2_polar_test, case_broadcast_failed)
	128	{
	129	// input
	130	auto inputDesc = TensorDesc({1, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	131	auto angleDesc = TensorDesc({1, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	132	auto outDesc = TensorDesc({1, 4}, ACL_COMPLEX64, ACL_FORMAT_ND).ValueRange(0, 1);
	133
	134	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
	135	// SAMPLE: only test GetWorkspaceSize
	136	uint64_t workspaceSize = 0;
	137	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	138	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	139	}
	140
	141	TEST_F(l2_polar_test, case_max_dim3)
	142	{
	143	// input
	144	auto inputDesc = TensorDesc({1, 1}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
	145	auto angleDesc = TensorDesc({1, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	146	auto outDesc = TensorDesc({1, 1, 1, 1, 1, 1, 1, 5, 6}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	147
	148	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
	149	// SAMPLE: only test GetWorkspaceSize
	150	uint64_t workspaceSize = 0;
	151	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	152	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	153	}
	154
	155	TEST_F(l2_polar_test, case_dim_not_match1)
	156	{
	157	// input
	158	auto inputDesc = TensorDesc({1, 2, 3}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
	159	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	160	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	161
	162	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
	163	// SAMPLE: only test GetWorkspaceSize
	164	uint64_t workspaceSize = 0;
	165	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	166	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	167	}
	168
	169	TEST_F(l2_polar_test, case_dim_not_match2)
	170	{
	171	// input
	172	auto inputDesc = TensorDesc({1, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
	173	auto angleDesc = TensorDesc({1, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	174	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	175
	176	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
	177	// SAMPLE: only test GetWorkspaceSize
	178	uint64_t workspaceSize = 0;
	179	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	180	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	181	}
	182
	183	TEST_F(l2_polar_test, case_dim_not_match3)
	184	{
	185	// input
	186	auto inputDesc = TensorDesc({1, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
	187	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	188	auto outDesc = TensorDesc({1, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	189
	190	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
	191	// SAMPLE: only test GetWorkspaceSize
	192	uint64_t workspaceSize = 0;
	193	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	194	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	195	}
	196
	197	TEST_F(l2_polar_test, case_empty_input_1)
	198	{
	199	// input
	200	auto inputDesc = TensorDesc({0, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
	201	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	202	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	203
	204	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
	205	// SAMPLE: only test GetWorkspaceSize
	206	uint64_t workspaceSize = 0;
	207	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	208	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	209	}
	210
	211	TEST_F(l2_polar_test, case_empty_input_2)
	212	{
	213	// input
	214	auto inputDesc = TensorDesc({1, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
	215	auto angleDesc = TensorDesc({0, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	216	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	217
	218	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
	219	// SAMPLE: only test GetWorkspaceSize
	220	uint64_t workspaceSize = 0;
	221	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	222	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	223	}
	224
	225	TEST_F(l2_polar_test, case_empty_input_3)
	226	{
	227	// input
	228	auto inputDesc = TensorDesc({1, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
	229	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	230	auto outDesc = TensorDesc({0, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
	231
	232	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
	233	// SAMPLE: only test GetWorkspaceSize
	234	uint64_t workspaceSize = 0;
	235	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	236	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	237	}

Dmath/polar/tests/ut/op_api/test_polar.cpp+0-238

	@@ -1,238 +0,0 @@
1	/**
2	* Copyright (c) 2026 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10	#include <array>
11	#include <vector>
12	#include "gtest/gtest.h"
13
14	#include "../../../../op_host/op_api/aclnn_polar.h"
15	#include "op_api_ut_common/op_api_ut.h"
16	#include "op_api_ut_common/scalar_desc.h"
17	#include "op_api_ut_common/tensor_desc.h"
18	#include "opdev/platform.h"
19
20	using namespace std;
21
22	class l2_polar_test : public testing::Test {
23	protected:
24	static void SetUpTestCase() { cout << "polar_test SetUp" << endl; }
25
26	static void TearDownTestCase() { cout << "polar_test TearDown" << endl; }
27	};
28
29	TEST_F(l2_polar_test, case_fp32) {
30	// input
31	auto inputDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
32	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
33	auto outDesc = TensorDesc({1, 2}, ACL_COMPLEX64, ACL_FORMAT_ND).ValueRange(0, 1);
34
35	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
36	// SAMPLE: only test GetWorkspaceSize
37	uint64_t workspaceSize = 0;
38	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
39	EXPECT_EQ(aclRet, ACL_SUCCESS);
40
41	}
42
43	TEST_F(l2_polar_test, case_mismatch_dtype) {
44	// input
45	auto inputDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
46	auto angleDesc = TensorDesc({1, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0,1);
47	auto outDesc = TensorDesc({1, 2}, ACL_COMPLEX64, ACL_FORMAT_ND).ValueRange(0, 1);
48
49	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
50	// SAMPLE: only test GetWorkspaceSize
51	uint64_t workspaceSize = 0;
52	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
53	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
54
55	}
56
57	TEST_F(l2_polar_test, case_empty) {
58	// input
59	auto inputDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
60	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0,1);
61	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
62
63	auto ut = OP_API_UT(aclnnPolar, INPUT((aclTensor*)nullptr, angleDesc), OUTPUT(outDesc));
64	// SAMPLE: only test GetWorkspaceSize
65	uint64_t workspaceSize = 0;
66	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
67	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
68
69	}
70
71	TEST_F(l2_polar_test, case_empty2) {
72	// input
73	auto inputDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
74	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0,1);
75	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
76
77	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, (aclTensor*)nullptr), OUTPUT(outDesc));
78	// SAMPLE: only test GetWorkspaceSize
79	uint64_t workspaceSize = 0;
80	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
81	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
82
83	}
84
85	TEST_F(l2_polar_test, case_unsupport1) {
86	// input
87	auto inputDesc = TensorDesc({1, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
88	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0,1);
89	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
90
91	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
92	// SAMPLE: only test GetWorkspaceSize
93	uint64_t workspaceSize = 0;
94	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
95	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
96
97	}
98
99	TEST_F(l2_polar_test, case_max_dim1) {
100	// input
101	auto inputDesc = TensorDesc({1, 1, 1, 1, 1, 1, 1, 5, 6}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
102	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0,1);
103	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
104
105	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
106	// SAMPLE: only test GetWorkspaceSize
107	uint64_t workspaceSize = 0;
108	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
109	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
110
111	}
112
113	TEST_F(l2_polar_test, case_max_dim2) {
114	// input
115	auto inputDesc = TensorDesc({1, 1}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
116	auto angleDesc = TensorDesc({1, 1, 1, 1, 1, 1, 1, 5, 6}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0,1);
117	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
118
119	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
120	// SAMPLE: only test GetWorkspaceSize
121	uint64_t workspaceSize = 0;
122	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
123	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
124
125	}
126
127	TEST_F(l2_polar_test, case_broadcast_failed) {
128	// input
129	auto inputDesc = TensorDesc({1, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
130	auto angleDesc = TensorDesc({1, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0,1);
131	auto outDesc = TensorDesc({1, 4}, ACL_COMPLEX64, ACL_FORMAT_ND).ValueRange(0, 1);
132
133	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
134	// SAMPLE: only test GetWorkspaceSize
135	uint64_t workspaceSize = 0;
136	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
137	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
138
139	}
140
141
142	TEST_F(l2_polar_test, case_max_dim3) {
143	// input
144	auto inputDesc = TensorDesc({1, 1}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
145	auto angleDesc = TensorDesc({1, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0,1);
146	auto outDesc = TensorDesc({1, 1, 1, 1, 1, 1, 1, 5, 6}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
147
148	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
149	// SAMPLE: only test GetWorkspaceSize
150	uint64_t workspaceSize = 0;
151	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
152	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
153
154	}
155
156	TEST_F(l2_polar_test, case_dim_not_match1) {
157	// input
158	auto inputDesc = TensorDesc({1, 2, 3}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
159	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0,1);
160	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
161
162	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
163	// SAMPLE: only test GetWorkspaceSize
164	uint64_t workspaceSize = 0;
165	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
166	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
167
168	}
169
170	TEST_F(l2_polar_test, case_dim_not_match2) {
171	// input
172	auto inputDesc = TensorDesc({1, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
173	auto angleDesc = TensorDesc({1, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0,1);
174	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
175
176	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
177	// SAMPLE: only test GetWorkspaceSize
178	uint64_t workspaceSize = 0;
179	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
180	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
181
182	}
183
184	TEST_F(l2_polar_test, case_dim_not_match3) {
185	// input
186	auto inputDesc = TensorDesc({1, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
187	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0,1);
188	auto outDesc = TensorDesc({1, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
189
190	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
191	// SAMPLE: only test GetWorkspaceSize
192	uint64_t workspaceSize = 0;
193	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
194	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
195
196	}
197
198	TEST_F(l2_polar_test, case_empty_input_1) {
199	// input
200	auto inputDesc = TensorDesc({0, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
201	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0,1);
202	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
203
204	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
205	// SAMPLE: only test GetWorkspaceSize
206	uint64_t workspaceSize = 0;
207	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
208	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
209
210	}
211
212	TEST_F(l2_polar_test, case_empty_input_2) {
213	// input
214	auto inputDesc = TensorDesc({1, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
215	auto angleDesc = TensorDesc({0, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0,1);
216	auto outDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
217
218	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
219	// SAMPLE: only test GetWorkspaceSize
220	uint64_t workspaceSize = 0;
221	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
222	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
223
224	}
225
226	TEST_F(l2_polar_test, case_empty_input_3) {
227	// input
228	auto inputDesc = TensorDesc({1, 2}, ACL_DOUBLE, ACL_FORMAT_ND).ValueRange(0, 1);
229	auto angleDesc = TensorDesc({1, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0,1);
230	auto outDesc = TensorDesc({0, 2}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 1);
231
232	auto ut = OP_API_UT(aclnnPolar, INPUT(inputDesc, angleDesc), OUTPUT(outDesc));
233	// SAMPLE: only test GetWorkspaceSize
234	uint64_t workspaceSize = 0;
235	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
236	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
237
238	}

Mmath/pow/op_api/aclnn_pow.cpp+505-491

	@@ -11,7 +11,7 @@
11	#include "pow.h"	11	#include "pow.h"
12	#include "aclnn_kernels/contiguous.h"	12	#include "aclnn_kernels/contiguous.h"
13	#include "conversion/fill/op_api/fill.h"	13	#include "conversion/fill/op_api/fill.h"
14	#include "math/pows/op_host/op_api/pows.h"	14	#include "math/pows/op_api/pows.h"
15	#include "aclnn_kernels/cast.h"	15	#include "aclnn_kernels/cast.h"
16	#include "math/square/op_api/square.h"	16	#include "math/square/op_api/square.h"
17	#include "aclnn_kernels/common/op_error_check.h"	17	#include "aclnn_kernels/common/op_error_check.h"
	@@ -42,564 +42,578 @@ const float NEGTIVE_ONE_EXP = -1.0;
42	const float NEGTIVE_SQUARE_EXP = -2.0;	42	const float NEGTIVE_SQUARE_EXP = -2.0;
43		43
44	static const std::initializer_list<op::DataType> DTYPE_SUPPORT_LIST = {	44	static const std::initializer_list<op::DataType> DTYPE_SUPPORT_LIST = {
45	op::DataType::DT_FLOAT, op::DataType::DT_INT32, op::DataType::DT_INT64, op::DataType::DT_FLOAT16,	45	op::DataType::DT_FLOAT, op::DataType::DT_INT32, op::DataType::DT_INT64, op::DataType::DT_FLOAT16,
46	op::DataType::DT_INT8, op::DataType::DT_UINT8, op::DataType::DT_DOUBLE, op::DataType::DT_BOOL,	46	op::DataType::DT_INT8, op::DataType::DT_UINT8, op::DataType::DT_DOUBLE, op::DataType::DT_BOOL,
47	op::DataType::DT_INT16, op::DataType::DT_COMPLEX64, op::DataType::DT_COMPLEX128, op::DataType::DT_BF16};	47	op::DataType::DT_INT16, op::DataType::DT_COMPLEX64, op::DataType::DT_COMPLEX128, op::DataType::DT_BF16};
48		48
49	static const std::initializer_list<op::DataType> SQUARE_NEED_CAST_DTYPE_LIST = {	49	static const std::initializer_list<op::DataType> SQUARE_NEED_CAST_DTYPE_LIST = {
50	op::DataType::DT_INT8, op::DataType::DT_UINT8, op::DataType::DT_BOOL, op::DataType::DT_INT16	50	op::DataType::DT_INT8, op::DataType::DT_UINT8, op::DataType::DT_BOOL, op::DataType::DT_INT16};
51	};
52		51
53	static const std::initializer_list<op::DataType> POWS_DTYPE_SUPPORT_LIST = {	52	static const std::initializer_list<op::DataType> POWS_DTYPE_SUPPORT_LIST = {
54	op::DataType::DT_FLOAT16, op::DataType::DT_FLOAT, op::DataType::DT_BF16	53	op::DataType::DT_FLOAT16, op::DataType::DT_FLOAT, op::DataType::DT_BF16};
55	};
56		54
57	static op::DataType GetScalarDefaultDtype(const op::DataType input) {	55	static op::DataType GetScalarDefaultDtype(const op::DataType input)
58	if (IsComplexType(input)) {	56	{
59	return op::DataType::DT_COMPLEX64;	57	if (IsComplexType(input)) {
60	} else if (IsFloatingType(input)) {	58	return op::DataType::DT_COMPLEX64;
61	return op::DataType::DT_FLOAT;	59	} else if (IsFloatingType(input)) {
62	}	60	return op::DataType::DT_FLOAT;
63	return input;	61	}
64	}	62	return input;
65		63	}
66	static op::DataType InnerTypeToComplexType(const op::DataType input) {	64
67	switch (input) {	65	static op::DataType InnerTypeToComplexType(const op::DataType input)
68	case op::DataType::DT_BF16:	66	{
69	// BFloat16 has range equivalent to Float,	67	switch (input) {
70	// so we map it to ComplexFloat.	68	case op::DataType::DT_BF16:
71	return op::DataType::DT_COMPLEX64;	69	// BFloat16 has range equivalent to Float,
72	case op::DataType::DT_FLOAT16:	70	// so we map it to ComplexFloat.
73	return op::DataType::DT_COMPLEX32;	71	return op::DataType::DT_COMPLEX64;
74	case op::DataType::DT_FLOAT:	72	case op::DataType::DT_FLOAT16:
75	return op::DataType::DT_COMPLEX64;	73	return op::DataType::DT_COMPLEX32;
76	case op::DataType::DT_DOUBLE:	74	case op::DataType::DT_FLOAT:
77	return op::DataType::DT_COMPLEX128;	75	return op::DataType::DT_COMPLEX64;
78	case op::DataType::DT_COMPLEX32:	76	case op::DataType::DT_DOUBLE:
79	return op::DataType::DT_COMPLEX32;	77	return op::DataType::DT_COMPLEX128;
80	case op::DataType::DT_COMPLEX64:	78	case op::DataType::DT_COMPLEX32:
81	return op::DataType::DT_COMPLEX64;	79	return op::DataType::DT_COMPLEX32;
82	case op::DataType::DT_COMPLEX128:	80	case op::DataType::DT_COMPLEX64:
83	return op::DataType::DT_COMPLEX128;	81	return op::DataType::DT_COMPLEX64;
84	default:	82	case op::DataType::DT_COMPLEX128:
85	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Unknown Complex ScalarType for [%s]", ToString(input).GetString());	83	return op::DataType::DT_COMPLEX128;
86	return op::DataType::DT_UNDEFINED;	84	default:
87	}	85	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Unknown Complex ScalarType for [%s]", ToString(input).GetString());
88	}	86	return op::DataType::DT_UNDEFINED;
89		87	}
90	static op::DataType CombineCategoriesWithComplex(const op::DataType higher, const op::DataType lower) {	88	}
91	if(IsComplexType(higher)) {	89
92	return higher;	90	static op::DataType CombineCategoriesWithComplex(const op::DataType higher, const op::DataType lower)
93	} else if (IsComplexType(lower)) {	91	{
94	// preserve value type of higher if it is floating type.	92	if (IsComplexType(higher)) {
95	if (IsFloatingType(higher)) {	93	return higher;
96	return InnerTypeToComplexType(higher);	94	} else if (IsComplexType(lower)) {
		95	// preserve value type of higher if it is floating type.
		96	if (IsFloatingType(higher)) {
		97	return InnerTypeToComplexType(higher);
		98	}
		99	// in case of integral input
		100	// lower complex takes precedence.
		101	return lower;
		102	} else if (IsFloatingType(higher)) {
		103	return higher;
		104	}
		105	if (higher == op::DataType::DT_BOOL \|\| IsFloatingType(lower)) {
		106	return op::PromoteType(higher, lower);
		107	}
		108	if (higher != op::DataType::DT_UNDEFINED) {
		109	return higher;
97	}	110	}
98	// in case of integral input
99	// lower complex takes precedence.
100	return lower;	111	return lower;
101	} else if (IsFloatingType(higher)) {
102	return higher;
103	}
104	if (higher == op::DataType::DT_BOOL \|\| IsFloatingType(lower)) {
105	return op::PromoteType(higher, lower);
106	}
107	if (higher != op::DataType::DT_UNDEFINED) {
108	return higher;
109	}
110	return lower;
111	}	112	}
112		113
113	static bool CheckPowTensorScalarNotNull(const aclTensor self, const aclScalar exponent, const aclTensor *out) {	114	static bool CheckPowTensorScalarNotNull(const aclTensor* self, const aclScalar* exponent, const aclTensor* out)
114	OP_CHECK_NULL(self, return false);	115	{
115	OP_CHECK_NULL(exponent, return false);	116	OP_CHECK_NULL(self, return false);
116	OP_CHECK_NULL(out, return false);	117	OP_CHECK_NULL(exponent, return false);
117	return true;	118	OP_CHECK_NULL(out, return false);
		119	return true;
118	}	120	}
119		121
120	static bool CheckPowScalarTensorNotNull(const aclScalar self, const aclTensor exponent, const aclTensor *out) {	122	static bool CheckPowScalarTensorNotNull(const aclScalar* self, const aclTensor* exponent, const aclTensor* out)
121	OP_CHECK_NULL(self, return false);	123	{
122	OP_CHECK_NULL(exponent, return false);	124	OP_CHECK_NULL(self, return false);
123	OP_CHECK_NULL(out, return false);	125	OP_CHECK_NULL(exponent, return false);
124	return true;	126	OP_CHECK_NULL(out, return false);
		127	return true;
125	}	128	}
126		129
127	static inline bool CheckSocVersionIsSupportBf16(void) {	130	static inline bool CheckSocVersionIsSupportBf16(void)
128	return GetCurrentPlatformInfo().GetSocVersion() >= SocVersion::ASCEND910B &&	131	{
129	GetCurrentPlatformInfo().GetSocVersion() <= SocVersion::ASCEND910E;	132	return GetCurrentPlatformInfo().GetSocVersion() >= SocVersion::ASCEND910B &&
		133	GetCurrentPlatformInfo().GetSocVersion() <= SocVersion::ASCEND910E;
130	}	134	}
131		135
132	// 判断910B芯片上，pow是否走AICPU路径	136	// 判断910B芯片上，pow是否走AICPU路径
133	static inline bool IsPowAiCpuOn910B(const op::DataType dtype, const aclScalar self, const aclTensor exponent) {	137	static inline bool IsPowAiCpuOn910B(const op::DataType dtype, const aclScalar* self, const aclTensor* exponent)
134	auto socVersion = GetCurrentPlatformInfo().GetSocVersion();	138	{
135	if (socVersion < SocVersion::ASCEND910B \|\| socVersion > SocVersion::ASCEND910E) {	139	auto socVersion = GetCurrentPlatformInfo().GetSocVersion();
136	return false;	140	if (socVersion < SocVersion::ASCEND910B \|\| socVersion > SocVersion::ASCEND910E) {
137	}	141	return false;
138	if (IsRegBase()) {
139	return false;
140	}
141	// self或exponent为bool或bf16类型时，不走AICPU路径
142	const auto selfDtype = self->GetDataType();
143	const auto expDtype = exponent->GetDataType();
144	if (selfDtype == op::DataType::DT_BOOL \|\| expDtype == op::DataType::DT_BOOL \|\|
145	selfDtype == op::DataType::DT_BF16 \|\| expDtype == op::DataType::DT_BF16) {
146	return false;
147	}
148	// 910B AICORE支持的dtype
149	static const std::initializer_list<op::DataType> AICORE_DTYPE_LIST = {
150	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_INT32,
151	op::DataType::DT_INT8, op::DataType::DT_UINT8, op::DataType::DT_BF16};
152	return !CheckType(dtype, AICORE_DTYPE_LIST);
153	}
154
155	static bool CheckDtypeValid(const op::DataType selfDtype, const op::DataType expDtype, const op::DataType outDtype) {
156	if (!CheckSocVersionIsSupportBf16() &&
157	(selfDtype == op::DataType::DT_BF16 \|\| expDtype == op::DataType::DT_BF16)) {
158	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Input dtype of pow is not support bfloat16 in current socversion.");
159	return false;
160	}
161	if (!CheckType(selfDtype, DTYPE_SUPPORT_LIST)) {
162	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Self dtype %s should be in dtype support list %s.",
163	op::ToString(selfDtype).GetString(), op::ToString(DTYPE_SUPPORT_LIST).GetString());
164	return false;
165	}
166	if (!CheckType(expDtype, DTYPE_SUPPORT_LIST)) {
167	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "exp dtype %s should be in dtype support list %s.",
168	op::ToString(expDtype).GetString(), op::ToString(DTYPE_SUPPORT_LIST).GetString());
169	return false;
170	}
171	// 检查self和exponent能否做数据类型推导
172	op::DataType promoteType = op::PromoteType(selfDtype, expDtype);
173	if (promoteType == DataType::DT_UNDEFINED) {
174	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "self dtype %s and exponent dtype %s can not promote dtype.",
175	op::ToString(selfDtype).GetString(), op::ToString(expDtype).GetString());
176	return false;
177	}
178	OP_CHECK_RESULT_DTYPE_CAST_FAILED(promoteType, outDtype, return false);
179	return true;
180	}
181
182	static inline bool isFloatType(const DataType type) {
183	return type == op::DataType::DT_DOUBLE \|\| type == op::DataType::DT_FLOAT \|\|
184	type == op::DataType::DT_FLOAT16 \|\| type == op::DataType::DT_BF16;
185	}
186
187	static inline op::DataType InferTensorScalarDtype(const aclTensor self, const aclScalar exponent,
188	const aclTensor *out) {
189	if (IsRegBase()) {
190	auto scalarDefaultDtype = GetScalarDefaultDtype(exponent->GetDataType());
191	auto promoteType = CombineCategoriesWithComplex(self->GetDataType(), scalarDefaultDtype);
192	if (promoteType == DataType::DT_COMPLEX32) {
193	promoteType = DataType::DT_COMPLEX64;
194	}	142	}
195	return promoteType;	143	if (IsRegBase()) {
196	}	144	return false;
197	if (exponent->GetDataType() == op::DataType::DT_DOUBLE && out->GetDataType() == op::DataType::DT_FLOAT) {	145	}
198	return op::DataType::DT_FLOAT;	146	// self或exponent为bool或bf16类型时，不走AICPU路径
199	}	147	const auto selfDtype = self->GetDataType();
200		148	const auto expDtype = exponent->GetDataType();
201	if (IsComplexType(exponent->GetDataType())) {	149	if (selfDtype == op::DataType::DT_BOOL \|\| expDtype == op::DataType::DT_BOOL \|\| selfDtype == op::DataType::DT_BF16 \|\|
202	return PromoteType(self->GetDataType(), exponent->GetDataType());	150	expDtype == op::DataType::DT_BF16) {
203	}	151	return false;
204	return isFloatType(self->GetDataType()) ? self->GetDataType() :	152	}
205	((isFloatType(exponent->GetDataType()) \|\| self->GetDataType() == op::DataType::DT_BOOL) ?	153	// 910B AICORE支持的dtype
206	PromoteType(self->GetDataType(), exponent->GetDataType()) : self->GetDataType());	154	static const std::initializer_list<op::DataType> AICORE_DTYPE_LIST = {
		155	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_INT32,
		156	op::DataType::DT_INT8, op::DataType::DT_UINT8, op::DataType::DT_BF16};
		157	return !CheckType(dtype, AICORE_DTYPE_LIST);
207	}	158	}
208		159
209	static inline op::DataType InferScalarTensorDtype(const aclScalar self, const aclTensor exponent,	160	static bool CheckDtypeValid(const op::DataType selfDtype, const op::DataType expDtype, const op::DataType outDtype)
210	const aclTensor *out) {	161	{
211	if (IsRegBase()) {	162	if (!CheckSocVersionIsSupportBf16() && (selfDtype == op::DataType::DT_BF16 \|\| expDtype == op::DataType::DT_BF16)) {
212	auto scalarDefaultDtype = GetScalarDefaultDtype(self->GetDataType());	163	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Input dtype of pow is not support bfloat16 in current socversion.");
213	auto promoteType = CombineCategoriesWithComplex(exponent->GetDataType(), scalarDefaultDtype);	164	return false;
214	if (promoteType == DataType::DT_COMPLEX32) {
215	promoteType = DataType::DT_COMPLEX64;
216	}	165	}
217	return promoteType;	166	if (!CheckType(selfDtype, DTYPE_SUPPORT_LIST)) {
218	}	167	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Self dtype %s should be in dtype support list %s.",
219	if (exponent->GetDataType() == op::DataType::DT_DOUBLE && out->GetDataType() == op::DataType::DT_FLOAT) {	168	op::ToString(selfDtype).GetString(), op::ToString(DTYPE_SUPPORT_LIST).GetString());
220	return op::DataType::DT_FLOAT;	169	return false;
221	}	170	}
		171	if (!CheckType(expDtype, DTYPE_SUPPORT_LIST)) {
		172	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "exp dtype %s should be in dtype support list %s.",
		173	op::ToString(expDtype).GetString(), op::ToString(DTYPE_SUPPORT_LIST).GetString());
		174	return false;
		175	}
		176	// 检查self和exponent能否做数据类型推导
		177	op::DataType promoteType = op::PromoteType(selfDtype, expDtype);
		178	if (promoteType == DataType::DT_UNDEFINED) {
		179	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "self dtype %s and exponent dtype %s can not promote dtype.",
		180	op::ToString(selfDtype).GetString(), op::ToString(expDtype).GetString());
		181	return false;
		182	}
		183	OP_CHECK_RESULT_DTYPE_CAST_FAILED(promoteType, outDtype, return false);
		184	return true;
		185	}
222		186
223	if (IsComplexType(self->GetDataType())) {	187	static inline bool isFloatType(const DataType type)
224	return PromoteType(self->GetDataType(), exponent->GetDataType());	188	{
225	}	189	return type == op::DataType::DT_DOUBLE \|\| type == op::DataType::DT_FLOAT \|\| type == op::DataType::DT_FLOAT16 \|\|
226	return isFloatType(exponent->GetDataType()) ? exponent->GetDataType() :	190	type == op::DataType::DT_BF16;
227	((isFloatType(self->GetDataType()) \|\| exponent->GetDataType() == op::DataType::DT_BOOL) ?	191	}
228	PromoteType(exponent->GetDataType(), self->GetDataType()) : exponent->GetDataType());	192
		193	static inline op::DataType InferTensorScalarDtype(const aclTensor* self, const aclScalar* exponent,
		194	const aclTensor* out)
		195	{
		196	if (IsRegBase()) {
		197	auto scalarDefaultDtype = GetScalarDefaultDtype(exponent->GetDataType());
		198	auto promoteType = CombineCategoriesWithComplex(self->GetDataType(), scalarDefaultDtype);
		199	if (promoteType == DataType::DT_COMPLEX32) {
		200	promoteType = DataType::DT_COMPLEX64;
		201	}
		202	return promoteType;
		203	}
		204	if (exponent->GetDataType() == op::DataType::DT_DOUBLE && out->GetDataType() == op::DataType::DT_FLOAT) {
		205	return op::DataType::DT_FLOAT;
		206	}
		207
		208	if (IsComplexType(exponent->GetDataType())) {
		209	return PromoteType(self->GetDataType(), exponent->GetDataType());
		210	}
		211	return isFloatType(self->GetDataType()) ?
		212	self->GetDataType() :
		213	((isFloatType(exponent->GetDataType()) \|\| self->GetDataType() == op::DataType::DT_BOOL) ?
		214	PromoteType(self->GetDataType(), exponent->GetDataType()) :
		215	self->GetDataType());
		216	}
		217
		218	static inline op::DataType InferScalarTensorDtype(const aclScalar* self, const aclTensor* exponent,
		219	const aclTensor* out)
		220	{
		221	if (IsRegBase()) {
		222	auto scalarDefaultDtype = GetScalarDefaultDtype(self->GetDataType());
		223	auto promoteType = CombineCategoriesWithComplex(exponent->GetDataType(), scalarDefaultDtype);
		224	if (promoteType == DataType::DT_COMPLEX32) {
		225	promoteType = DataType::DT_COMPLEX64;
		226	}
		227	return promoteType;
		228	}
		229	if (exponent->GetDataType() == op::DataType::DT_DOUBLE && out->GetDataType() == op::DataType::DT_FLOAT) {
		230	return op::DataType::DT_FLOAT;
		231	}
		232
		233	if (IsComplexType(self->GetDataType())) {
		234	return PromoteType(self->GetDataType(), exponent->GetDataType());
		235	}
		236	return isFloatType(exponent->GetDataType()) ?
		237	exponent->GetDataType() :
		238	((isFloatType(self->GetDataType()) \|\| exponent->GetDataType() == op::DataType::DT_BOOL) ?
		239	PromoteType(exponent->GetDataType(), self->GetDataType()) :
		240	exponent->GetDataType());
229	}	241	}
230		242
231	static bool CheckPromoteType(const op::DataType selfDtype, const op::DataType exponentDtype,	243	static bool CheckPromoteType(const op::DataType selfDtype, const op::DataType exponentDtype,
232	const op::DataType outDtype, op::DataType promoteType) {	244	const op::DataType outDtype, op::DataType promoteType)
233	if (promoteType == op::DataType::DT_UNDEFINED) {	245	{
234	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Self dtype %s and exponent dtype %s can not promote dtype.",	246	if (promoteType == op::DataType::DT_UNDEFINED) {
235	op::ToString(selfDtype).GetString(), op::ToString(exponentDtype).GetString());	247	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Self dtype %s and exponent dtype %s can not promote dtype.",
236	return false;	248	op::ToString(selfDtype).GetString(), op::ToString(exponentDtype).GetString());
237	}	249	return false;
238	if ((selfDtype == op::DataType::DT_BOOL) && (exponentDtype == op::DataType::DT_BOOL)) {	250	}
239	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Self and exponent dtype are bool is not supported.");	251	if ((selfDtype == op::DataType::DT_BOOL) && (exponentDtype == op::DataType::DT_BOOL)) {
240	return false;	252	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Self and exponent dtype are bool is not supported.");
241	}	253	return false;
242	OP_CHECK_RESULT_DTYPE_CAST_FAILED(promoteType, outDtype, return false);	254	}
243	return true;	255	OP_CHECK_RESULT_DTYPE_CAST_FAILED(promoteType, outDtype, return false);
		256	return true;
244	}	257	}
245		258
246	static bool CheckShape(const aclTensor self, const aclTensor out) {	259	static bool CheckShape(const aclTensor* self, const aclTensor* out)
247	OP_CHECK_MAX_DIM(self, MAX_SUPPORT_DIMS_NUMS, return false);	260	{
248	OP_CHECK_SHAPE_NOT_EQUAL(self, out, return false);	261	OP_CHECK_MAX_DIM(self, MAX_SUPPORT_DIMS_NUMS, return false);
249	return true;	262	OP_CHECK_SHAPE_NOT_EQUAL(self, out, return false);
		263	return true;
250	}	264	}
251		265
252	static aclnnStatus CheckPowTensorScalarParams(const aclTensor self, const aclScalar exponent,	266	static aclnnStatus CheckPowTensorScalarParams(const aclTensor* self, const aclScalar* exponent, const aclTensor* out)
253	const aclTensor *out) {	267	{
254	// 1. 检查参数是否为空指针	268	// 1. 检查参数是否为空指针
255	CHECK_RET(CheckPowTensorScalarNotNull(self, exponent, out), ACLNN_ERR_PARAM_NULLPTR);	269	CHECK_RET(CheckPowTensorScalarNotNull(self, exponent, out), ACLNN_ERR_PARAM_NULLPTR);
256		270
257	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验	271	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验
258	CHECK_RET(CheckDtypeValid(self->GetDataType(), exponent->GetDataType(), out->GetDataType()),	272	CHECK_RET(CheckDtypeValid(self->GetDataType(), exponent->GetDataType(), out->GetDataType()),
259	ACLNN_ERR_PARAM_INVALID);	273	ACLNN_ERR_PARAM_INVALID);
260		274
261	op::DataType promoteType = InferTensorScalarDtype(self, exponent, out);	275	op::DataType promoteType = InferTensorScalarDtype(self, exponent, out);
262	CHECK_RET(CheckPromoteType(self->GetDataType(), exponent->GetDataType(), out->GetDataType(), promoteType),	276	CHECK_RET(CheckPromoteType(self->GetDataType(), exponent->GetDataType(), out->GetDataType(), promoteType),
263	ACLNN_ERR_PARAM_INVALID);	277	ACLNN_ERR_PARAM_INVALID);
264		278
265	// 3. 检查输入shape	279	// 3. 检查输入shape
266	CHECK_RET(CheckShape(self, out), ACLNN_ERR_PARAM_INVALID);	280	CHECK_RET(CheckShape(self, out), ACLNN_ERR_PARAM_INVALID);
267		281
268	return ACLNN_SUCCESS;
269	}
270
271	static bool CheckPowTensorScalarExponet(const DataType inputDtype, const aclScalar* exponent) {
272	// promoteType为整形的情况，exponent需要大于0
273	if (IsIntegralType(inputDtype) && (exponent->ToInt64() < 0)) {
274	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Base dtype is intergal and exponent negative integers is not allowed.");
275	return false;
276	}
277	return true;;
278	}
279
280	static bool CheckNotOverflow(const DataType pmtType, const aclScalar *exponent) {
281	int8_t overFlowFlag = 1;
282	int8_t floatFlag = 1;
283	int8_t intFlag = 2;
284	int8_t complexFlag = 3;
285
286	switch (pmtType) {
287	case op::DataType::DT_FLOAT: {
288	overFlowFlag = exponent->CheckOverflows<float>() ? overFlowFlag << floatFlag : overFlowFlag;
289	break;
290	}
291	case op::DataType::DT_FLOAT16: {
292	overFlowFlag = exponent->CheckOverflows<op::fp16_t>() ? overFlowFlag << floatFlag : overFlowFlag;
293	break;
294	}
295	case op::DataType::DT_BF16: {
296	overFlowFlag = exponent->CheckOverflows<op::bfloat16>() ? overFlowFlag << floatFlag : overFlowFlag;
297	break;
298	}
299	case op::DataType::DT_INT8: {
300	overFlowFlag = exponent->CheckOverflows<int8_t>() ? overFlowFlag << intFlag : overFlowFlag;
301	break;
302	}
303	case op::DataType::DT_INT16: {
304	overFlowFlag = exponent->CheckOverflows<int16_t>() ? overFlowFlag << intFlag : overFlowFlag;
305	break;
306	}
307	case op::DataType::DT_INT32: {
308	overFlowFlag = exponent->CheckOverflows<int32_t>() ? overFlowFlag << intFlag : overFlowFlag;
309	break;
310	}
311	case op::DataType::DT_INT64: {
312	overFlowFlag = exponent->CheckOverflows<int64_t>() ? overFlowFlag << intFlag : overFlowFlag;
313	break;
314	}
315	case op::DataType::DT_UINT8: {
316	overFlowFlag = exponent->CheckOverflows<uint8_t>() ? overFlowFlag << intFlag : overFlowFlag;
317	break;
318	}
319	case op::DataType::DT_COMPLEX32:
320	case op::DataType::DT_COMPLEX64: {
321	overFlowFlag = exponent->CheckOverflows<std::complex<float>>() ? overFlowFlag << complexFlag : overFlowFlag;
322	break;
323	}
324	default: {
325	return true;
326	}
327	}
328
329	if ((overFlowFlag >> floatFlag) == 1) {
330	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "exponent value cannot be converted to promote type %s without overflow: %lf.",
331	op::ToString(pmtType).GetString(), exponent->ToDouble());
332	} else if ((overFlowFlag >> intFlag) == 1) {
333	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "exponent value cannot be converted to promote type %s without overflow: %ld.",
334	op::ToString(pmtType).GetString(), exponent->ToInt64());
335	} else if ((overFlowFlag >> complexFlag) == 1) {
336	OP_LOGE(ACLNN_ERR_PARAM_INVALID,
337	"exponent value cannot be converted to promote type %s without overflow: real is %f, imag is %f.",
338	op::ToString(pmtType).GetString(), exponent->ToComplex64().real(), exponent->ToComplex64().imag());
339	}
340	return overFlowFlag == 1;
341	}
342
343	static aclnnStatus CheckPowScalarTensorParams(const aclScalar self, const aclTensor exponent,
344	const aclTensor *out) {
345	// 1. 检查参数是否为空指针
346	CHECK_RET(CheckPowScalarTensorNotNull(self, exponent, out), ACLNN_ERR_PARAM_NULLPTR);
347
348	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验
349	CHECK_RET(CheckDtypeValid(self->GetDataType(), exponent->GetDataType(), out->GetDataType()),
350	ACLNN_ERR_PARAM_INVALID);
351
352	op::DataType promoteType = InferScalarTensorDtype(self, exponent, out);
353	CHECK_RET(CheckPromoteType(self->GetDataType(), exponent->GetDataType(), out->GetDataType(), promoteType),
354	ACLNN_ERR_PARAM_INVALID);
355
356	// 3. 检查输入shape
357	CHECK_RET(CheckShape(exponent, out), ACLNN_ERR_PARAM_INVALID);
358
359	return ACLNN_SUCCESS;
360	}
361
362	static bool CheckSupportPows(const aclTensor selfCast, const aclScalar exponent) {
363	if (exponent->ToFloat() != SQRT_EXP && exponent->ToFloat() != SQUARE_EXP &&
364	exponent->ToFloat() != CUBE_EXP && exponent->ToFloat() != NEGTIVE_SQRT_EXP &&
365	exponent->ToFloat() != NEGTIVE_ONE_EXP && exponent->ToFloat() != NEGTIVE_SQUARE_EXP) {
366	return false;
367	}
368
369	if (!CheckType(selfCast->GetDataType(), POWS_DTYPE_SUPPORT_LIST)) {
370	return false;
371	}
372
373	if(GetCurrentPlatformInfo().GetSocVersion() != SocVersion::ASCEND310P &&
374	GetCurrentPlatformInfo().GetSocVersion() != SocVersion::ASCEND910B &&
375	GetCurrentPlatformInfo().GetSocVersion() != SocVersion::ASCEND910_93) {
376	return false;
377	}
378
379	return true;
380	}
381
382	static void CheckFormat(const aclTensor* self){
383	ge::Format selfStorageFormat = self->GetStorageFormat();
384	if (selfStorageFormat != ge::Format::FORMAT_ND){
385	OP_LOGW("aclnnPowTensorScalar/aclnnInplacePowTensorScalar only support format ND.");
386	}
387	}
388
389	aclnnStatus aclnnPowTensorScalarGetWorkspaceSize(const aclTensor *self,
390	const aclScalar *exponent,
391	const aclTensor *out,
392	uint64_t *workspaceSize,
393	aclOpExecutor **executor) {
394	L2_DFX_PHASE_1(aclnnPowTensorScalar, DFX_IN(self, exponent), DFX_OUT(out));
395
396	// 固定写法，创建OpExecutor
397	auto uniqueExecutor = CREATE_EXECUTOR();
398	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
399
400	// 固定写法，参数检查
401	auto ret = CheckPowTensorScalarParams(self, exponent, out);
402	CHECK_RET(ret == ACLNN_SUCCESS, ret);
403
404	CheckFormat(self);
405
406	// pow算子的空tensor在kernel中支持，对标竞品根据算子实际情况补充
407	if (self->IsEmpty()) {
408	*workspaceSize = 0;
409	uniqueExecutor.ReleaseTo(executor);
410	return ACLNN_SUCCESS;	282	return ACLNN_SUCCESS;
411	}	283	}
412	auto promoteType = InferTensorScalarDtype(self, exponent, out);	284
413	if (IsRegBase()) {	285	static bool CheckPowTensorScalarExponet(const DataType inputDtype, const aclScalar* exponent)
		286	{
414	// promoteType为整形的情况，exponent需要大于0	287	// promoteType为整形的情况，exponent需要大于0
415	CHECK_RET(CheckPowTensorScalarExponet(promoteType, exponent), ACLNN_ERR_PARAM_INVALID);	288	if (IsIntegralType(inputDtype) && (exponent->ToInt64() < 0)) {
416		289	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Base dtype is intergal and exponent negative integers is not allowed.");
417	// 检查exponent是否溢出	290	return false;
418	CHECK_RET(CheckNotOverflow(promoteType, exponent), ACLNN_ERR_PARAM_INVALID);
419	}
420	// 固定写法，将输入self转换成连续的tensor
421	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
422	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
423
424	auto selfCast = l0op::Cast(selfContiguous, promoteType, uniqueExecutor.get());
425	CHECK_RET(selfCast != nullptr, ACLNN_ERR_INNER_NULLPTR);
426
427	aclTensor* powOut = nullptr;
428	bool canUseSquare =
429	static_cast<float>(exponent->ToFloat()) == SQUARE_EXP &&
430	(!IsRegBase() \|\|
431	(IsRegBase() && (selfCast->GetDataType() == op::DataType::DT_FLOAT \|\|
432	selfCast->GetDataType() == op::DataType::DT_BF16 \|\|
433	selfCast->GetDataType() == op::DataType::DT_FLOAT16 \|\|
434	selfCast->GetDataType() == op::DataType::DT_INT64 \|\|
435	selfCast->GetDataType() == op::DataType::DT_COMPLEX64 \|\|
436	selfCast->GetDataType() == op::DataType::DT_COMPLEX128)));
437	bool canNoUseOp = static_cast<float>(exponent->ToFloat()) == NOOP_EXP && !IsRegBase();
438	if (CheckSupportPows(selfCast, exponent)) {
439	auto expTensor = uniqueExecutor.get()->ConvertToTensor(exponent, promoteType);
440	CHECK_RET(expTensor != nullptr, ACLNN_ERR_INNER_NULLPTR);
441	// 调用pows进行计算
442	powOut = const_cast<aclTensor *>(l0op::Pows(selfCast, expTensor, uniqueExecutor.get()));
443	} else if (canUseSquare) {
444	const aclTensor *squareInput = selfCast;
445	if (CheckType(selfCast->GetDataType(), SQUARE_NEED_CAST_DTYPE_LIST)) {
446	squareInput = l0op::Cast(selfCast, op::DataType::DT_INT32, uniqueExecutor.get());
447	CHECK_RET(squareInput != nullptr, ACLNN_ERR_INNER_NULLPTR);
448	}	291	}
449	// 当exponent为2.0时，使用square算子计算	292	return true;
450	powOut = const_cast<aclTensor *>(l0op::Square(squareInput, uniqueExecutor.get()));	293	;
451	} else if (canNoUseOp) {
452	powOut = const_cast<aclTensor *>(selfCast);
453	} else {
454	auto expTensor = uniqueExecutor.get()->ConvertToTensor(exponent, promoteType);
455	CHECK_RET(expTensor != nullptr, ACLNN_ERR_INNER_NULLPTR);
456
457	// 调用pow进行计算
458	powOut = const_cast<aclTensor *>(l0op::Pow(selfCast, expTensor, uniqueExecutor.get()));
459	}
460	CHECK_RET(powOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
461
462	// 固定写法，将计算结果转换成输出out的数据类型
463	auto castOut = l0op::Cast(powOut, out->GetDataType(), uniqueExecutor.get());
464	CHECK_RET(castOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
465
466	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor
467	auto viewCopyResult = l0op::ViewCopy(castOut, out, uniqueExecutor.get());
468	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
469
470	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
471	uniqueExecutor.ReleaseTo(executor);
472
473	return ACLNN_SUCCESS;
474	}	294	}
475		295
476	aclnnStatus aclnnPowTensorScalar(void workspace, uint64_t workspaceSize, aclOpExecutor executor,	296	static bool CheckNotOverflow(const DataType pmtType, const aclScalar* exponent)
477	const aclrtStream stream) {	297	{
478	L2_DFX_PHASE_2(aclnnPowTensorScalar);	298	int8_t overFlowFlag = 1;
479	// 固定写法，调用框架能力，完成计算	299	int8_t floatFlag = 1;
480	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	300	int8_t intFlag = 2;
		301	int8_t complexFlag = 3;
		302
		303	switch (pmtType) {
		304	case op::DataType::DT_FLOAT: {
		305	overFlowFlag = exponent->CheckOverflows<float>() ? overFlowFlag << floatFlag : overFlowFlag;
		306	break;
		307	}
		308	case op::DataType::DT_FLOAT16: {
		309	overFlowFlag = exponent->CheckOverflows<op::fp16_t>() ? overFlowFlag << floatFlag : overFlowFlag;
		310	break;
		311	}
		312	case op::DataType::DT_BF16: {
		313	overFlowFlag = exponent->CheckOverflows<op::bfloat16>() ? overFlowFlag << floatFlag : overFlowFlag;
		314	break;
		315	}
		316	case op::DataType::DT_INT8: {
		317	overFlowFlag = exponent->CheckOverflows<int8_t>() ? overFlowFlag << intFlag : overFlowFlag;
		318	break;
		319	}
		320	case op::DataType::DT_INT16: {
		321	overFlowFlag = exponent->CheckOverflows<int16_t>() ? overFlowFlag << intFlag : overFlowFlag;
		322	break;
		323	}
		324	case op::DataType::DT_INT32: {
		325	overFlowFlag = exponent->CheckOverflows<int32_t>() ? overFlowFlag << intFlag : overFlowFlag;
		326	break;
		327	}
		328	case op::DataType::DT_INT64: {
		329	overFlowFlag = exponent->CheckOverflows<int64_t>() ? overFlowFlag << intFlag : overFlowFlag;
		330	break;
		331	}
		332	case op::DataType::DT_UINT8: {
		333	overFlowFlag = exponent->CheckOverflows<uint8_t>() ? overFlowFlag << intFlag : overFlowFlag;
		334	break;
		335	}
		336	case op::DataType::DT_COMPLEX32:
		337	case op::DataType::DT_COMPLEX64: {
		338	overFlowFlag = exponent->CheckOverflows<std::complex<float>>() ? overFlowFlag << complexFlag : overFlowFlag;
		339	break;
		340	}
		341	default: {
		342	return true;
		343	}
		344	}
		345
		346	if ((overFlowFlag >> floatFlag) == 1) {
		347	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "exponent value cannot be converted to promote type %s without overflow: %lf.",
		348	op::ToString(pmtType).GetString(), exponent->ToDouble());
		349	} else if ((overFlowFlag >> intFlag) == 1) {
		350	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "exponent value cannot be converted to promote type %s without overflow: %ld.",
		351	op::ToString(pmtType).GetString(), exponent->ToInt64());
		352	} else if ((overFlowFlag >> complexFlag) == 1) {
		353	OP_LOGE(ACLNN_ERR_PARAM_INVALID,
		354	"exponent value cannot be converted to promote type %s without overflow: real is %f, imag is %f.",
		355	op::ToString(pmtType).GetString(), exponent->ToComplex64().real(), exponent->ToComplex64().imag());
		356	}
		357	return overFlowFlag == 1;
481	}	358	}
482		359
483	aclnnStatus aclnnInplacePowTensorScalarGetWorkspaceSize(const aclTensor *self,	360	static aclnnStatus CheckPowScalarTensorParams(const aclScalar* self, const aclTensor* exponent, const aclTensor* out)
484	const aclScalar *exponent,	361	{
485	uint64_t *workspaceSize,	362	// 1. 检查参数是否为空指针
486	aclOpExecutor **executor) {	363	CHECK_RET(CheckPowScalarTensorNotNull(self, exponent, out), ACLNN_ERR_PARAM_NULLPTR);
487	auto out = const_cast<aclTensor*>(self);	364
488	return aclnnPowTensorScalarGetWorkspaceSize(self, exponent, out, workspaceSize, executor);	365	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验
		366	CHECK_RET(CheckDtypeValid(self->GetDataType(), exponent->GetDataType(), out->GetDataType()),
		367	ACLNN_ERR_PARAM_INVALID);
		368
		369	op::DataType promoteType = InferScalarTensorDtype(self, exponent, out);
		370	CHECK_RET(CheckPromoteType(self->GetDataType(), exponent->GetDataType(), out->GetDataType(), promoteType),
		371	ACLNN_ERR_PARAM_INVALID);
		372
		373	// 3. 检查输入shape
		374	CHECK_RET(CheckShape(exponent, out), ACLNN_ERR_PARAM_INVALID);
		375
		376	return ACLNN_SUCCESS;
489	}	377	}
490		378
491	aclnnStatus aclnnInplacePowTensorScalar(void workspace, uint64_t workspaceSize, aclOpExecutor executor,	379	static bool CheckSupportPows(const aclTensor* selfCast, const aclScalar* exponent)
492	aclrtStream stream) {	380	{
493	L2_DFX_PHASE_2(aclnnInplacePowTensorScalar);	381	if (exponent->ToFloat() != SQRT_EXP && exponent->ToFloat() != SQUARE_EXP && exponent->ToFloat() != CUBE_EXP &&
494	// 固定写法，调用框架能力，完成计算	382	exponent->ToFloat() != NEGTIVE_SQRT_EXP && exponent->ToFloat() != NEGTIVE_ONE_EXP &&
495	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	383	exponent->ToFloat() != NEGTIVE_SQUARE_EXP) {
		384	return false;
		385	}
		386
		387	if (!CheckType(selfCast->GetDataType(), POWS_DTYPE_SUPPORT_LIST)) {
		388	return false;
		389	}
		390
		391	if (GetCurrentPlatformInfo().GetSocVersion() != SocVersion::ASCEND310P &&
		392	GetCurrentPlatformInfo().GetSocVersion() != SocVersion::ASCEND910B &&
		393	GetCurrentPlatformInfo().GetSocVersion() != SocVersion::ASCEND910_93) {
		394	return false;
		395	}
		396
		397	return true;
		398	}
		399
		400	static void CheckFormat(const aclTensor* self)
		401	{
		402	ge::Format selfStorageFormat = self->GetStorageFormat();
		403	if (selfStorageFormat != ge::Format::FORMAT_ND) {
		404	OP_LOGW("aclnnPowTensorScalar/aclnnInplacePowTensorScalar only support format ND.");
		405	}
		406	}
		407
		408	aclnnStatus aclnnPowTensorScalarGetWorkspaceSize(const aclTensor* self, const aclScalar* exponent, const aclTensor* out,
		409	uint64_t* workspaceSize, aclOpExecutor** executor)
		410	{
		411	L2_DFX_PHASE_1(aclnnPowTensorScalar, DFX_IN(self, exponent), DFX_OUT(out));
		412
		413	// 固定写法，创建OpExecutor
		414	auto uniqueExecutor = CREATE_EXECUTOR();
		415	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
		416
		417	// 固定写法，参数检查
		418	auto ret = CheckPowTensorScalarParams(self, exponent, out);
		419	CHECK_RET(ret == ACLNN_SUCCESS, ret);
		420
		421	CheckFormat(self);
		422
		423	// pow算子的空tensor在kernel中支持，对标竞品根据算子实际情况补充
		424	if (self->IsEmpty()) {
		425	*workspaceSize = 0;
		426	uniqueExecutor.ReleaseTo(executor);
		427	return ACLNN_SUCCESS;
		428	}
		429	auto promoteType = InferTensorScalarDtype(self, exponent, out);
		430	if (IsRegBase()) {
		431	// promoteType为整形的情况，exponent需要大于0
		432	CHECK_RET(CheckPowTensorScalarExponet(promoteType, exponent), ACLNN_ERR_PARAM_INVALID);
		433
		434	// 检查exponent是否溢出
		435	CHECK_RET(CheckNotOverflow(promoteType, exponent), ACLNN_ERR_PARAM_INVALID);
		436	}
		437	// 固定写法，将输入self转换成连续的tensor
		438	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
		439	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
		440
		441	auto selfCast = l0op::Cast(selfContiguous, promoteType, uniqueExecutor.get());
		442	CHECK_RET(selfCast != nullptr, ACLNN_ERR_INNER_NULLPTR);
		443
		444	aclTensor* powOut = nullptr;
		445	bool canUseSquare = static_cast<float>(exponent->ToFloat()) == SQUARE_EXP &&
		446	(!IsRegBase() \|\| (IsRegBase() && (selfCast->GetDataType() == op::DataType::DT_FLOAT \|\|
		447	selfCast->GetDataType() == op::DataType::DT_BF16 \|\|
		448	selfCast->GetDataType() == op::DataType::DT_FLOAT16 \|\|
		449	selfCast->GetDataType() == op::DataType::DT_INT64 \|\|
		450	selfCast->GetDataType() == op::DataType::DT_COMPLEX64 \|\|
		451	selfCast->GetDataType() == op::DataType::DT_COMPLEX128)));
		452	bool canNoUseOp = static_cast<float>(exponent->ToFloat()) == NOOP_EXP && !IsRegBase();
		453	if (CheckSupportPows(selfCast, exponent)) {
		454	auto expTensor = uniqueExecutor.get()->ConvertToTensor(exponent, promoteType);
		455	CHECK_RET(expTensor != nullptr, ACLNN_ERR_INNER_NULLPTR);
		456	// 调用pows进行计算
		457	powOut = const_cast<aclTensor*>(l0op::Pows(selfCast, expTensor, uniqueExecutor.get()));
		458	} else if (canUseSquare) {
		459	const aclTensor* squareInput = selfCast;
		460	if (CheckType(selfCast->GetDataType(), SQUARE_NEED_CAST_DTYPE_LIST)) {
		461	squareInput = l0op::Cast(selfCast, op::DataType::DT_INT32, uniqueExecutor.get());
		462	CHECK_RET(squareInput != nullptr, ACLNN_ERR_INNER_NULLPTR);
		463	}
		464	// 当exponent为2.0时，使用square算子计算
		465	powOut = const_cast<aclTensor*>(l0op::Square(squareInput, uniqueExecutor.get()));
		466	} else if (canNoUseOp) {
		467	powOut = const_cast<aclTensor*>(selfCast);
		468	} else {
		469	auto expTensor = uniqueExecutor.get()->ConvertToTensor(exponent, promoteType);
		470	CHECK_RET(expTensor != nullptr, ACLNN_ERR_INNER_NULLPTR);
		471
		472	// 调用pow进行计算
		473	powOut = const_cast<aclTensor*>(l0op::Pow(selfCast, expTensor, uniqueExecutor.get()));
		474	}
		475	CHECK_RET(powOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
		476
		477	// 固定写法，将计算结果转换成输出out的数据类型
		478	auto castOut = l0op::Cast(powOut, out->GetDataType(), uniqueExecutor.get());
		479	CHECK_RET(castOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
		480
		481	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor
		482	auto viewCopyResult = l0op::ViewCopy(castOut, out, uniqueExecutor.get());
		483	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
		484
		485	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
		486	uniqueExecutor.ReleaseTo(executor);
		487
		488	return ACLNN_SUCCESS;
		489	}
		490
		491	aclnnStatus aclnnPowTensorScalar(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor,
		492	const aclrtStream stream)
		493	{
		494	L2_DFX_PHASE_2(aclnnPowTensorScalar);
		495	// 固定写法，调用框架能力，完成计算
		496	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
		497	}
		498
		499	aclnnStatus aclnnInplacePowTensorScalarGetWorkspaceSize(const aclTensor* self, const aclScalar* exponent,
		500	uint64_t* workspaceSize, aclOpExecutor** executor)
		501	{
		502	auto out = const_cast<aclTensor*>(self);
		503	return aclnnPowTensorScalarGetWorkspaceSize(self, exponent, out, workspaceSize, executor);
		504	}
		505
		506	aclnnStatus aclnnInplacePowTensorScalar(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor,
		507	aclrtStream stream)
		508	{
		509	L2_DFX_PHASE_2(aclnnInplacePowTensorScalar);
		510	// 固定写法，调用框架能力，完成计算
		511	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
496	}	512	}
497		513
498	// self为1时的fill(1)分支	514	// self为1时的fill(1)分支
499	static aclnnStatus BuildPowScalarTensorFillOne(const aclTensor out, aclOpExecutor executor) {	515	static aclnnStatus BuildPowScalarTensorFillOne(const aclTensor* out, aclOpExecutor* executor)
500	FVector<int64_t> shape;	516	{
501	for (size_t idx = 0; idx < out->GetViewShape().GetDimNum(); idx++) {	517	FVector<int64_t> shape;
502	int64_t tmpVal = out->GetViewShape().GetDim(idx);	518	for (size_t idx = 0; idx < out->GetViewShape().GetDimNum(); idx++) {
503	shape.push_back(tmpVal);	519	int64_t tmpVal = out->GetViewShape().GetDim(idx);
504	}	520	shape.push_back(tmpVal);
505	auto dims = executor->ConvertToTensor(shape.data(), shape.size(), DataType::DT_INT64);	521	}
506	CHECK_RET(dims != nullptr, ACLNN_ERR_INNER_NULLPTR);	522	auto dims = executor->ConvertToTensor(shape.data(), shape.size(), DataType::DT_INT64);
507	auto shapeArray = executor->AllocIntArray(shape.data(), shape.size());	523	CHECK_RET(dims != nullptr, ACLNN_ERR_INNER_NULLPTR);
508	CHECK_RET(shapeArray != nullptr, ACLNN_ERR_INNER_NULLPTR);	524	auto shapeArray = executor->AllocIntArray(shape.data(), shape.size());
		525	CHECK_RET(shapeArray != nullptr, ACLNN_ERR_INNER_NULLPTR);
509		526
510	FVector<float> valVector = {1.0};	527	FVector<float> valVector = {1.0};
511	auto valTensor = executor->ConvertToTensor(valVector.data(), valVector.size(), out->GetDataType());	528	auto valTensor = executor->ConvertToTensor(valVector.data(), valVector.size(), out->GetDataType());
512	CHECK_RET(valTensor != nullptr, ACLNN_ERR_INNER_NULLPTR);	529	CHECK_RET(valTensor != nullptr, ACLNN_ERR_INNER_NULLPTR);
513	auto powOut = l0op::Fill(dims, valTensor, shapeArray, executor);	530	auto powOut = l0op::Fill(dims, valTensor, shapeArray, executor);
514	CHECK_RET(powOut != nullptr, ACLNN_ERR_INNER_NULLPTR);	531	CHECK_RET(powOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
515		532
516	auto viewCopyResult = l0op::ViewCopy(powOut, out, executor);	533	auto viewCopyResult = l0op::ViewCopy(powOut, out, executor);
517	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);	534	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
518		535
519	return ACLNN_SUCCESS;	536	return ACLNN_SUCCESS;
520	}	537	}
521		538
522	// pow计算分支：contiguous -> cast -> pow -> cast -> viewcopy	539	// pow计算分支：contiguous -> cast -> pow -> cast -> viewcopy
523	static aclnnStatus BuildPowScalarTensorCompute(const aclScalar self, const aclTensor exponent,	540	static aclnnStatus BuildPowScalarTensorCompute(const aclScalar* self, const aclTensor* exponent, const aclTensor* out,
524	const aclTensor *out, const op::DataType promoteType,	541	const op::DataType promoteType, aclOpExecutor* executor)
525	aclOpExecutor *executor) {	542	{
526	auto expContiguous = l0op::Contiguous(exponent, executor);	543	auto expContiguous = l0op::Contiguous(exponent, executor);
527	CHECK_RET(expContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);	544	CHECK_RET(expContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
528		545
529	// 910B且走AICPU时，exponent不cast到promoteType	546	// 910B且走AICPU时，exponent不cast到promoteType
530	bool skipCastForAicpu = IsPowAiCpuOn910B(promoteType, self, exponent);	547	bool skipCastForAicpu = IsPowAiCpuOn910B(promoteType, self, exponent);
531	const aclTensor* powExp = expContiguous;	548	const aclTensor* powExp = expContiguous;
532	if (!skipCastForAicpu) {	549	if (!skipCastForAicpu) {
533	powExp = l0op::Cast(expContiguous, promoteType, executor);	550	powExp = l0op::Cast(expContiguous, promoteType, executor);
534	CHECK_RET(powExp != nullptr, ACLNN_ERR_INNER_NULLPTR);	551	CHECK_RET(powExp != nullptr, ACLNN_ERR_INNER_NULLPTR);
535	}	552	}
536		553
537	auto selfTensor = executor->ConvertToTensor(self, promoteType);	554	auto selfTensor = executor->ConvertToTensor(self, promoteType);
538	CHECK_RET(selfTensor != nullptr, ACLNN_ERR_INNER_NULLPTR);	555	CHECK_RET(selfTensor != nullptr, ACLNN_ERR_INNER_NULLPTR);
539		556
540	// 调用pow进行计算	557	// 调用pow进行计算
541	auto powOut = l0op::Pow(selfTensor, powExp, executor);	558	auto powOut = l0op::Pow(selfTensor, powExp, executor);
542	CHECK_RET(powOut != nullptr, ACLNN_ERR_INNER_NULLPTR);	559	CHECK_RET(powOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
543		560
544	// 固定写法，将计算结果转换成输出out的数据类型	561	// 固定写法，将计算结果转换成输出out的数据类型
545	auto castOut = l0op::Cast(powOut, out->GetDataType(), executor);	562	auto castOut = l0op::Cast(powOut, out->GetDataType(), executor);
546	CHECK_RET(castOut != nullptr, ACLNN_ERR_INNER_NULLPTR);	563	CHECK_RET(castOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
547		564
548	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor	565	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor
549	auto viewCopyResult = l0op::ViewCopy(castOut, out, executor);	566	auto viewCopyResult = l0op::ViewCopy(castOut, out, executor);
550	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);	567	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
551		568
552	return ACLNN_SUCCESS;	569	return ACLNN_SUCCESS;
553	}	570	}
554		571
555	aclnnStatus aclnnPowScalarTensorGetWorkspaceSize(const aclScalar *self,	572	aclnnStatus aclnnPowScalarTensorGetWorkspaceSize(const aclScalar* self, const aclTensor* exponent, const aclTensor* out,
556	const aclTensor *exponent,	573	uint64_t* workspaceSize, aclOpExecutor** executor)
557	const aclTensor *out,	574	{
558	uint64_t *workspaceSize,	575	L2_DFX_PHASE_1(aclnnPowScalarTensor, DFX_IN(self, exponent), DFX_OUT(out));
559	aclOpExecutor **executor) {
560	L2_DFX_PHASE_1(aclnnPowScalarTensor, DFX_IN(self, exponent), DFX_OUT(out));
561		576
562	// 固定写法，创建OpExecutor	577	// 固定写法，创建OpExecutor
563	auto uniqueExecutor = CREATE_EXECUTOR();	578	auto uniqueExecutor = CREATE_EXECUTOR();
564	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);	579	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
565		580
566	// 固定写法，参数检查	581	// 固定写法，参数检查
567	auto ret = CheckPowScalarTensorParams(self, exponent, out);	582	auto ret = CheckPowScalarTensorParams(self, exponent, out);
568	CHECK_RET(ret == ACLNN_SUCCESS, ret);	583	CHECK_RET(ret == ACLNN_SUCCESS, ret);
569		584
570	// pow算子的空tensor在kernel中支持，对标竞品根据算子实际情况补充	585	// pow算子的空tensor在kernel中支持，对标竞品根据算子实际情况补充
571	if (exponent->IsEmpty()) {	586	if (exponent->IsEmpty()) {
572	*workspaceSize = 0;	587	*workspaceSize = 0;
573	uniqueExecutor.ReleaseTo(executor);	588	uniqueExecutor.ReleaseTo(executor);
574	return ACLNN_SUCCESS;	589	return ACLNN_SUCCESS;
575	}	590	}
		591
		592	// fill(1) 分支
		593	if (IsRegBase() && static_cast<float>(self->ToFloat()) == 1.0 && !IsComplexType(exponent->GetDataType()) &&
		594	!IsComplexType(out->GetDataType())) {
		595	CHECK_RET(BuildPowScalarTensorFillOne(out, uniqueExecutor.get()) == ACLNN_SUCCESS, ACLNN_ERR_INNER);
		596	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
		597	uniqueExecutor.ReleaseTo(executor);
		598	return ACLNN_SUCCESS;
		599	}
		600
		601	auto promoteType = InferScalarTensorDtype(self, exponent, out);
		602
		603	CHECK_RET(BuildPowScalarTensorCompute(self, exponent, out, promoteType, uniqueExecutor.get()) == ACLNN_SUCCESS,
		604	ACLNN_ERR_INNER);
576		605
577	// fill(1) 分支
578	if (IsRegBase() &&
579	static_cast<float>(self->ToFloat()) == 1.0 &&
580	!IsComplexType(exponent->GetDataType()) && !IsComplexType(out->GetDataType())) {
581	CHECK_RET(BuildPowScalarTensorFillOne(out, uniqueExecutor.get()) == ACLNN_SUCCESS, ACLNN_ERR_INNER);
582	*workspaceSize = uniqueExecutor->GetWorkspaceSize();	606	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
583	uniqueExecutor.ReleaseTo(executor);	607	uniqueExecutor.ReleaseTo(executor);
		608
584	return ACLNN_SUCCESS;	609	return ACLNN_SUCCESS;
585	}
586
587	auto promoteType = InferScalarTensorDtype(self, exponent, out);
588
589	CHECK_RET(BuildPowScalarTensorCompute(self, exponent, out, promoteType,
590	uniqueExecutor.get()) == ACLNN_SUCCESS, ACLNN_ERR_INNER);
591
592	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
593	uniqueExecutor.ReleaseTo(executor);
594
595	return ACLNN_SUCCESS;
596	}	610	}
597		611
598	aclnnStatus aclnnPowScalarTensor(void *workspace, uint64_t workspaceSize,	612	aclnnStatus aclnnPowScalarTensor(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
599	aclOpExecutor *executor, aclrtStream stream) {	613	{
600	L2_DFX_PHASE_2(aclnnPowScalarTensor);	614	L2_DFX_PHASE_2(aclnnPowScalarTensor);
601	// 固定写法，调用框架能力，完成计算	615	// 固定写法，调用框架能力，完成计算
602	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	616	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
603	}	617	}
604	#ifdef __cplusplus	618	#ifdef __cplusplus
605	}	619	}

Mmath/pows/CMakeLists.txt+3-12

	@@ -1,20 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11		10
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE pows ACLNNTYPE aclnn_exclude)
13	if(NOT ENABLE_TEST AND NOT BENCHMARK)
14	list(REMOVE_ITEM CURRENT_DIRS tests)
15	endif()
16	foreach(SUB_DIR ${CURRENT_DIRS})
17	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
18	add_subdirectory(${SUB_DIR})
19	endif()
20	endforeach()

Rmath/pows/op_host/op_api/pows.cpp→math/pows/op_api/pows.cpp+4-5

	@@ -30,8 +30,8 @@ namespace l0op {
30	OP_TYPE_REGISTER(Pows);	30	OP_TYPE_REGISTER(Pows);
31		31
32	// AICORE算子kernel	32	// AICORE算子kernel
33	static const aclTensor* PowsAiCore(	33	static const aclTensor* PowsAiCore(const aclTensor* self, const aclTensor* exponent, aclTensor* powsOut,
34	const aclTensor* self, const aclTensor* exponent, aclTensor* powsOut, aclOpExecutor* executor)	34	aclOpExecutor* executor)
35	{	35	{
36	L0_DFX(PowsAiCore, self, exponent, powsOut);	36	L0_DFX(PowsAiCore, self, exponent, powsOut);
37		37
	@@ -43,9 +43,8 @@ const aclTensor* Pows(const aclTensor* self, const aclTensor* exponent, aclOpExe
43	{	43	{
44	op::Shape broadcastShape;	44	op::Shape broadcastShape;
45	if (!BroadcastInferShape(self->GetViewShape(), exponent->GetViewShape(), broadcastShape)) {	45	if (!BroadcastInferShape(self->GetViewShape(), exponent->GetViewShape(), broadcastShape)) {
46	OP_LOGE(	46	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Broadcast %s and %s failed.", op::ToString(self->GetViewShape()).GetString(),
47	ACLNN_ERR_PARAM_INVALID, "Broadcast %s and %s failed.", op::ToString(self->GetViewShape()).GetString(),	47	op::ToString(exponent->GetViewShape()).GetString());
48	op::ToString(exponent->GetViewShape()).GetString());
49	return nullptr;	48	return nullptr;
50	}	49	}
51		50

Rmath/pows/op_host/op_api/pows.h→math/pows/op_api/pows.h+0-0

文件重命名但无更改。

Dmath/pows/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources(OPTYPE pows ACLNNTYPE aclnn_exclude)

Dmath/pows/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/pows/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/pows/tests/ut/op_host/CMakeLists.txt+0-22

	@@ -1,22 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	if(UT_TEST_ALL OR OP_HOST_UT)
13	add_modules_ut_sources(UT_NAME ${OP_TILING_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
14	# add_modules_ut_sources(UT_NAME ${OP_INFERSHAPE_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
15	endif()
16
17	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
18	foreach(SUB_DIR ${CURRENT_DIRS})
19	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
20	add_subdirectory(${SUB_DIR})
21	endif()
22	endforeach()

Mmath/reduce_mean_with_count/CMakeLists.txt+0-8

	@@ -13,11 +13,3 @@ set(SUPPORT_COMPUTE_UNIT "ascend950")
13	# 设置每种芯片类型对应的tiling文件目录，即采用op_host目录下哪个文件夹下的tiling文件编译	13	# 设置每种芯片类型对应的tiling文件目录，即采用op_host目录下哪个文件夹下的tiling文件编译
14	set(SUPPORT_TILING_DIR "arch35")	14	set(SUPPORT_TILING_DIR "arch35")
15	add_all_modules_sources(OPTYPE reduce_mean_with_count ACLNNTYPE aclnn_exclude COMPUTE_UNIT ${SUPPORT_COMPUTE_UNIT} TILING_DIR ${SUPPORT_TILING_DIR} DISABLE_IN_OPP TRUE)	15	add_all_modules_sources(OPTYPE reduce_mean_with_count ACLNNTYPE aclnn_exclude COMPUTE_UNIT ${SUPPORT_COMPUTE_UNIT} TILING_DIR ${SUPPORT_TILING_DIR} DISABLE_IN_OPP TRUE)
16
17	# L0 op source is in op_host/op_api/, not picked up by default GLOB
18	file(GLOB OPAPI_L0_EXTRA_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/op_host/op_api/*.cpp)
19	list(FILTER OPAPI_L0_EXTRA_SRCS EXCLUDE REGEX "./aclnn_[^/]$")
20	if(OPAPI_L0_EXTRA_SRCS)
21	add_opapi_modules()
22	target_sources(${OPHOST_NAME}_opapi_obj PRIVATE ${OPAPI_L0_EXTRA_SRCS})
23	endif()

Rmath/reduce_mean_with_count/op_host/op_api/reduce_mean_with_count.cpp→math/reduce_mean_with_count/op_api/reduce_mean_with_count.cpp+5-6

	@@ -67,9 +67,8 @@ static op::Shape ComputeReduceOutputShape(const aclTensor* x, const aclIntArray*
67	return yShape;	67	return yShape;
68	}	68	}
69		69
70	const aclTensor* ReduceMeanWithCount(const aclTensor* x, const aclTensor* count,	70	const aclTensor* ReduceMeanWithCount(const aclTensor* x, const aclTensor* count, const aclTensor* countSum,
71	const aclTensor* countSum, const aclIntArray* axes,	71	const aclIntArray* axes, bool keepDims, aclOpExecutor* executor)
72	bool keepDims, aclOpExecutor* executor)
73	{	72	{
74	L0_DFX(ReduceMeanWithCount, x, count, countSum, axes, keepDims);	73	L0_DFX(ReduceMeanWithCount, x, count, countSum, axes, keepDims);
75		74
	@@ -85,8 +84,8 @@ const aclTensor* ReduceMeanWithCount(const aclTensor* x, const aclTensor* count,
85	}	84	}
86	CHECK_RET(yOut != nullptr, nullptr);	85	CHECK_RET(yOut != nullptr, nullptr);
87		86
88	auto retAicore = ADD_TO_LAUNCHER_LIST_AICORE(	87	auto retAicore = ADD_TO_LAUNCHER_LIST_AICORE(ReduceMeanWithCount, OP_INPUT(x, count, countSum), OP_OUTPUT(yOut),
89	ReduceMeanWithCount, OP_INPUT(x, count, countSum), OP_OUTPUT(yOut), OP_ATTR(axes, keepDims));	88	OP_ATTR(axes, keepDims));
90	OP_CHECK(retAicore == ACLNN_SUCCESS,	89	OP_CHECK(retAicore == ACLNN_SUCCESS,
91	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "ReduceMeanWithCount ADD_TO_LAUNCHER_LIST_AICORE failed."),	90	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "ReduceMeanWithCount ADD_TO_LAUNCHER_LIST_AICORE failed."),
92	return nullptr);	91	return nullptr);
	@@ -94,4 +93,4 @@ const aclTensor* ReduceMeanWithCount(const aclTensor* x, const aclTensor* count,
94	return yOut;	93	return yOut;
95	}	94	}
96		95
97	} // namespace l0op	96	} // namespace l0op

Rmath/reduce_mean_with_count/op_host/op_api/reduce_mean_with_count.h→math/reduce_mean_with_count/op_api/reduce_mean_with_count.h+2-2

	@@ -20,6 +20,6 @@
20	namespace l0op {	20	namespace l0op {
21	const aclTensor* ReduceMeanWithCount(const aclTensor* input, const aclTensor* count, const aclTensor* countSum,	21	const aclTensor* ReduceMeanWithCount(const aclTensor* input, const aclTensor* count, const aclTensor* countSum,
22	const aclIntArray* axes, bool keepDims, aclOpExecutor* executor);	22	const aclIntArray* axes, bool keepDims, aclOpExecutor* executor);
23	} // namespace l0op	23	} // namespace l0op
24		24
25	#endif	25	#endif

Dmath/reduce_mean_with_count/op_host/CMakeLists.txt+0-9

	@@ -1,9 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# Copyright (c) 2026 Huawei Technologies Co., Ltd.
3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	# CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------

Dmath/reduce_nansum/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/reduce_nansum/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Amath/reduce_nansum/tests/ut/op_api/test_aclnn_reduce_nansum.cpp+357-0

@@ -0,0 +1,357 @@
	1	/**
	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10
	11	#include "gtest/gtest.h"
	12	#include "../../../op_api/aclnn_reduce_nansum.h"
	13	#include "op_api_ut_common/tensor_desc.h"
	14	#include "op_api_ut_common/op_api_ut.h"
	15
	16	using namespace std;
	17
	18	class l2_reduce_nansum_test : public testing::Test {
	19	protected:
	20	static void SetUpTestCase() { cout << "l2_reduce_nansum_test SetUp" << endl; }
	21
	22	static void TearDownTestCase() { cout << "l2_reduce_nansum_test TearDown" << endl; }
	23	};
	24
	25	// self为空指针
	26	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_nullptr_self)
	27	{
	28	auto outDesc = TensorDesc({2, 4}, ACL_FLOAT, ACL_FORMAT_ND);
	29	auto dim = IntArrayDesc(vector<int64_t>{0});
	30	bool keep_dim = true;
	31
	32	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(nullptr, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
	33
	34	uint64_t workspaceSize = 0;
	35	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	36	EXPECT_NE(getWorkspaceResult, ACLNN_ERR_INNER_NULLPTR);
	37	}
	38
	39	// dim为空指针
	40	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_nullptr_dim)
	41	{
	42	auto selfDesc = TensorDesc({2, 4}, ACL_FLOAT, ACL_FORMAT_ND);
	43	auto outDesc = TensorDesc({1, 4}, ACL_FLOAT, ACL_FORMAT_ND);
	44	bool keep_dim = true;
	45
	46	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, nullptr, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
	47
	48	uint64_t workspaceSize = 0;
	49	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	50	EXPECT_NE(getWorkspaceResult, ACLNN_ERR_INNER_NULLPTR);
	51	}
	52
	53	// out为空指针
	54	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_nullptr_out)
	55	{
	56	auto selfDesc = TensorDesc({2, 4}, ACL_FLOAT, ACL_FORMAT_ND);
	57	auto dim = IntArrayDesc(vector<int64_t>{0});
	58	bool keep_dim = true;
	59
	60	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(nullptr));
	61
	62	uint64_t workspaceSize = 0;
	63	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	64	EXPECT_NE(getWorkspaceResult, ACLNN_ERR_INNER_NULLPTR);
	65	}
	66
	67	// self为空tensor
	68	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_empty_self)
	69	{
	70	auto selfDesc = TensorDesc({2, 0}, ACL_FLOAT, ACL_FORMAT_ND);
	71	auto outDesc = TensorDesc({1, 0}, ACL_FLOAT, ACL_FORMAT_ND);
	72	auto dim = IntArrayDesc(vector<int64_t>{0});
	73	bool keep_dim = true;
	74
	75	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
	76
	77	uint64_t workspaceSize = 0;
	78	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	79	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
	80	// ut.TestPrecision();
	81	}
	82
	83	// 正常路径，float16
	84	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_float16)
	85	{
	86	auto selfDesc = TensorDesc({2, 4}, ACL_FLOAT16, ACL_FORMAT_ND);
	87	auto outDesc = TensorDesc({1, 4}, ACL_FLOAT16, ACL_FORMAT_ND);
	88	auto dim = IntArrayDesc(vector<int64_t>{0});
	89	bool keep_dim = true;
	90
	91	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT16), OUTPUT(outDesc));
	92
	93	uint64_t workspaceSize = 0;
	94	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	95	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
	96	// ut.TestPrecision();
	97	}
	98
	99	// 正常路径，float32
	100	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_float32)
	101	{
	102	auto selfDesc = TensorDesc({2, 4}, ACL_FLOAT, ACL_FORMAT_ND);
	103	auto outDesc = TensorDesc({1, 4}, ACL_FLOAT, ACL_FORMAT_ND);
	104	auto dim = IntArrayDesc(vector<int64_t>{0});
	105	bool keep_dim = true;
	106
	107	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
	108
	109	uint64_t workspaceSize = 0;
	110	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	111	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
	112	// ut.TestPrecision();
	113	}
	114
	115	// 不支持类型complex64
	116	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_complex64)
	117	{
	118	auto selfDesc = TensorDesc({2, 3}, ACL_COMPLEX64, ACL_FORMAT_ND);
	119	auto outDesc = TensorDesc({1, 3}, ACL_COMPLEX64, ACL_FORMAT_ND);
	120	auto dim = IntArrayDesc(vector<int64_t>{0});
	121	bool keep_dim = true;
	122	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_COMPLEX64), OUTPUT(outDesc));
	123
	124	uint64_t workspaceSize = 0;
	125	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	126	EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
	127	}
	128
	129	// 不支持类型complex128
	130	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_complex128)
	131	{
	132	auto selfDesc = TensorDesc({2, 3}, ACL_COMPLEX128, ACL_FORMAT_ND);
	133	auto outDesc = TensorDesc({1, 3}, ACL_COMPLEX128, ACL_FORMAT_ND);
	134	auto dim = IntArrayDesc(vector<int64_t>{0});
	135	bool keep_dim = true;
	136	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_COMPLEX128), OUTPUT(outDesc));
	137
	138	uint64_t workspaceSize = 0;
	139	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	140	EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
	141	}
	142
	143	// 不支持类型double
	144	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_double)
	145	{
	146	auto selfDesc = TensorDesc({2, 3}, ACL_DOUBLE, ACL_FORMAT_ND);
	147	auto outDesc = TensorDesc({1, 3}, ACL_DOUBLE, ACL_FORMAT_ND);
	148	auto dim = IntArrayDesc(vector<int64_t>{0});
	149	bool keep_dim = true;
	150	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_DOUBLE), OUTPUT(outDesc));
	151
	152	uint64_t workspaceSize = 0;
	153	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	154	EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
	155	}
	156
	157	// 正常路径，integral type, int64
	158	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_int64)
	159	{
	160	auto selfDesc = TensorDesc({2, 4}, ACL_INT64, ACL_FORMAT_ND);
	161	auto outDesc = TensorDesc({2, 1}, ACL_INT64, ACL_FORMAT_ND);
	162	auto dim = IntArrayDesc(vector<int64_t>{1});
	163	bool keep_dim = true;
	164
	165	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_INT64), OUTPUT(outDesc));
	166
	167	uint64_t workspaceSize = 0;
	168	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	169	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
	170	// ut.TestPrecision();
	171	}
	172
	173	// 正常路径，integral type, int8
	174	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_int8)
	175	{
	176	auto selfDesc = TensorDesc({2, 4}, ACL_INT8, ACL_FORMAT_ND);
	177	auto outDesc = TensorDesc({2, 1}, ACL_INT8, ACL_FORMAT_ND);
	178	auto dim = IntArrayDesc(vector<int64_t>{1});
	179	bool keep_dim = true;
	180
	181	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_INT8), OUTPUT(outDesc));
	182
	183	uint64_t workspaceSize = 0;
	184	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	185	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
	186	// ut.TestPrecision();
	187	}
	188
	189	// 正常路径，integral type, bool
	190	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_bool)
	191	{
	192	auto selfDesc = TensorDesc({2, 4}, ACL_BOOL, ACL_FORMAT_ND);
	193	auto outDesc = TensorDesc({2, 1}, ACL_BOOL, ACL_FORMAT_ND);
	194	auto dim = IntArrayDesc(vector<int64_t>{1});
	195	bool keep_dim = true;
	196
	197	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_BOOL), OUTPUT(outDesc));
	198
	199	uint64_t workspaceSize = 0;
	200	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	201	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
	202	// ut.TestPrecision();
	203	}
	204
	205	// 正常路径，bf16
	206	TEST_F(l2_reduce_nansum_test, ascend910B2_case_self_bf16)
	207	{
	208	auto input_tensor_desc = TensorDesc({1, 8, 2, 3, 6}, ACL_BF16, ACL_FORMAT_NCDHW);
	209	auto dim_desc = IntArrayDesc(vector<int64_t>{2});
	210	bool keepDim = false;
	211	aclDataType dtype_desc = ACL_BF16;
	212	auto out_desc = TensorDesc({1, 8, 3, 6}, ACL_BF16, ACL_FORMAT_NHWC).Precision(0.001, 0.001);
	213	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(input_tensor_desc, dim_desc, keepDim, dtype_desc), OUTPUT(out_desc));
	214
	215	uint64_t workspace_size = 0;
	216	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	217	EXPECT_EQ(aclRet, ACL_SUCCESS);
	218	// // ut.TestPrecision();
	219	}
	220
	221	TEST_F(l2_reduce_nansum_test, case_self_bf16)
	222	{
	223	auto input_tensor_desc = TensorDesc({1, 8, 2, 3, 6}, ACL_BF16, ACL_FORMAT_NCDHW);
	224	auto dim_desc = IntArrayDesc(vector<int64_t>{2});
	225	bool keepDim = false;
	226	aclDataType dtype_desc = ACL_BF16;
	227	auto out_desc = TensorDesc({1, 8, 3, 6}, ACL_BF16, ACL_FORMAT_NHWC).Precision(0.001, 0.001);
	228	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(input_tensor_desc, dim_desc, keepDim, dtype_desc), OUTPUT(out_desc));
	229
	230	uint64_t workspace_size = 0;
	231	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
	232	// EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
	233	}
	234
	235	// 正常路径，dim为1
	236	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dim_1)
	237	{
	238	auto selfDesc = TensorDesc({2, 4}, ACL_FLOAT, ACL_FORMAT_ND);
	239	auto outDesc = TensorDesc({2, 1}, ACL_FLOAT, ACL_FORMAT_ND);
	240	auto dim = IntArrayDesc(vector<int64_t>{1});
	241	bool keep_dim = true;
	242
	243	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
	244
	245	uint64_t workspaceSize = 0;
	246	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	247	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
	248	// ut.TestPrecision();
	249	}
	250
	251	// 正常路径，dim为-1
	252	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dim_neg1)
	253	{
	254	auto selfDesc = TensorDesc({2, 4}, ACL_FLOAT, ACL_FORMAT_ND);
	255	auto outDesc = TensorDesc({2, 1}, ACL_FLOAT, ACL_FORMAT_ND);
	256	auto dim = IntArrayDesc(vector<int64_t>{-1});
	257	bool keep_dim = true;
	258
	259	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
	260
	261	uint64_t workspaceSize = 0;
	262	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	263	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
	264	// ut.TestPrecision();
	265	}
	266
	267	// 正常路径，dim为-1,0
	268	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dim_neg1_0)
	269	{
	270	auto selfDesc = TensorDesc({2, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND);
	271	auto outDesc = TensorDesc({1, 3, 1}, ACL_FLOAT, ACL_FORMAT_ND);
	272	auto dim = IntArrayDesc(vector<int64_t>{-1, 0});
	273	bool keep_dim = true;
	274
	275	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
	276
	277	uint64_t workspaceSize = 0;
	278	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	279	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
	280	// ut.TestPrecision();
	281	}
	282
	283	// 正常路径，dim为空
	284	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dim_empty)
	285	{
	286	auto selfDesc = TensorDesc({2, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND);
	287	auto outDesc = TensorDesc({}, ACL_FLOAT, ACL_FORMAT_ND);
	288	auto dim = IntArrayDesc(vector<int64_t>{});
	289	bool keep_dim = true;
	290
	291	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
	292
	293	uint64_t workspaceSize = 0;
	294	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	295	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
	296	// ut.TestPrecision();
	297	}
	298
	299	// dim轴重复
	300	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_repeat_dim)
	301	{
	302	auto selfDesc = TensorDesc({2, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND);
	303	auto outDesc = TensorDesc({}, ACL_FLOAT, ACL_FORMAT_ND);
	304	auto dim = IntArrayDesc(vector<int64_t>{1, 1});
	305	bool keep_dim = true;
	306
	307	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
	308
	309	uint64_t workspaceSize = 0;
	310	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	311	EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
	312	}
	313
	314	// dim轴超过shape范围
	315	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_invalid_dim)
	316	{
	317	auto selfDesc = TensorDesc({2, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND);
	318	auto outDesc = TensorDesc({}, ACL_FLOAT, ACL_FORMAT_ND);
	319	auto dim = IntArrayDesc(vector<int64_t>{1, 3});
	320	bool keep_dim = true;
	321
	322	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
	323
	324	uint64_t workspaceSize = 0;
	325	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	326	EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
	327	}
	328
	329	// 正常路径，keep_dim为false
	330	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_keepdim_false)
	331	{
	332	auto selfDesc = TensorDesc({2, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND);
	333	auto outDesc = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
	334	auto dim = IntArrayDesc(vector<int64_t>{-1, 0});
	335	bool keep_dim = false;
	336
	337	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
	338
	339	uint64_t workspaceSize = 0;
	340	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	341	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
	342	// ut.TestPrecision();
	343	}
	344
	345	// 用例不支持，最大维度超过8
	346	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dimension)
	347	{
	348	auto selfDesc = TensorDesc({2, 2, 1, 1, 1, 1, 1, 1, 1, 1}, ACL_FLOAT, ACL_FORMAT_ND);
	349	auto outDesc = TensorDesc({1, 2, 1, 1, 1, 1, 1, 1, 1, 1}, ACL_FLOAT, ACL_FORMAT_ND);
	350	auto dim = IntArrayDesc(vector<int64_t>{0});
	351	bool keep_dim = true;
	352	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
	353
	354	uint64_t workspaceSize = 0;
	355	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
	356	EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
	357	}

Dmath/reduce_nansum/tests/ut/op_host/CMakeLists.txt+0-22

	@@ -1,22 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	if(UT_TEST_ALL OR OP_HOST_UT)
13	add_modules_ut_sources(UT_NAME ${OP_TILING_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
14	add_modules_ut_sources(UT_NAME ${OP_INFERSHAPE_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
15	endif()
16
17	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
18	foreach(SUB_DIR ${CURRENT_DIRS})
19	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
20	add_subdirectory(${SUB_DIR})
21	endif()
22	endforeach()

Dmath/reduce_nansum/tests/ut/op_host/op_api/CMakeLists.txt+0-14

	@@ -1,14 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	if(UT_TEST_ALL OR OP_API_UT)
13	add_modules_ut_sources(UT_NAME ${OP_API_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
14	endif()

Dmath/reduce_nansum/tests/ut/op_host/op_api/test_reduce_nansum.cpp+0-335

	@@ -1,335 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10
11	#include "gtest/gtest.h"
12	#include "../../../../op_api/aclnn_reduce_nansum.h"
13	#include "op_api_ut_common/tensor_desc.h"
14	#include "op_api_ut_common/op_api_ut.h"
15
16	using namespace std;
17
18	class l2_reduce_nansum_test : public testing::Test {
19	protected:
20	static void SetUpTestCase() {cout << "l2_reduce_nansum_test SetUp" << endl;}
21
22	static void TearDownTestCase() { cout << "l2_reduce_nansum_test TearDown" << endl; }
23	};
24
25	// self为空指针
26	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_nullptr_self) {
27	auto outDesc = TensorDesc({2, 4}, ACL_FLOAT, ACL_FORMAT_ND);
28	auto dim = IntArrayDesc(vector<int64_t>{0});
29	bool keep_dim = true;
30
31	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(nullptr, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
32
33	uint64_t workspaceSize = 0;
34	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
35	EXPECT_NE(getWorkspaceResult, ACLNN_ERR_INNER_NULLPTR);
36	}
37
38	// dim为空指针
39	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_nullptr_dim) {
40	auto selfDesc = TensorDesc({2, 4}, ACL_FLOAT, ACL_FORMAT_ND);
41	auto outDesc = TensorDesc({1, 4}, ACL_FLOAT, ACL_FORMAT_ND);
42	bool keep_dim = true;
43
44	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, nullptr, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
45
46	uint64_t workspaceSize = 0;
47	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
48	EXPECT_NE(getWorkspaceResult, ACLNN_ERR_INNER_NULLPTR);
49	}
50
51	// out为空指针
52	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_nullptr_out) {
53	auto selfDesc = TensorDesc({2, 4}, ACL_FLOAT, ACL_FORMAT_ND);
54	auto dim = IntArrayDesc(vector<int64_t>{0});
55	bool keep_dim = true;
56
57	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(nullptr));
58
59	uint64_t workspaceSize = 0;
60	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
61	EXPECT_NE(getWorkspaceResult, ACLNN_ERR_INNER_NULLPTR);
62	}
63
64	// self为空tensor
65	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_empty_self) {
66	auto selfDesc = TensorDesc({2, 0}, ACL_FLOAT, ACL_FORMAT_ND);
67	auto outDesc = TensorDesc({1, 0}, ACL_FLOAT, ACL_FORMAT_ND);
68	auto dim = IntArrayDesc(vector<int64_t>{0});
69	bool keep_dim = true;
70
71	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
72
73	uint64_t workspaceSize = 0;
74	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
75	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
76	ut.TestPrecision();
77	}
78
79	// 正常路径，float16
80	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_float16) {
81	auto selfDesc = TensorDesc({2, 4}, ACL_FLOAT16, ACL_FORMAT_ND);
82	auto outDesc = TensorDesc({1, 4}, ACL_FLOAT16, ACL_FORMAT_ND);
83	auto dim = IntArrayDesc(vector<int64_t>{0});
84	bool keep_dim = true;
85
86	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT16), OUTPUT(outDesc));
87
88	uint64_t workspaceSize = 0;
89	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
90	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
91	ut.TestPrecision();
92	}
93
94	// 正常路径，float32
95	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_float32) {
96	auto selfDesc = TensorDesc({2, 4}, ACL_FLOAT, ACL_FORMAT_ND);
97	auto outDesc = TensorDesc({1, 4}, ACL_FLOAT, ACL_FORMAT_ND);
98	auto dim = IntArrayDesc(vector<int64_t>{0});
99	bool keep_dim = true;
100
101	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
102
103	uint64_t workspaceSize = 0;
104	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
105	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
106	ut.TestPrecision();
107	}
108
109	// 不支持类型complex64
110	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_complex64) {
111	auto selfDesc = TensorDesc({2, 3}, ACL_COMPLEX64, ACL_FORMAT_ND);
112	auto outDesc = TensorDesc({1, 3}, ACL_COMPLEX64, ACL_FORMAT_ND);
113	auto dim = IntArrayDesc(vector<int64_t>{0});
114	bool keep_dim = true;
115	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_COMPLEX64), OUTPUT(outDesc));
116
117	uint64_t workspaceSize = 0;
118	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
119	EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
120	}
121
122	// 不支持类型complex128
123	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_complex128) {
124	auto selfDesc = TensorDesc({2, 3}, ACL_COMPLEX128, ACL_FORMAT_ND);
125	auto outDesc = TensorDesc({1, 3}, ACL_COMPLEX128, ACL_FORMAT_ND);
126	auto dim = IntArrayDesc(vector<int64_t>{0});
127	bool keep_dim = true;
128	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_COMPLEX128), OUTPUT(outDesc));
129
130	uint64_t workspaceSize = 0;
131	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
132	EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
133	}
134
135	// 不支持类型double
136	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_double) {
137	auto selfDesc = TensorDesc({2, 3}, ACL_DOUBLE, ACL_FORMAT_ND);
138	auto outDesc = TensorDesc({1, 3}, ACL_DOUBLE, ACL_FORMAT_ND);
139	auto dim = IntArrayDesc(vector<int64_t>{0});
140	bool keep_dim = true;
141	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_DOUBLE), OUTPUT(outDesc));
142
143	uint64_t workspaceSize = 0;
144	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
145	EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
146	}
147
148	// 正常路径，integral type, int64
149	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_int64) {
150	auto selfDesc = TensorDesc({2, 4}, ACL_INT64, ACL_FORMAT_ND);
151	auto outDesc = TensorDesc({2, 1}, ACL_INT64, ACL_FORMAT_ND);
152	auto dim = IntArrayDesc(vector<int64_t>{1});
153	bool keep_dim = true;
154
155	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_INT64), OUTPUT(outDesc));
156
157	uint64_t workspaceSize = 0;
158	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
159	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
160	ut.TestPrecision();
161	}
162
163	// 正常路径，integral type, int8
164	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_int8) {
165	auto selfDesc = TensorDesc({2, 4}, ACL_INT8, ACL_FORMAT_ND);
166	auto outDesc = TensorDesc({2, 1}, ACL_INT8, ACL_FORMAT_ND);
167	auto dim = IntArrayDesc(vector<int64_t>{1});
168	bool keep_dim = true;
169
170	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_INT8), OUTPUT(outDesc));
171
172	uint64_t workspaceSize = 0;
173	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
174	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
175	ut.TestPrecision();
176	}
177
178	// 正常路径，integral type, bool
179	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dtype_bool) {
180	auto selfDesc = TensorDesc({2, 4}, ACL_BOOL, ACL_FORMAT_ND);
181	auto outDesc = TensorDesc({2, 1}, ACL_BOOL, ACL_FORMAT_ND);
182	auto dim = IntArrayDesc(vector<int64_t>{1});
183	bool keep_dim = true;
184
185	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_BOOL), OUTPUT(outDesc));
186
187	uint64_t workspaceSize = 0;
188	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
189	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
190	ut.TestPrecision();
191	}
192
193	// 正常路径，bf16
194	TEST_F(l2_reduce_nansum_test, ascend910B2_case_self_bf16) {
195	auto input_tensor_desc = TensorDesc({1, 8, 2, 3, 6}, ACL_BF16, ACL_FORMAT_NCDHW);
196	auto dim_desc = IntArrayDesc(vector<int64_t>{2});
197	bool keepDim = false;
198	aclDataType dtype_desc = ACL_BF16;
199	auto out_desc = TensorDesc({1, 8, 3, 6}, ACL_BF16, ACL_FORMAT_NHWC).Precision(0.001, 0.001);
200	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(input_tensor_desc, dim_desc, keepDim, dtype_desc), OUTPUT(out_desc));
201
202	uint64_t workspace_size = 0;
203	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
204	EXPECT_EQ(aclRet, ACL_SUCCESS);
205	// ut.TestPrecision();
206	}
207
208	TEST_F(l2_reduce_nansum_test, case_self_bf16) {
209	auto input_tensor_desc = TensorDesc({1, 8, 2, 3, 6}, ACL_BF16, ACL_FORMAT_NCDHW);
210	auto dim_desc = IntArrayDesc(vector<int64_t>{2});
211	bool keepDim = false;
212	aclDataType dtype_desc = ACL_BF16;
213	auto out_desc = TensorDesc({1, 8, 3, 6}, ACL_BF16, ACL_FORMAT_NHWC).Precision(0.001, 0.001);
214	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(input_tensor_desc, dim_desc, keepDim, dtype_desc), OUTPUT(out_desc));
215
216	uint64_t workspace_size = 0;
217	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
218	// EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
219	}
220
221	// 正常路径，dim为1
222	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dim_1) {
223	auto selfDesc = TensorDesc({2, 4}, ACL_FLOAT, ACL_FORMAT_ND);
224	auto outDesc = TensorDesc({2, 1}, ACL_FLOAT, ACL_FORMAT_ND);
225	auto dim = IntArrayDesc(vector<int64_t>{1});
226	bool keep_dim = true;
227
228	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
229
230	uint64_t workspaceSize = 0;
231	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
232	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
233	ut.TestPrecision();
234	}
235
236	// 正常路径，dim为-1
237	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dim_neg1) {
238	auto selfDesc = TensorDesc({2, 4}, ACL_FLOAT, ACL_FORMAT_ND);
239	auto outDesc = TensorDesc({2, 1}, ACL_FLOAT, ACL_FORMAT_ND);
240	auto dim = IntArrayDesc(vector<int64_t>{-1});
241	bool keep_dim = true;
242
243	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
244
245	uint64_t workspaceSize = 0;
246	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
247	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
248	ut.TestPrecision();
249	}
250
251	// 正常路径，dim为-1,0
252	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dim_neg1_0) {
253	auto selfDesc = TensorDesc({2, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND);
254	auto outDesc = TensorDesc({1, 3, 1}, ACL_FLOAT, ACL_FORMAT_ND);
255	auto dim = IntArrayDesc(vector<int64_t>{-1, 0});
256	bool keep_dim = true;
257
258	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
259
260	uint64_t workspaceSize = 0;
261	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
262	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
263	ut.TestPrecision();
264	}
265
266	// 正常路径，dim为空
267	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dim_empty) {
268	auto selfDesc = TensorDesc({2, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND);
269	auto outDesc = TensorDesc({}, ACL_FLOAT, ACL_FORMAT_ND);
270	auto dim = IntArrayDesc(vector<int64_t>{});
271	bool keep_dim = true;
272
273	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
274
275	uint64_t workspaceSize = 0;
276	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
277	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
278	ut.TestPrecision();
279	}
280
281	// dim轴重复
282	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_repeat_dim) {
283	auto selfDesc = TensorDesc({2, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND);
284	auto outDesc = TensorDesc({}, ACL_FLOAT, ACL_FORMAT_ND);
285	auto dim = IntArrayDesc(vector<int64_t>{1, 1});
286	bool keep_dim = true;
287
288	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
289
290	uint64_t workspaceSize = 0;
291	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
292	EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
293	}
294
295	// dim轴超过shape范围
296	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_invalid_dim) {
297	auto selfDesc = TensorDesc({2, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND);
298	auto outDesc = TensorDesc({}, ACL_FLOAT, ACL_FORMAT_ND);
299	auto dim = IntArrayDesc(vector<int64_t>{1, 3});
300	bool keep_dim = true;
301
302	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
303
304	uint64_t workspaceSize = 0;
305	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
306	EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
307	}
308
309	// 正常路径，keep_dim为false
310	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_keepdim_false) {
311	auto selfDesc = TensorDesc({2, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND);
312	auto outDesc = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
313	auto dim = IntArrayDesc(vector<int64_t>{-1, 0});
314	bool keep_dim = false;
315
316	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
317
318	uint64_t workspaceSize = 0;
319	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
320	EXPECT_EQ(getWorkspaceResult, ACLNN_SUCCESS);
321	ut.TestPrecision();
322	}
323
324	// 用例不支持，最大维度超过8
325	TEST_F(l2_reduce_nansum_test, ascend910B2_case_test_dimension) {
326	auto selfDesc = TensorDesc({2, 2, 1, 1, 1, 1, 1, 1, 1, 1}, ACL_FLOAT, ACL_FORMAT_ND);
327	auto outDesc = TensorDesc({1, 2, 1, 1, 1, 1, 1, 1, 1, 1}, ACL_FLOAT, ACL_FORMAT_ND);
328	auto dim = IntArrayDesc(vector<int64_t>{0});
329	bool keep_dim = true;
330	auto ut = OP_API_UT(aclnnReduceNansum, INPUT(selfDesc, dim, keep_dim, ACL_FLOAT), OUTPUT(outDesc));
331
332	uint64_t workspaceSize = 0;
333	aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
334	EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
335	}

Mmath/reduce_std_v2/op_api/aclnn_std.cpp+229-222

	@@ -9,7 +9,7 @@
9	*/	9	*/
10	#include "aclnn_std.h"	10	#include "aclnn_std.h"
11	#include <bitset>	11	#include <bitset>
12	#include "math/reduce_std_with_mean/op_host/op_api/reduce_std_with_mean.h"	12	#include "math/reduce_std_with_mean/op_api/reduce_std_with_mean.h"
13	#include "math/reduce_mean/op_api/reduce_mean.h"	13	#include "math/reduce_mean/op_api/reduce_mean.h"
14	#include "reduce_std_v2.h"	14	#include "reduce_std_v2.h"
15	#include "aclnn_kernels/cast.h"	15	#include "aclnn_kernels/cast.h"
	@@ -57,144 +57,151 @@ extern "C" {
57		57
58	constexpr size_t MAX_MASK_LEN = 64;	58	constexpr size_t MAX_MASK_LEN = 64;
59	// 根据API定义，需要列出所能支持的所有dtype	59	// 根据API定义，需要列出所能支持的所有dtype
60	static const std::initializer_list<op::DataType> ASCEND910_DTYPE_DTYPE_SUPPORT_LIST = {	60	static const std::initializer_list<op::DataType> ASCEND910_DTYPE_DTYPE_SUPPORT_LIST = {op::DataType::DT_FLOAT,
61	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16};	61	op::DataType::DT_FLOAT16};
62		62
63	static const std::initializer_list<op::DataType> ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST = {	63	static const std::initializer_list<op::DataType> ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST = {
64	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};	64	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};
65		65
66	static bool CheckDtypeValid(const aclTensor self, const aclTensor out) {	66	static bool CheckDtypeValid(const aclTensor* self, const aclTensor* out)
67	// 检查self的数据类型是否在std算子的支持列表内	67	{
68	auto supportList = GetDtypeSupportListV2(ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST, ASCEND910_DTYPE_DTYPE_SUPPORT_LIST);	68	// 检查self的数据类型是否在std算子的支持列表内
69	OP_CHECK_DTYPE_NOT_SUPPORT(self, supportList, return false);	69	auto supportList = GetDtypeSupportListV2(ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST, ASCEND910_DTYPE_DTYPE_SUPPORT_LIST);
		70	OP_CHECK_DTYPE_NOT_SUPPORT(self, supportList, return false);
70		71
71	// 检查out的数据类型是否在std算子的支持列表内	72	// 检查out的数据类型是否在std算子的支持列表内
72	OP_CHECK_DTYPE_NOT_SUPPORT(out, supportList, return false);	73	OP_CHECK_DTYPE_NOT_SUPPORT(out, supportList, return false);
73		74
74	// 检查self的数据类型能否转换为输出的数据类型	75	// 检查self的数据类型能否转换为输出的数据类型
75	OP_CHECK_RESULT_DTYPE_CAST_FAILED(self->GetDataType(), out->GetDataType(), return false);	76	OP_CHECK_RESULT_DTYPE_CAST_FAILED(self->GetDataType(), out->GetDataType(), return false);
76		77
77	return true;
78	}
79
80	static bool CheckDimValid(const aclTensor self, const aclIntArray dim) {
81	auto selfViewShape = self->GetViewShape();
82	auto selfDimNum = static_cast<int64_t>(selfViewShape.GetDimNum());
83	// 0维tensor
84	if (selfDimNum == 0) {
85	selfDimNum = 1;
86	}
87	uint64_t dimMask[64] = {0};
88	// dim可以为空指针
89	if (dim == nullptr) {
90	return true;	78	return true;
91	}
92	// 获取dim元素
93	for (size_t i = 0; i < dim->Size(); i++) {
94	// dim值不能超出范围
95	if (dim->operator[](i) >= selfDimNum \|\| dim->operator[](i) < (-selfDimNum)) {
96	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Provided dim %ld must be in the range of [%ld, %ld].",
97	dim->operator[](i), -selfDimNum, selfDimNum - 1);
98	return false;
99	}
100	// dim值可以为负
101	if (dim->operator[](i) < 0) {
102	if (dimMask[selfDimNum + dim->operator[](i)] == 1) {
103	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dim %ld appears multiple times in the list of dims.",
104	selfDimNum + dim->operator[](i));
105	return false;
106	} else {
107	dimMask[selfDimNum + dim->operator[](i)] = 1;
108	}
109	continue;
110	}
111	// dim值不能重复
112	if (dimMask[dim->operator[](i)] == 1) {
113	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dim %ld appears multiple times in the list of dims.", dim->operator[](i));
114	return false;
115	} else {
116	dimMask[dim->operator[](i)] = 1;
117	}
118	}
119	return true;
120	}	79	}
121		80
122	static void StdInferShape(const op::Shape& selfShape, const aclIntArray* dim, bool keepDim, op::Shape& reduceShape) {	81	static bool CheckDimValid(const aclTensor* self, const aclIntArray* dim)
123	bitset<MAX_MASK_LEN> dimMask = bitset<MAX_MASK_LEN>();	82	{
124	for (size_t i = 0; i < dim->Size(); i++) {	83	auto selfViewShape = self->GetViewShape();
125	int64_t index = GetPosDimWithStd(dim->operator[](i), selfShape.GetDimNum());	84	auto selfDimNum = static_cast<int64_t>(selfViewShape.GetDimNum());
126	// 前序已检查，此处如果dim不会重复	85	// 0维tensor
127	dimMask.set(index);	86	if (selfDimNum == 0) {
128	}	87	selfDimNum = 1;
129		88	}
130	for (size_t i = 0; i < selfShape.GetDimNum(); i++) {	89	uint64_t dimMask[64] = {0};
131	if (!dimMask[i]) {	90	// dim可以为空指针
132	reduceShape.AppendDim(selfShape.GetDim(i));	91	if (dim == nullptr) {
133	} else if (keepDim) {	92	return true;
134	reduceShape.AppendDim(1);	93	}
		94	// 获取dim元素
		95	for (size_t i = 0; i < dim->Size(); i++) {
		96	// dim值不能超出范围
		97	if (dim->operator[](i) >= selfDimNum \|\| dim->operator[](i) < (-selfDimNum)) {
		98	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Provided dim %ld must be in the range of [%ld, %ld].", dim->operator[](i),
		99	-selfDimNum, selfDimNum - 1);
		100	return false;
		101	}
		102	// dim值可以为负
		103	if (dim->operator[](i) < 0) {
		104	if (dimMask[selfDimNum + dim->operator[](i)] == 1) {
		105	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dim %ld appears multiple times in the list of dims.",
		106	selfDimNum + dim->operator[](i));
		107	return false;
		108	} else {
		109	dimMask[selfDimNum + dim->operator[](i)] = 1;
		110	}
		111	continue;
		112	}
		113	// dim值不能重复
		114	if (dimMask[dim->operator[](i)] == 1) {
		115	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dim %ld appears multiple times in the list of dims.", dim->operator[](i));
		116	return false;
		117	} else {
		118	dimMask[dim->operator[](i)] = 1;
		119	}
135	}	120	}
136	}
137	}
138	static bool CheckShape(const aclTensor* self, const aclIntArray* dim, const bool keepDim, const aclTensor* out) {
139	OP_CHECK_MAX_DIM(self, MAX_SUPPORT_DIMS_NUMS, return false);
140	OP_CHECK_MAX_DIM(out, MAX_SUPPORT_DIMS_NUMS, return false);
141	// dim可以为空指针
142	if (dim == nullptr \|\| dim->Size() == 0) {
143	return true;	121	return true;
144	}
145	op::Shape reduceShape;
146	StdInferShape(self->GetViewShape(), dim, keepDim, reduceShape);
147
148	// out的shape必须满足Infer shape
149	OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(out, reduceShape, return false);
150	return true;
151	}	122	}
152		123
153	static aclnnStatus CheckParams(const aclTensor* self, const aclIntArray* dim, const bool keepdim,	124	static void StdInferShape(const op::Shape& selfShape, const aclIntArray* dim, bool keepDim, op::Shape& reduceShape)
154	aclTensor* out) {	125	{
155	// 1. 检查参数是否为空指针	126	bitset<MAX_MASK_LEN> dimMask = bitset<MAX_MASK_LEN>();
156	CHECK_RET(CheckNotNull2Tensor(self, out), ACLNN_ERR_PARAM_NULLPTR);	127	for (size_t i = 0; i < dim->Size(); i++) {
157		128	int64_t index = GetPosDimWithStd(dim->operator[](i), selfShape.GetDimNum());
158	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验	129	// 前序已检查，此处如果dim不会重复
159	CHECK_RET(CheckDtypeValid(self, out), ACLNN_ERR_PARAM_INVALID);	130	dimMask.set(index);
160
161	// 3. 检查reduce的轴是否合理
162	CHECK_RET(CheckDimValid(self, dim), ACLNN_ERR_PARAM_INVALID);
163
164	// 4. 检查shape是否满足推导
165	CHECK_RET(CheckShape(self, dim, keepdim, out), ACLNN_ERR_PARAM_INVALID);
166
167	return ACLNN_SUCCESS;
168	}
169
170	static aclIntArray* CalcDim(const aclTensor self, aclOpExecutor executor){
171	FVector<int64_t> dimVector;
172	auto selfViewShape = self->GetViewShape();
173	size_t selfDimNum = selfViewShape.GetDimNum();
174	for (size_t i = 0; i < selfDimNum; i++){
175	dimVector.push_back(static_cast<int64_t>(i));
176	}
177	return executor->AllocIntArray(dimVector.data(), dimVector.size());
178	}
179
180	static aclIntArray* ConvToNotNegDim(const aclTensor self, const aclIntArray dim, aclOpExecutor *executor) {
181	FVector<int64_t> dimVector;
182	auto selfViewShape = self->GetViewShape();
183	int64_t selfDimNum = static_cast<int64_t>(selfViewShape.GetDimNum());
184	int64_t dimValue;
185	for (size_t i = 0; i < dim->Size(); i++) {
186	dimValue = static_cast<int64_t>(dim->operator[](i));
187	if (dimValue < 0) {
188	dimVector.push_back(dimValue + selfDimNum);
189	} else {
190	dimVector.push_back(dimValue);
191	}	131	}
192	}	132
193	return executor->AllocIntArray(dimVector.data(), dimVector.size());	133	for (size_t i = 0; i < selfShape.GetDimNum(); i++) {
		134	if (!dimMask[i]) {
		135	reduceShape.AppendDim(selfShape.GetDim(i));
		136	} else if (keepDim) {
		137	reduceShape.AppendDim(1);
		138	}
		139	}
		140	}
		141	static bool CheckShape(const aclTensor* self, const aclIntArray* dim, const bool keepDim, const aclTensor* out)
		142	{
		143	OP_CHECK_MAX_DIM(self, MAX_SUPPORT_DIMS_NUMS, return false);
		144	OP_CHECK_MAX_DIM(out, MAX_SUPPORT_DIMS_NUMS, return false);
		145	// dim可以为空指针
		146	if (dim == nullptr \|\| dim->Size() == 0) {
		147	return true;
		148	}
		149	op::Shape reduceShape;
		150	StdInferShape(self->GetViewShape(), dim, keepDim, reduceShape);
		151
		152	// out的shape必须满足Infer shape
		153	OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(out, reduceShape, return false);
		154	return true;
194	}	155	}
195		156
196	static aclnnStatus aclnnStdV2ImplUnify(const aclTensor self, const aclIntArray dim, int64_t correction,	157	static aclnnStatus CheckParams(const aclTensor* self, const aclIntArray* dim, const bool keepdim, aclTensor* out)
197	bool keepdim, aclTensor out, uint64_t workspaceSize, UniqueExecutor &uniqueExecutor, aclOpExecutor **executor)	158	{
		159	// 1. 检查参数是否为空指针
		160	CHECK_RET(CheckNotNull2Tensor(self, out), ACLNN_ERR_PARAM_NULLPTR);
		161
		162	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验
		163	CHECK_RET(CheckDtypeValid(self, out), ACLNN_ERR_PARAM_INVALID);
		164
		165	// 3. 检查reduce的轴是否合理
		166	CHECK_RET(CheckDimValid(self, dim), ACLNN_ERR_PARAM_INVALID);
		167
		168	// 4. 检查shape是否满足推导
		169	CHECK_RET(CheckShape(self, dim, keepdim, out), ACLNN_ERR_PARAM_INVALID);
		170
		171	return ACLNN_SUCCESS;
		172	}
		173
		174	static aclIntArray* CalcDim(const aclTensor* self, aclOpExecutor* executor)
		175	{
		176	FVector<int64_t> dimVector;
		177	auto selfViewShape = self->GetViewShape();
		178	size_t selfDimNum = selfViewShape.GetDimNum();
		179	for (size_t i = 0; i < selfDimNum; i++) {
		180	dimVector.push_back(static_cast<int64_t>(i));
		181	}
		182	return executor->AllocIntArray(dimVector.data(), dimVector.size());
		183	}
		184
		185	static aclIntArray* ConvToNotNegDim(const aclTensor* self, const aclIntArray* dim, aclOpExecutor* executor)
		186	{
		187	FVector<int64_t> dimVector;
		188	auto selfViewShape = self->GetViewShape();
		189	int64_t selfDimNum = static_cast<int64_t>(selfViewShape.GetDimNum());
		190	int64_t dimValue;
		191	for (size_t i = 0; i < dim->Size(); i++) {
		192	dimValue = static_cast<int64_t>(dim->operator[](i));
		193	if (dimValue < 0) {
		194	dimVector.push_back(dimValue + selfDimNum);
		195	} else {
		196	dimVector.push_back(dimValue);
		197	}
		198	}
		199	return executor->AllocIntArray(dimVector.data(), dimVector.size());
		200	}
		201
		202	static aclnnStatus aclnnStdV2ImplUnify(const aclTensor* self, const aclIntArray* dim, int64_t correction, bool keepdim,
		203	aclTensor* out, uint64_t* workspaceSize, UniqueExecutor& uniqueExecutor,
		204	aclOpExecutor** executor)
198	{	205	{
199	bool isMeanOut = false;	206	bool isMeanOut = false;
200	auto reduceStdV2Out = l0op::ReduceStdV2(self, dim, correction, keepdim, isMeanOut, uniqueExecutor.get());	207	auto reduceStdV2Out = l0op::ReduceStdV2(self, dim, correction, keepdim, isMeanOut, uniqueExecutor.get());
	@@ -213,124 +220,124 @@ static aclnnStatus aclnnStdV2ImplUnify(const aclTensor *self, const aclIntArray
213	return ACLNN_SUCCESS;	220	return ACLNN_SUCCESS;
214	}	221	}
215		222
216	aclnnStatus aclnnStdGetWorkspaceSize(const aclTensor self, const aclIntArray dim, const int64_t correction,	223	aclnnStatus aclnnStdGetWorkspaceSize(const aclTensor* self, const aclIntArray* dim, const int64_t correction,
217	bool keepdim, aclTensor out, uint64_t workspaceSize,	224	bool keepdim, aclTensor* out, uint64_t* workspaceSize, aclOpExecutor** executor)
218	aclOpExecutor **executor) {	225	{
219	OP_CHECK_COMM_INPUT(workspaceSize, executor);	226	OP_CHECK_COMM_INPUT(workspaceSize, executor);
220		227
221	L2_DFX_PHASE_1(aclnnStd, DFX_IN(self, dim, correction, keepdim), DFX_OUT(out));	228	L2_DFX_PHASE_1(aclnnStd, DFX_IN(self, dim, correction, keepdim), DFX_OUT(out));
222		229
223	// 固定写法，创建OpExecutor	230	// 固定写法，创建OpExecutor
224	auto uniqueExecutor = CREATE_EXECUTOR();	231	auto uniqueExecutor = CREATE_EXECUTOR();
225	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);	232	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
226		233
227	// 固定写法，参数检查	234	// 固定写法，参数检查
228	auto selfReshape = self;	235	auto selfReshape = self;
229	auto ret = CheckParams(selfReshape, dim, keepdim, out);	236	auto ret = CheckParams(selfReshape, dim, keepdim, out);
230	CHECK_RET(ret == ACLNN_SUCCESS, ret);	237	CHECK_RET(ret == ACLNN_SUCCESS, ret);
231		238
232	if (self->GetViewShape().GetDimNum() == 0) {	239	if (self->GetViewShape().GetDimNum() == 0) {
233	int64_t selfShapeValue[1] = {1};	240	int64_t selfShapeValue[1] = {1};
234	aclIntArray *selfShape = uniqueExecutor.get()->AllocIntArray(selfShapeValue, 1);	241	aclIntArray* selfShape = uniqueExecutor.get()->AllocIntArray(selfShapeValue, 1);
235	CHECK_RET(selfShape != nullptr, ACLNN_ERR_INNER_NULLPTR);	242	CHECK_RET(selfShape != nullptr, ACLNN_ERR_INNER_NULLPTR);
236	auto selfReshapeI = l0op::Reshape(self, selfShape, uniqueExecutor.get());	243	auto selfReshapeI = l0op::Reshape(self, selfShape, uniqueExecutor.get());
237	CHECK_RET(selfReshapeI != nullptr, ACLNN_ERR_INNER_NULLPTR);	244	CHECK_RET(selfReshapeI != nullptr, ACLNN_ERR_INNER_NULLPTR);
238	selfReshape = selfReshapeI;	245	selfReshape = selfReshapeI;
239	}	246	}
240		247
241	const aclIntArray* dimArray;	248	const aclIntArray* dimArray;
242	if (dim == nullptr \|\| dim->Size() == 0) {	249	if (dim == nullptr \|\| dim->Size() == 0) {
243	// dim为空指针	250	// dim为空指针
244	dimArray = CalcDim(self, uniqueExecutor.get());	251	dimArray = CalcDim(self, uniqueExecutor.get());
245	} else {	252	} else {
246	// 负dim转成正值	253	// 负dim转成正值
247	dimArray = ConvToNotNegDim(selfReshape, dim, uniqueExecutor.get());	254	dimArray = ConvToNotNegDim(selfReshape, dim, uniqueExecutor.get());
248	}	255	}
249	CHECK_RET(dimArray != nullptr, ACLNN_ERR_INNER_NULLPTR);	256	CHECK_RET(dimArray != nullptr, ACLNN_ERR_INNER_NULLPTR);
250	// Std算子的空tensor在kernel中支持	257	// Std算子的空tensor在kernel中支持
251	if (selfReshape->IsEmpty()) {	258	if (selfReshape->IsEmpty()) {
252	// 空tensor填充NAN	259	// 空tensor填充NAN
253	ret = CheckFillScalarShapeStdAndVar(out, NAN, uniqueExecutor.get());	260	ret = CheckFillScalarShapeStdAndVar(out, NAN, uniqueExecutor.get());
254	*workspaceSize = 0UL;	261	*workspaceSize = 0UL;
255	uniqueExecutor.ReleaseTo(executor);	262	uniqueExecutor.ReleaseTo(executor);
256	return ret;	263	return ret;
257	}	264	}
258		265
259	// shapeProd小于等于correction场景	266	// shapeProd小于等于correction场景
260	int64_t shapeProd = 1;	267	int64_t shapeProd = 1;
261	shapeProd = CalcShapeProdStdAndVarMean(selfReshape, dimArray);	268	shapeProd = CalcShapeProdStdAndVarMean(selfReshape, dimArray);
262	if ((shapeProd == 1) && (shapeProd <= correction)) {	269	if ((shapeProd == 1) && (shapeProd <= correction)) {
263	// 返回NAN	270	// 返回NAN
264	ret = CheckFillScalarShapeStdAndVar(out, NAN, uniqueExecutor.get());	271	ret = CheckFillScalarShapeStdAndVar(out, NAN, uniqueExecutor.get());
265	*workspaceSize = 0UL;	272	*workspaceSize = 0UL;
266	uniqueExecutor.ReleaseTo(executor);	273	uniqueExecutor.ReleaseTo(executor);
267	return ret;	274	return ret;
268	}	275	}
269	if ((correction > 1) && (shapeProd <= correction)) {	276	if ((correction > 1) && (shapeProd <= correction)) {
270	// 返回INF	277	// 返回INF
271	ret = CheckFillScalarShapeStdAndVar(out, INFINITY, uniqueExecutor.get());	278	ret = CheckFillScalarShapeStdAndVar(out, INFINITY, uniqueExecutor.get());
272	*workspaceSize = 0UL;	279	*workspaceSize = 0UL;
273	uniqueExecutor.ReleaseTo(executor);	280	uniqueExecutor.ReleaseTo(executor);
274	return ret;	281	return ret;
275	}	282	}
276		283
277	// 固定写法，将输入self转换成连续的tensor	284	// 固定写法，将输入self转换成连续的tensor
278	auto selfContiguous = l0op::Contiguous(selfReshape, uniqueExecutor.get());	285	auto selfContiguous = l0op::Contiguous(selfReshape, uniqueExecutor.get());
279	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);	286	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
280		287
281	auto selfReformat = l0op::ReFormat(selfContiguous, Format::FORMAT_ND);	288	auto selfReformat = l0op::ReFormat(selfContiguous, Format::FORMAT_ND);
282	CHECK_RET(selfReformat != nullptr, ACLNN_ERR_INNER_NULLPTR);	289	CHECK_RET(selfReformat != nullptr, ACLNN_ERR_INNER_NULLPTR);
283		290
284	if (IsRegBase()) {	291	if (IsRegBase()) {
285	return aclnnStdV2ImplUnify(selfReformat, dimArray, correction, keepdim, out, workspaceSize,	292	return aclnnStdV2ImplUnify(selfReformat, dimArray, correction, keepdim, out, workspaceSize, uniqueExecutor,
286	uniqueExecutor, executor);	293	executor);
287	}	294	}
288		295
289	// 调用Mean算子kernel	296	// 调用Mean算子kernel
290	auto meanOpOut = l0op::ReduceMean(selfContiguous, dimArray, true, uniqueExecutor.get());	297	auto meanOpOut = l0op::ReduceMean(selfContiguous, dimArray, true, uniqueExecutor.get());
291	CHECK_RET(meanOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);	298	CHECK_RET(meanOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
292		299
293	// 调用Expand算子kernel	300	// 调用Expand算子kernel
294	FVector<int64_t> shapeVector;	301	FVector<int64_t> shapeVector;
295	auto selfShape = selfReshape->GetViewShape();	302	auto selfShape = selfReshape->GetViewShape();
296	size_t selfDimNum = selfShape.GetDimNum();	303	size_t selfDimNum = selfShape.GetDimNum();
297	for (size_t i = 0; i < selfDimNum; i++) {	304	for (size_t i = 0; i < selfDimNum; i++) {
298	shapeVector.emplace_back(selfShape[i]);	305	shapeVector.emplace_back(selfShape[i]);
299	}	306	}
300	auto shapeArray = uniqueExecutor.get()->AllocIntArray(shapeVector.data(), selfDimNum);	307	auto shapeArray = uniqueExecutor.get()->AllocIntArray(shapeVector.data(), selfDimNum);
301	CHECK_RET(shapeArray != nullptr, ACLNN_ERR_INNER_NULLPTR);	308	CHECK_RET(shapeArray != nullptr, ACLNN_ERR_INNER_NULLPTR);
302	auto expandOpOut = l0op::Expand(meanOpOut, shapeArray, uniqueExecutor.get());	309	auto expandOpOut = l0op::Expand(meanOpOut, shapeArray, uniqueExecutor.get());
303	CHECK_RET(expandOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);	310	CHECK_RET(expandOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
304		311
305	// 调用StdWithMean算子kernel	312	// 调用StdWithMean算子kernel
306	const aclTensor *stdWithMeanOpOut = nullptr;	313	const aclTensor* stdWithMeanOpOut = nullptr;
307	bool invert = false;	314	bool invert = false;
308	float eps = 0.001f;	315	float eps = 0.001f;
309	stdWithMeanOpOut = l0op::ReduceStdWithMean(selfContiguous, expandOpOut, dimArray, correction,	316	stdWithMeanOpOut = l0op::ReduceStdWithMean(selfContiguous, expandOpOut, dimArray, correction, keepdim, invert, eps,
310	keepdim, invert, eps, uniqueExecutor.get());	317	uniqueExecutor.get());
311	CHECK_RET(stdWithMeanOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);	318	CHECK_RET(stdWithMeanOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
312		319
313	// 固定写法，将计算结果转换成输出out的数据类型	320	// 固定写法，将计算结果转换成输出out的数据类型
314	auto castOut = l0op::Cast(stdWithMeanOpOut, out->GetDataType(), uniqueExecutor.get());	321	auto castOut = l0op::Cast(stdWithMeanOpOut, out->GetDataType(), uniqueExecutor.get());
315	CHECK_RET(castOut != nullptr, ACLNN_ERR_INNER_NULLPTR);	322	CHECK_RET(castOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
316		323
317	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor	324	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor
318	auto viewCopyResult = l0op::ViewCopy(castOut, out, uniqueExecutor.get());	325	auto viewCopyResult = l0op::ViewCopy(castOut, out, uniqueExecutor.get());
319	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);	326	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
320		327
321	// 固定写法，获取计算过程中需要使用的workspace大小	328	// 固定写法，获取计算过程中需要使用的workspace大小
322	*workspaceSize = uniqueExecutor->GetWorkspaceSize();	329	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
323	uniqueExecutor.ReleaseTo(executor); // 需要把 uniqueExecutor持有executor转移给executor	330	uniqueExecutor.ReleaseTo(executor); // 需要把 uniqueExecutor持有executor转移给executor
324	return ACLNN_SUCCESS;	331	return ACLNN_SUCCESS;
325	}	332	}
326		333
327	aclnnStatus aclnnStd(void *workspace, uint64_t workspaceSize,	334	aclnnStatus aclnnStd(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream)
328	aclOpExecutor *executor, const aclrtStream stream) {	335	{
329	L2_DFX_PHASE_2(aclnnStd);	336	L2_DFX_PHASE_2(aclnnStd);
330	// 固定写法，调用框架能力，完成计算	337	// 固定写法，调用框架能力，完成计算
331	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	338	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
332	}	339	}
333		340
334	#ifdef __cplusplus	341	#ifdef __cplusplus
335	}	342	}
336	#endif	343	#endif

Mmath/reduce_std_v2_update/CMakeLists.txt+3-12

	@@ -1,20 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11		10
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE reduce_std_v2_update ACLNNTYPE aclnn_exclude)
13	if(NOT ENABLE_TEST AND NOT BENCHMARK)
14	list(REMOVE_ITEM CURRENT_DIRS tests)
15	endif()
16	foreach(SUB_DIR ${CURRENT_DIRS})
17	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
18	add_subdirectory(${SUB_DIR})
19	endif()
20	endforeach()

Rmath/reduce_std_v2_update/op_host/op_api/reduce_std_v2_update.cpp→math/reduce_std_v2_update/op_api/reduce_std_v2_update.cpp+36-32

	@@ -29,38 +29,42 @@ using namespace op;
29	namespace l0op {	29	namespace l0op {
30	OP_TYPE_REGISTER(ReduceStdV2Update);	30	OP_TYPE_REGISTER(ReduceStdV2Update);
31		31
32	const aclTensor* ReduceStdV2Update(const aclTensor* self, const aclTensor* mean, const aclIntArray* dim,	32	const aclTensor* ReduceStdV2Update(const aclTensor* self, const aclTensor* mean, const aclIntArray* dim, bool unbiased,
33	bool unbiased, bool keepdim, aclOpExecutor* executor) {	33	bool keepdim, aclOpExecutor* executor)
34	L0_DFX(ReduceStdV2Update, self, mean, dim, unbiased, keepdim);	34	{
35	auto stdWithV2UpdateOut = executor->AllocTensor(self->GetDataType(),	35	L0_DFX(ReduceStdV2Update, self, mean, dim, unbiased, keepdim);
36	self->GetStorageFormat(), self->GetOriginalFormat());	36	auto stdWithV2UpdateOut = executor->AllocTensor(self->GetDataType(), self->GetStorageFormat(),
37	CHECK_RET(stdWithV2UpdateOut != nullptr, nullptr);	37	self->GetOriginalFormat());
38	bool if_std = false;	38	CHECK_RET(stdWithV2UpdateOut != nullptr, nullptr);
39	INFER_SHAPE(ReduceStdV2Update, OP_INPUT(self, mean), OP_OUTPUT(stdWithV2UpdateOut),	39	bool if_std = false;
40	OP_ATTR(dim, if_std, unbiased, keepdim));	40	INFER_SHAPE(ReduceStdV2Update, OP_INPUT(self, mean), OP_OUTPUT(stdWithV2UpdateOut),
41	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(ReduceStdV2Update, OP_INPUT(self, mean), OP_OUTPUT(stdWithV2UpdateOut),	41	OP_ATTR(dim, if_std, unbiased, keepdim));
42	OP_ATTR(dim, if_std, unbiased, keepdim));	42	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(ReduceStdV2Update, OP_INPUT(self, mean), OP_OUTPUT(stdWithV2UpdateOut),
43	OP_CHECK(ret == ACLNN_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "ReduceStdV2UpdateAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."),	43	OP_ATTR(dim, if_std, unbiased, keepdim));
44	return nullptr);	44	OP_CHECK(ret == ACLNN_SUCCESS,
45	return stdWithV2UpdateOut;	45	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "ReduceStdV2UpdateAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."),
		46	return nullptr);
		47	return stdWithV2UpdateOut;
46	}	48	}
47	const aclTensor* ReduceStdV2UpdateCorrection(const aclTensor* self, const aclTensor* mean, const aclIntArray* dim,	49	const aclTensor* ReduceStdV2UpdateCorrection(const aclTensor* self, const aclTensor* mean, const aclIntArray* dim,
48	int64_t correction, bool keepdim, aclOpExecutor* executor) {	50	int64_t correction, bool keepdim, aclOpExecutor* executor)
49	L0_DFX(ReduceStdV2UpdateCorrection, self, mean, dim, correction, keepdim);	51	{
50	auto stdWithV2UpdateOut = executor->AllocTensor(self->GetDataType(),	52	L0_DFX(ReduceStdV2UpdateCorrection, self, mean, dim, correction, keepdim);
51	self->GetStorageFormat(), self->GetOriginalFormat());	53	auto stdWithV2UpdateOut = executor->AllocTensor(self->GetDataType(), self->GetStorageFormat(),
52	CHECK_RET(stdWithV2UpdateOut != nullptr, nullptr);	54	self->GetOriginalFormat());
53	bool unbiased = true;	55	CHECK_RET(stdWithV2UpdateOut != nullptr, nullptr);
54	if (correction == 0) {	56	bool unbiased = true;
55	unbiased = false;	57	if (correction == 0) {
56	}	58	unbiased = false;
57	bool if_std = false;	59	}
58	INFER_SHAPE(ReduceStdV2Update, OP_INPUT(self, mean), OP_OUTPUT(stdWithV2UpdateOut),	60	bool if_std = false;
59	OP_ATTR(dim, if_std, unbiased, keepdim, correction));	61	INFER_SHAPE(ReduceStdV2Update, OP_INPUT(self, mean), OP_OUTPUT(stdWithV2UpdateOut),
60	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(ReduceStdV2Update, OP_INPUT(self, mean), OP_OUTPUT(stdWithV2UpdateOut),	62	OP_ATTR(dim, if_std, unbiased, keepdim, correction));
61	OP_ATTR(dim, if_std, unbiased, keepdim, correction));	63	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(ReduceStdV2Update, OP_INPUT(self, mean), OP_OUTPUT(stdWithV2UpdateOut),
62	OP_CHECK(ret == ACLNN_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "ReduceStdV2UpdateAiCcore ADD_TO_LAUNCHER_LIST_AICORE failed."),	64	OP_ATTR(dim, if_std, unbiased, keepdim, correction));
63	return nullptr);	65	OP_CHECK(ret == ACLNN_SUCCESS,
64	return stdWithV2UpdateOut;	66	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "ReduceStdV2UpdateAiCcore ADD_TO_LAUNCHER_LIST_AICORE failed."),
		67	return nullptr);
		68	return stdWithV2UpdateOut;
65	}	69	}
66	} // namespace l0op	70	} // namespace l0op

Rmath/reduce_std_v2_update/op_host/op_api/reduce_std_v2_update.h→math/reduce_std_v2_update/op_api/reduce_std_v2_update.h+4-4

	@@ -18,10 +18,10 @@
18	#include "opdev/op_executor.h"	18	#include "opdev/op_executor.h"
19		19
20	namespace l0op {	20	namespace l0op {
21	const aclTensor ReduceStdV2Update(const aclTensor self, const aclTensor mean, const aclIntArray dim,	21	const aclTensor* ReduceStdV2Update(const aclTensor* self, const aclTensor* mean, const aclIntArray* dim, bool unbiased,
22	bool unbiased, bool keepdim, aclOpExecutor *executor);	22	bool keepdim, aclOpExecutor* executor);
23	const aclTensor* ReduceStdV2UpdateCorrection(const aclTensor* self, const aclTensor* mean, const aclIntArray* dim,	23	const aclTensor* ReduceStdV2UpdateCorrection(const aclTensor* self, const aclTensor* mean, const aclIntArray* dim,
24	int64_t correction, bool keepdim, aclOpExecutor* executor);	24	int64_t correction, bool keepdim, aclOpExecutor* executor);
25	}	25	} // namespace l0op
26		26
27	#endif	27	#endif

Dmath/reduce_std_v2_update/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources()

Mmath/reduce_std_with_mean/CMakeLists.txt+4-12

	@@ -1,19 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	10
12	if(NOT ENABLE_TEST AND NOT BENCHMARK)	11	add_all_modules_sources(OPTYPE reduce_std_with_mean ACLNNTYPE aclnn_exclude)
13	list(REMOVE_ITEM CURRENT_DIRS tests)
14	endif()
15	foreach(SUB_DIR ${CURRENT_DIRS})
16	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
17	add_subdirectory(${SUB_DIR})
18	endif()
19	endforeach()

Rmath/reduce_std_with_mean/op_host/op_api/aclnn_batch_norm_stats.cpp→math/reduce_std_with_mean/op_api/aclnn_batch_norm_stats.cpp+33-32

	@@ -41,30 +41,32 @@ extern "C" {
41		41
42	constexpr float NEGTIVE_SQRT_EXP = -0.5f;	42	constexpr float NEGTIVE_SQRT_EXP = -0.5f;
43		43
44	static aclTensor* FillVector(const op::Shape dstShape, const aclTensor* src, float value, aclOpExecutor* executor) {	44	static aclTensor* FillVector(const op::Shape dstShape, const aclTensor* src, float value, aclOpExecutor* executor)
45	op::FVector<int64_t, op::MAX_DIM_NUM> fillDims = op::ToShapeVector(dstShape);	45	{
46	auto shapes = executor->AllocIntArray(fillDims.data(), src->GetViewShape().GetDimNum());	46	op::FVector<int64_t, op::MAX_DIM_NUM> fillDims = op::ToShapeVector(dstShape);
47	const aclTensor* dimTensor = executor->ConvertToTensor(shapes, op::DataType::DT_INT32);	47	auto shapes = executor->AllocIntArray(fillDims.data(), src->GetViewShape().GetDimNum());
48	const aclScalar* valueScalar = executor->AllocScalar(value);	48	const aclTensor* dimTensor = executor->ConvertToTensor(shapes, op::DataType::DT_INT32);
49	const aclTensor* valueTensor = executor->ConvertToTensor(valueScalar, src->GetDataType());	49	const aclScalar* valueScalar = executor->AllocScalar(value);
50	auto fillTensor = l0op::Fill(dimTensor, valueTensor, shapes, executor);	50	const aclTensor* valueTensor = executor->ConvertToTensor(valueScalar, src->GetDataType());
51	if (fillTensor == nullptr) {	51	auto fillTensor = l0op::Fill(dimTensor, valueTensor, shapes, executor);
52	return nullptr;	52	if (fillTensor == nullptr) {
53	}	53	return nullptr;
54	fillTensor = l0op::ReFormat(fillTensor, op::Format::FORMAT_ND);	54	}
55	return const_cast<aclTensor*>(fillTensor);	55	fillTensor = l0op::ReFormat(fillTensor, op::Format::FORMAT_ND);
		56	return const_cast<aclTensor*>(fillTensor);
56	}	57	}
57		58
58	static aclnnStatus ProcessEmptyTensorWithValue(aclTensor* src, float initValue, aclOpExecutor* executor) {	59	static aclnnStatus ProcessEmptyTensorWithValue(aclTensor* src, float initValue, aclOpExecutor* executor)
59	auto srcShape = src->GetViewShape();	60	{
60	auto dst = FillVector(srcShape, src, initValue, executor);	61	auto srcShape = src->GetViewShape();
61	auto dstCopyResult = l0op::ViewCopy(dst, src, executor);	62	auto dst = FillVector(srcShape, src, initValue, executor);
62	CHECK_RET(dstCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);	63	auto dstCopyResult = l0op::ViewCopy(dst, src, executor);
63	return ACLNN_SUCCESS;	64	CHECK_RET(dstCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
		65	return ACLNN_SUCCESS;
64	}	66	}
65		67
66	static const std::initializer_list<op::DataType> DTYPE_SUPPORT_LIST = {	68	static const std::initializer_list<op::DataType> DTYPE_SUPPORT_LIST = {op::DataType::DT_FLOAT,
67	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16};	69	op::DataType::DT_FLOAT16};
68		70
69	static const std::initializer_list<op::DataType> ASCEND950_DTYPE_SUPPORT_LIST = {	71	static const std::initializer_list<op::DataType> ASCEND950_DTYPE_SUPPORT_LIST = {
70	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};	72	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};
	@@ -137,9 +139,9 @@ static aclnnStatus CheckParams(const aclTensor* input, aclTensor* mean, aclTenso
137	return ACLNN_SUCCESS;	139	return ACLNN_SUCCESS;
138	}	140	}
139		141
140	static aclnnStatus aclnnBatchNormStatsImplUnify(	142	static aclnnStatus aclnnBatchNormStatsImplUnify(const aclTensor* input, const aclIntArray* dim, double eps,
141	const aclTensor* input, const aclIntArray* dim, double eps, aclTensor* meanOut, aclTensor* invstdOut,	143	aclTensor* meanOut, aclTensor* invstdOut, uint64_t* workspaceSize,
142	uint64_t* workspaceSize, UniqueExecutor& uniqueExecutor, aclOpExecutor** executor)	144	UniqueExecutor& uniqueExecutor, aclOpExecutor** executor)
143	{	145	{
144	int64_t correction = 0;	146	int64_t correction = 0;
145	bool keepdim = false;	147	bool keepdim = false;
	@@ -178,9 +180,8 @@ static aclnnStatus aclnnBatchNormStatsImplUnify(
178	return ACLNN_SUCCESS;	180	return ACLNN_SUCCESS;
179	}	181	}
180		182
181	aclnnStatus aclnnBatchNormStatsGetWorkspaceSize(	183	aclnnStatus aclnnBatchNormStatsGetWorkspaceSize(const aclTensor* input, double eps, aclTensor* meanOut,
182	const aclTensor* input, double eps, aclTensor* meanOut, aclTensor* invstdOut, uint64_t* workspaceSize,	184	aclTensor* invstdOut, uint64_t* workspaceSize, aclOpExecutor** executor)
183	aclOpExecutor** executor)
184	{	185	{
185	OP_CHECK_COMM_INPUT(workspaceSize, executor);	186	OP_CHECK_COMM_INPUT(workspaceSize, executor);
186		187
	@@ -223,8 +224,8 @@ aclnnStatus aclnnBatchNormStatsGetWorkspaceSize(
223	CHECK_RET(axes != nullptr, ACLNN_ERR_INNER_NULLPTR);	224	CHECK_RET(axes != nullptr, ACLNN_ERR_INNER_NULLPTR);
224		225
225	if (IsRegBase()) {	226	if (IsRegBase()) {
226	return aclnnBatchNormStatsImplUnify(	227	return aclnnBatchNormStatsImplUnify(reformat, axes, eps, meanOut, invstdOut, workspaceSize, uniqueExecutor,
227	reformat, axes, eps, meanOut, invstdOut, workspaceSize, uniqueExecutor, executor);	228	executor);
228	}	229	}
229		230
230	auto reduceMeanResult = l0op::ReduceMean(reformat, axes, false, uniqueExecutor.get());	231	auto reduceMeanResult = l0op::ReduceMean(reformat, axes, false, uniqueExecutor.get());
	@@ -241,8 +242,8 @@ aclnnStatus aclnnBatchNormStatsGetWorkspaceSize(
241	CHECK_RET(broadcast != nullptr, ACLNN_ERR_INNER_NULLPTR);	242	CHECK_RET(broadcast != nullptr, ACLNN_ERR_INNER_NULLPTR);
242		243
243	int64_t correction = 0;	244	int64_t correction = 0;
244	auto reduceStdWithMeanResult = l0op::ReduceStdWithMean(	245	auto reduceStdWithMeanResult = l0op::ReduceStdWithMean(reformat, broadcast, axes, correction, false, true,
245	reformat, broadcast, axes, correction, false, true, static_cast<float>(eps), uniqueExecutor.get());	246	static_cast<float>(eps), uniqueExecutor.get());
246	CHECK_RET(reduceStdWithMeanResult != nullptr, ACLNN_ERR_INNER_NULLPTR);	247	CHECK_RET(reduceStdWithMeanResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
247		248
248	auto view_copy_invstd = l0op::ViewCopy(reduceStdWithMeanResult, invstdOut, uniqueExecutor.get());	249	auto view_copy_invstd = l0op::ViewCopy(reduceStdWithMeanResult, invstdOut, uniqueExecutor.get());
	@@ -253,8 +254,8 @@ aclnnStatus aclnnBatchNormStatsGetWorkspaceSize(
253	return ACLNN_SUCCESS;	254	return ACLNN_SUCCESS;
254	}	255	}
255		256
256	aclnnStatus aclnnBatchNormStats(	257	aclnnStatus aclnnBatchNormStats(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor,
257	void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream)	258	const aclrtStream stream)
258	{	259	{
259	L2_DFX_PHASE_2(aclnnBatchNormStats);	260	L2_DFX_PHASE_2(aclnnBatchNormStats);
260	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	261	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);

Rmath/reduce_std_with_mean/op_host/op_api/aclnn_batch_norm_stats.h→math/reduce_std_with_mean/op_api/aclnn_batch_norm_stats.h+5-5

	@@ -21,15 +21,15 @@ extern "C" {
21	* @brief aclnnBatchNormStats的第一段接口，根据具体的计算流程，计算workspace大小。	21	* @brief aclnnBatchNormStats的第一段接口，根据具体的计算流程，计算workspace大小。
22	* @domain aclnn_ops_train	22	* @domain aclnn_ops_train
23	*/	23	*/
24	ACLNN_API aclnnStatus aclnnBatchNormStatsGetWorkspaceSize(	24	ACLNN_API aclnnStatus aclnnBatchNormStatsGetWorkspaceSize(const aclTensor* input, double eps, aclTensor* mean,
25	const aclTensor* input, double eps, aclTensor* mean, aclTensor* invstd, uint64_t* workspaceSize,	25	aclTensor* invstd, uint64_t* workspaceSize,
26	aclOpExecutor** executor);	26	aclOpExecutor** executor);
27		27
28	/**	28	/**
29	* @brief aclnnBatchNormStats的第二段接口，用于执行计算。	29	* @brief aclnnBatchNormStats的第二段接口，用于执行计算。
30	*/	30	*/
31	ACLNN_API aclnnStatus	31	ACLNN_API aclnnStatus aclnnBatchNormStats(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor,
32	aclnnBatchNormStats(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream);	32	const aclrtStream stream);
33		33
34	#ifdef __cplusplus	34	#ifdef __cplusplus
35	}	35	}

Amath/reduce_std_with_mean/op_api/aclnn_std_mean_correction.cpp+387-0

@@ -0,0 +1,387 @@
	1	/**
	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10	#include "aclnn_std_mean_correction.h"
	11	#include <bitset>
	12	#include "reduce_std_with_mean.h"
	13	#include "math/reduce_mean/op_api/reduce_mean.h"
	14	#include "math/reduce_std_v2/op_api/reduce_std_v2.h"
	15	#include "aclnn_kernels/cast.h"
	16	#include "aclnn_kernels/contiguous.h"
	17	#include "aclnn_kernels/transdata.h"
	18	#include "conversion/unsqueeze/op_host/op_api/unsqueeze.h"
	19	#include "math/expand/op_api/expand.h"
	20	#include "opdev/common_types.h"
	21	#include "opdev/data_type_utils.h"
	22	#include "opdev/format_utils.h"
	23	#include "opdev/op_dfx.h"
	24	#include "opdev/op_executor.h"
	25	#include "opdev/shape_utils.h"
	26	#include "opdev/tensor_view_utils.h"
	27	#include "aclnn_kernels/common/op_error_check.h"
	28	#include "op_api/op_api_def.h"
	29	#include "opdev/platform.h"
	30	#include "opdev/op_log.h"
	31	#include "op_api/level2_base_caculation.h"
	32	#include "op_api/aclnn_check.h"
	33
	34	using namespace op;
	35	using std::bitset;
	36
	37	#ifdef __cplusplus
	38	extern "C" {
	39	#endif
	40
	41	constexpr size_t MAX_MASK_NUM = 64;
	42	static const bool invert = false;
	43	static const float eps = 0.001f;
	44	// 根据API定义，需要列出所能支持的所有dtype
	45	static const std::initializer_list<op::DataType> ASCEND910_DTYPE_DTYPE_SUPPORT_LIST = {op::DataType::DT_FLOAT,
	46	op::DataType::DT_FLOAT16};
	47
	48	static const std::initializer_list<op::DataType> ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST = {
	49	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};
	50
	51	static bool CheckDtypeValid(const aclTensor* self, const aclTensor* stdOut, const aclTensor* meanOut)
	52	{
	53	// 检查self的数据类型是否在算子的支持列表内
	54	auto supportList = GetDtypeSupportListV2(ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST, ASCEND910_DTYPE_DTYPE_SUPPORT_LIST);
	55	OP_CHECK_DTYPE_NOT_SUPPORT(self, supportList, return false);
	56
	57	// 检查stdOut、meanOut的数据类型是否在算子的支持列表内
	58	OP_CHECK_DTYPE_NOT_SUPPORT(stdOut, supportList, return false);
	59	OP_CHECK_DTYPE_NOT_SUPPORT(meanOut, supportList, return false);
	60
	61	// Ascend950支持输入、输出数据类型不一致
	62	if (IsRegBase()) {
	63	return true;
	64	}
	65
	66	// 检查self的数据类型是否输出的数据类型一致
	67	OP_CHECK_DTYPE_NOT_MATCH(self, stdOut->GetDataType(), return false);
	68	OP_CHECK_DTYPE_NOT_MATCH(self, meanOut->GetDataType(), return false);
	69	return true;
	70	}
	71
	72	static bool CheckDimValid(const aclTensor* self, const aclIntArray* dim)
	73	{
	74	auto selfViewShape = self->GetViewShape();
	75	auto selfDimNum = static_cast<int64_t>(selfViewShape.GetDimNum());
	76	int64_t dimMin = std::min(-1 * selfDimNum, selfDimNum - 1);
	77	int64_t dimMax = std::max(-1 * selfDimNum, selfDimNum - 1);
	78	// 0维tensor
	79	if (selfDimNum == 0) {
	80	selfDimNum = 1;
	81	}
	82	bool dimMask[64] = {false};
	83	// dim可以为空指针
	84	if (dim == nullptr) {
	85	return true;
	86	}
	87	// 获取dim元素
	88	for (size_t i = 0; i < dim->Size(); i++) {
	89	// dim值不能超出范围
	90	auto currentDim = dim->operator[](i);
	91	if (currentDim > dimMax \|\| currentDim < dimMin) {
	92	OP_LOGE(ACLNN_ERR_PARAM_INVALID,
	93	"Dimension out of range (expected to be in range of [%ld, %ld], but got %ld)", dimMin, dimMax,
	94	selfDimNum);
	95	return false;
	96	}
	97	// dim值可以为负
	98	if (currentDim < 0) {
	99	currentDim = currentDim + selfDimNum;
	100	}
	101	// dim值不能重复
	102	if (dimMask[currentDim]) {
	103	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dim %ld appears multiple times in the list of dims.", currentDim);
	104	return false;
	105	}
	106	dimMask[currentDim] = true;
	107	}
	108	return true;
	109	}
	110
	111	static void OutInferShape(const op::Shape& selfShape, const aclIntArray* dim, bool keepDim, op::Shape& reduceShape)
	112	{
	113	bitset<MAX_MASK_NUM> dimTmp = bitset<MAX_MASK_NUM>();
	114	for (size_t i = 0; i < dim->Size(); i++) {
	115	int64_t index = GetPosDimWithStd(dim->operator[](i), selfShape.GetDimNum());
	116	// 前序已检查，此处如果dim不会重复
	117	dimTmp.set(index);
	118	}
	119
	120	for (size_t i = 0; i < selfShape.GetDimNum(); i++) {
	121	if (!dimTmp[i]) {
	122	reduceShape.AppendDim(selfShape.GetDim(i));
	123	} else if (keepDim) {
	124	reduceShape.AppendDim(1);
	125	}
	126	}
	127	}
	128
	129	static bool CheckShape(const aclTensor* self, const aclIntArray* dim, const bool keepDim, const aclTensor* stdOut,
	130	const aclTensor* meanOut)
	131	{
	132	OP_CHECK_MAX_DIM(self, MAX_SUPPORT_DIMS_NUMS, return false);
	133	OP_CHECK_MAX_DIM(stdOut, MAX_SUPPORT_DIMS_NUMS, return false);
	134	OP_CHECK_MAX_DIM(meanOut, MAX_SUPPORT_DIMS_NUMS, return false);
	135	// dim可以为空指针
	136	if (dim == nullptr \|\| dim->Size() == 0) {
	137	return true;
	138	}
	139	op::Shape reduceShape;
	140	OutInferShape(self->GetViewShape(), dim, keepDim, reduceShape);
	141	// stdOut的shape必须满足Infer shape
	142	OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(stdOut, reduceShape, return false);
	143	// meanOut的shape必须满足Infer shape
	144	OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(meanOut, reduceShape, return false);
	145	return true;
	146	}
	147
	148	static aclnnStatus CheckParams(const aclTensor* self, const aclIntArray* dim, const bool keepdim,
	149	const aclTensor* stdOut, const aclTensor* meanOut)
	150	{
	151	// 1. 检查参数是否为空指针
	152	CHECK_RET(CheckNotNull3Tensor(self, stdOut, meanOut), ACLNN_ERR_PARAM_NULLPTR);
	153
	154	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验
	155	CHECK_RET(CheckDtypeValid(self, stdOut, meanOut), ACLNN_ERR_PARAM_INVALID);
	156
	157	// 3. 检查reduce的轴是否合理
	158	CHECK_RET(CheckDimValid(self, dim), ACLNN_ERR_PARAM_INVALID);
	159
	160	// 4. 检查shape是否满足推导
	161	CHECK_RET(CheckShape(self, dim, keepdim, stdOut, meanOut), ACLNN_ERR_PARAM_INVALID);
	162
	163	return ACLNN_SUCCESS;
	164	}
	165
	166	static aclIntArray* CalcDim(const aclTensor* self, aclOpExecutor* executor)
	167	{
	168	FVector<int64_t> dimVector;
	169	auto selfViewShape = self->GetViewShape();
	170	size_t selfDimNum = selfViewShape.GetDimNum();
	171	for (size_t i = 0; i < selfDimNum; i++) {
	172	dimVector.push_back(static_cast<int64_t>(i));
	173	}
	174	return executor->AllocIntArray(dimVector.data(), dimVector.size());
	175	}
	176
	177	static const aclIntArray* GetDimArray(const aclTensor* self, const aclIntArray* dim, aclOpExecutor* executor)
	178	{
	179	const aclIntArray* dimArray = dim;
	180	if (dim == nullptr \|\| dim->Size() == 0) {
	181	dimArray = CalcDim(self, executor);
	182	}
	183	CHECK_RET(dimArray != nullptr, nullptr);
	184	return dimArray;
	185	}
	186
	187	static int64_t CalcShapeProd(const aclTensor* self, const aclIntArray* dim)
	188	{
	189	auto selfViewShape = self->GetViewShape();
	190	int64_t shapeProd = 1;
	191	size_t selfDimNum = selfViewShape.GetDimNum();
	192	if (selfDimNum != 0) {
	193	// dim为all reduce
	194	if (dim->Size() == 0) {
	195	for (size_t i = 0; i < selfDimNum; i++) {
	196	shapeProd *= selfViewShape.GetDim(i);
	197	}
	198	} else {
	199	for (size_t i = 0; i < dim->Size(); i++) {
	200	auto oriDim = dim->operator[](i);
	201	auto realDim = oriDim < 0 ? oriDim + selfDimNum : oriDim;
	202	shapeProd *= selfViewShape.GetDim(realDim);
	203	}
	204	}
	205	}
	206	return shapeProd;
	207	}
	208
	209	static const aclTensor* GetExpandMean(const aclTensor* self, const aclTensor* meanOpOut, const aclIntArray* dimArray,
	210	bool keepdim, aclOpExecutor* executor)
	211	{
	212	auto meanOpOutTmp = keepdim ? meanOpOut : l0op::UnsqueezeNd(meanOpOut, dimArray, executor);
	213	CHECK_RET(meanOpOutTmp != nullptr, nullptr);
	214	// 调用Expand算子kernel
	215	FVector<int64_t> shapeVector;
	216	auto selfShape = self->GetViewShape();
	217	size_t selfDimNum = selfShape.GetDimNum();
	218	if (!selfDimNum) {
	219	return meanOpOutTmp;
	220	}
	221	for (size_t i = 0; i < selfDimNum; i++) {
	222	shapeVector.emplace_back(selfShape[i]);
	223	}
	224	auto shapeArray = executor->AllocIntArray(shapeVector.data(), selfDimNum);
	225	CHECK_RET(shapeArray != nullptr, nullptr);
	226	auto expandOpOut = l0op::Expand(meanOpOutTmp, shapeArray, executor);
	227	CHECK_RET(expandOpOut != nullptr, nullptr);
	228	return expandOpOut;
	229	}
	230
	231	static aclnnStatus DealEmpty(aclTensor* stdOut, aclTensor* meanOut, aclOpExecutor* executor)
	232	{
	233	auto ret = CheckFillScalarShapeStdAndVar(stdOut, NAN, executor);
	234	CHECK_RET(ret == ACLNN_SUCCESS, ret);
	235	ret = CheckFillScalarShapeStdAndVar(meanOut, NAN, executor);
	236	CHECK_RET(ret == ACLNN_SUCCESS, ret);
	237	return ACLNN_SUCCESS;
	238	}
	239
	240	static aclnnStatus DealshapeProdNAN(const aclTensor* meanOpOut, aclTensor* stdOut, aclTensor* meanOut,
	241	aclOpExecutor* executor)
	242	{
	243	// stdOut返回NAN
	244	auto ret = CheckFillScalarShapeStdAndVar(stdOut, NAN, executor);
	245	CHECK_RET(ret == ACLNN_SUCCESS, ret);
	246	// 固定写法，将计算结果拷贝到输出meanOut上，meanOut可能是非连续的tensor
	247	auto viewCopyMeanResult = l0op::ViewCopy(meanOpOut, meanOut, executor);
	248	CHECK_RET(viewCopyMeanResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
	249	return ACLNN_SUCCESS;
	250	}
	251
	252	static aclnnStatus DealshapeProdINF(const aclTensor* meanOpOut, aclTensor* stdOut, aclTensor* meanOut,
	253	aclOpExecutor* executor)
	254	{
	255	// stdOut返回INF
	256	auto ret = CheckFillScalarShapeStdAndVar(stdOut, INFINITY, executor);
	257	CHECK_RET(ret == ACLNN_SUCCESS, ret);
	258	// 固定写法，将计算结果拷贝到输出meanOut上，meanOut可能是非连续的tensor
	259	auto viewCopyMeanResult = l0op::ViewCopy(meanOpOut, meanOut, executor);
	260	CHECK_RET(viewCopyMeanResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
	261	return ACLNN_SUCCESS;
	262	}
	263
	264	static aclnnStatus aclnnStdMeanCorrectionImplUnify(const aclTensor* self, const aclIntArray* dim, int64_t correction,
	265	bool keepdim, aclTensor* stdOut, aclTensor* meanOut,
	266	uint64_t* workspaceSize, UniqueExecutor& uniqueExecutor,
	267	aclOpExecutor** executor)
	268	{
	269	bool isMeanOut = true;
	270	auto reduceStdOut = l0op::ReduceStdV2(self, dim, correction, keepdim, isMeanOut, uniqueExecutor.get());
	271
	272	auto stdOpOut = std::get<0>(reduceStdOut);
	273	CHECK_RET(stdOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
	274	auto castOut = l0op::Cast(stdOpOut, stdOut->GetDataType(), uniqueExecutor.get());
	275	CHECK_RET(castOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
	276	auto viewCopyResult = l0op::ViewCopy(castOut, stdOut, uniqueExecutor.get());
	277	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
	278
	279	auto meanOpOut = std::get<1>(reduceStdOut);
	280	CHECK_RET(meanOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
	281	auto castOut1 = l0op::Cast(meanOpOut, meanOut->GetDataType(), uniqueExecutor.get());
	282	CHECK_RET(castOut1 != nullptr, ACLNN_ERR_INNER_NULLPTR);
	283	auto viewCopyResult1 = l0op::ViewCopy(castOut1, meanOut, uniqueExecutor.get());
	284	CHECK_RET(viewCopyResult1 != nullptr, ACLNN_ERR_INNER_NULLPTR);
	285
	286	// 获取计算过程中需要使用的workspace大小
	287	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
	288	uniqueExecutor.ReleaseTo(executor);
	289
	290	return ACLNN_SUCCESS;
	291	}
	292
	293	aclnnStatus aclnnStdMeanCorrectionGetWorkspaceSize(const aclTensor* self, const aclIntArray* dim, int64_t correction,
	294	bool keepdim, aclTensor* stdOut, aclTensor* meanOut,
	295	uint64_t* workspaceSize, aclOpExecutor** executor)
	296	{
	297	OP_CHECK_COMM_INPUT(workspaceSize, executor);
	298
	299	L2_DFX_PHASE_1(aclnnStdMeanCorrection, DFX_IN(self, dim, correction, keepdim), DFX_OUT(stdOut, meanOut));
	300
	301	// 固定写法，创建OpExecutor
	302	auto uniqueExecutor = CREATE_EXECUTOR();
	303	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
	304
	305	// 固定写法，参数检查
	306	auto ret = CheckParams(self, dim, keepdim, stdOut, meanOut);
	307	CHECK_RET(ret == ACLNN_SUCCESS, ret);
	308
	309	// dim为空指针
	310	auto dimArray = GetDimArray(self, dim, uniqueExecutor.get());
	311	CHECK_RET(dimArray != nullptr, ACLNN_ERR_INNER_NULLPTR);
	312
	313	// 空tensor在kernel中支持
	314	if (self->IsEmpty()) {
	315	// 空tensor填充NAN
	316	ret = DealEmpty(stdOut, meanOut, uniqueExecutor.get());
	317	CHECK_RET(ret == ACLNN_SUCCESS, ret);
	318	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
	319	uniqueExecutor.ReleaseTo(executor);
	320	return ret;
	321	}
	322
	323	// 固定写法，将输入self转换成连续的tensor
	324	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
	325	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
	326	auto selfReformat = l0op::ReFormat(selfContiguous, Format::FORMAT_ND);
	327	CHECK_RET(selfReformat != nullptr, ACLNN_ERR_INNER_NULLPTR);
	328
	329	if (IsRegBase()) {
	330	return aclnnStdMeanCorrectionImplUnify(selfReformat, dimArray, correction, keepdim, stdOut, meanOut,
	331	workspaceSize, uniqueExecutor, executor);
	332	}
	333
	334	// 调用Mean算子kernel
	335	auto meanOpOut = l0op::ReduceMean(selfContiguous, dimArray, keepdim, uniqueExecutor.get());
	336	CHECK_RET(meanOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
	337
	338	// shapeProd小于等于correction场景
	339	int64_t shapeProd = 1;
	340	shapeProd = CalcShapeProd(self, dimArray);
	341	if ((shapeProd == 1) && (shapeProd <= correction)) {
	342	ret = DealshapeProdNAN(meanOpOut, stdOut, meanOut, uniqueExecutor.get());
	343	CHECK_RET(ret == ACLNN_SUCCESS, ret);
	344	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
	345	uniqueExecutor.ReleaseTo(executor);
	346	return ret;
	347	}
	348	if ((correction > 1) && (shapeProd <= correction)) {
	349	ret = DealshapeProdINF(meanOpOut, stdOut, meanOut, uniqueExecutor.get());
	350	CHECK_RET(ret == ACLNN_SUCCESS, ret);
	351	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
	352	uniqueExecutor.ReleaseTo(executor);
	353	return ret;
	354	}
	355	// 固定写法，将计算结果拷贝到输出meanOut上，meanOut可能是非连续的tensor
	356	auto viewCopyMeanResult = l0op::ViewCopy(meanOpOut, meanOut, uniqueExecutor.get());
	357	CHECK_RET(viewCopyMeanResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
	358
	359	auto expandOpOut = GetExpandMean(self, meanOpOut, dimArray, keepdim, uniqueExecutor.get());
	360	CHECK_RET(expandOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
	361
	362	// 调用StdWithMean算子kernel
	363	auto stdWithMeanOpOut = l0op::ReduceStdWithMean(selfContiguous, expandOpOut, dimArray, correction, keepdim, invert,
	364	eps, uniqueExecutor.get());
	365	CHECK_RET(stdWithMeanOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
	366
	367	// 固定写法，将计算结果拷贝到输出stdOut上，stdOut可能是非连续的tensor
	368	auto viewCopyStdResult = l0op::ViewCopy(stdWithMeanOpOut, stdOut, uniqueExecutor.get());
	369	CHECK_RET(viewCopyStdResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
	370
	371	// 固定写法，获取计算过程中需要使用的workspace大小
	372	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
	373	uniqueExecutor.ReleaseTo(executor); // 需要把 uniqueExecutor持有executor转移给executor
	374	return ACLNN_SUCCESS;
	375	}
	376
	377	aclnnStatus aclnnStdMeanCorrection(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor,
	378	const aclrtStream stream)
	379	{
	380	L2_DFX_PHASE_2(aclnnStdMeanCorrection);
	381	// 固定写法，调用框架能力，完成计算
	382	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
	383	}
	384
	385	#ifdef __cplusplus
	386	}
	387	#endif

Rmath/reduce_std_with_mean/op_host/op_api/aclnn_std_mean_correction.h→math/reduce_std_with_mean/op_api/aclnn_std_mean_correction.h+1-1

	@@ -36,4 +36,4 @@ ACLNN_API aclnnStatus aclnnStdMeanCorrection(void* workspace, uint64_t workspace
36	}	36	}
37	#endif	37	#endif
38		38
39	#endif // OP_API_INC_STD_MEAN_CORRECTION_H_	39	#endif // OP_API_INC_STD_MEAN_CORRECTION_H_

Rmath/reduce_std_with_mean/op_host/op_api/reduce_std_with_mean.cpp→math/reduce_std_with_mean/op_api/reduce_std_with_mean.cpp+11-16

	@@ -23,34 +23,29 @@
23	#include "opdev/op_log.h"	23	#include "opdev/op_log.h"
24	#include "opdev/shape_utils.h"	24	#include "opdev/shape_utils.h"
25		25
26
27	using namespace op;	26	using namespace op;
28		27
29	namespace l0op {	28	namespace l0op {
30	OP_TYPE_REGISTER(ReduceStdWithMean);	29	OP_TYPE_REGISTER(ReduceStdWithMean);
31		30
32	const aclTensor* ReduceStdWithMean(	31	const aclTensor* ReduceStdWithMean(const aclTensor* self, const aclTensor* mean, const aclIntArray* dim,
33	const aclTensor* self, const aclTensor* mean, const aclIntArray* dim, int64_t correction, bool keepdim, bool invert,	32	int64_t correction, bool keepdim, bool invert, float eps, aclOpExecutor* executor)
34	float eps, aclOpExecutor* executor)
35	{	33	{
36	L0_DFX(ReduceStdWithMean, self, mean, dim, correction, keepdim, invert, eps);	34	L0_DFX(ReduceStdWithMean, self, mean, dim, correction, keepdim, invert, eps);
37	auto stdWithMeanOut =	35	auto stdWithMeanOut = executor->AllocTensor(self->GetDataType(), self->GetStorageFormat(),
38	executor->AllocTensor(self->GetDataType(), self->GetStorageFormat(), self->GetOriginalFormat());	36	self->GetOriginalFormat());
39	CHECK_RET(stdWithMeanOut != nullptr, nullptr);	37	CHECK_RET(stdWithMeanOut != nullptr, nullptr);
40	bool unbiased = true;	38	bool unbiased = true;
41	if (correction == 0) {	39	if (correction == 0) {
42	unbiased = false;	40	unbiased = false;
43	}	41	}
44	INFER_SHAPE(	42	INFER_SHAPE(ReduceStdWithMean, OP_INPUT(self, mean), OP_OUTPUT(stdWithMeanOut),
45	ReduceStdWithMean, OP_INPUT(self, mean), OP_OUTPUT(stdWithMeanOut),	43	OP_ATTR(dim, unbiased, keepdim, invert, eps, correction));
46	OP_ATTR(dim, unbiased, keepdim, invert, eps, correction));	44	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(ReduceStdWithMean, OP_INPUT(self, mean), OP_OUTPUT(stdWithMeanOut),
47	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(	45	OP_ATTR(dim, unbiased, keepdim, invert, eps, correction));
48	ReduceStdWithMean, OP_INPUT(self, mean), OP_OUTPUT(stdWithMeanOut),	46	OP_CHECK(ret == ACLNN_SUCCESS,
49	OP_ATTR(dim, unbiased, keepdim, invert, eps, correction));	47	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "ReduceStdWithMeanAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."),
50	OP_CHECK(	48	return nullptr);
51	ret == ACLNN_SUCCESS,
52	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "ReduceStdWithMeanAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."),
53	return nullptr);
54	return stdWithMeanOut;	49	return stdWithMeanOut;
55	}	50	}
56	} // namespace l0op	51	} // namespace l0op

Rmath/reduce_std_with_mean/op_host/op_api/reduce_std_with_mean.h→math/reduce_std_with_mean/op_api/reduce_std_with_mean.h+3-4

	@@ -18,9 +18,8 @@
18	#include "opdev/op_executor.h"	18	#include "opdev/op_executor.h"
19		19
20	namespace l0op {	20	namespace l0op {
21	const aclTensor* ReduceStdWithMean(	21	const aclTensor* ReduceStdWithMean(const aclTensor* self, const aclTensor* mean, const aclIntArray* dim,
22	const aclTensor* self, const aclTensor* mean, const aclIntArray* dim, int64_t correction, bool keepdim, bool invert,	22	int64_t correction, bool keepdim, bool invert, float eps, aclOpExecutor* executor);
23	float eps, aclOpExecutor* executor);
24	}	23	}
25		24
26	#endif	25	#endif

Dmath/reduce_std_with_mean/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources(OPTYPE reduce_std_with_mean ACLNNTYPE aclnn_exclude)

Dmath/reduce_std_with_mean/op_host/op_api/aclnn_std_mean_correction.cpp+0-372

	@@ -1,372 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10	#include "aclnn_std_mean_correction.h"
11	#include <bitset>
12	#include "reduce_std_with_mean.h"
13	#include "math/reduce_mean/op_api/reduce_mean.h"
14	#include "math/reduce_std_v2/op_api/reduce_std_v2.h"
15	#include "aclnn_kernels/cast.h"
16	#include "aclnn_kernels/contiguous.h"
17	#include "aclnn_kernels/transdata.h"
18	#include "conversion/unsqueeze/op_host/op_api/unsqueeze.h"
19	#include "math/expand/op_api/expand.h"
20	#include "opdev/common_types.h"
21	#include "opdev/data_type_utils.h"
22	#include "opdev/format_utils.h"
23	#include "opdev/op_dfx.h"
24	#include "opdev/op_executor.h"
25	#include "opdev/shape_utils.h"
26	#include "opdev/tensor_view_utils.h"
27	#include "aclnn_kernels/common/op_error_check.h"
28	#include "op_api/op_api_def.h"
29	#include "opdev/platform.h"
30	#include "opdev/op_log.h"
31	#include "op_api/level2_base_caculation.h"
32	#include "op_api/aclnn_check.h"
33
34	using namespace op;
35	using std::bitset;
36
37	#ifdef __cplusplus
38	extern "C" {
39	#endif
40
41	constexpr size_t MAX_MASK_NUM = 64;
42	static const bool invert = false;
43	static const float eps = 0.001f;
44	// 根据API定义，需要列出所能支持的所有dtype
45	static const std::initializer_list<op::DataType> ASCEND910_DTYPE_DTYPE_SUPPORT_LIST = {
46	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16};
47
48	static const std::initializer_list<op::DataType> ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST = {
49	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};
50
51	static bool CheckDtypeValid(const aclTensor self, const aclTensor stdOut, const aclTensor *meanOut) {
52	// 检查self的数据类型是否在算子的支持列表内
53	auto supportList = GetDtypeSupportListV2(ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST, ASCEND910_DTYPE_DTYPE_SUPPORT_LIST);
54	OP_CHECK_DTYPE_NOT_SUPPORT(self, supportList, return false);
55
56	// 检查stdOut、meanOut的数据类型是否在算子的支持列表内
57	OP_CHECK_DTYPE_NOT_SUPPORT(stdOut, supportList, return false);
58	OP_CHECK_DTYPE_NOT_SUPPORT(meanOut, supportList, return false);
59
60	// Ascend950支持输入、输出数据类型不一致
61	if (IsRegBase()) {
62	return true;
63	}
64
65	// 检查self的数据类型是否输出的数据类型一致
66	OP_CHECK_DTYPE_NOT_MATCH(self, stdOut->GetDataType(), return false);
67	OP_CHECK_DTYPE_NOT_MATCH(self, meanOut->GetDataType(), return false);
68	return true;
69	}
70
71	static bool CheckDimValid(const aclTensor self, const aclIntArray dim) {
72	auto selfViewShape = self->GetViewShape();
73	auto selfDimNum = static_cast<int64_t>(selfViewShape.GetDimNum());
74	int64_t dimMin = std::min(-1 * selfDimNum, selfDimNum - 1);
75	int64_t dimMax = std::max(-1 * selfDimNum, selfDimNum - 1);
76	// 0维tensor
77	if (selfDimNum == 0) {
78	selfDimNum = 1;
79	}
80	bool dimMask[64] = {false};
81	// dim可以为空指针
82	if (dim == nullptr) {
83	return true;
84	}
85	// 获取dim元素
86	for (size_t i = 0; i < dim->Size(); i++) {
87	// dim值不能超出范围
88	auto currentDim = dim->operator[](i);
89	if (currentDim > dimMax \|\| currentDim < dimMin) {
90	OP_LOGE(ACLNN_ERR_PARAM_INVALID,
91	"Dimension out of range (expected to be in range of [%ld, %ld], but got %ld)",
92	dimMin, dimMax, selfDimNum);
93	return false;
94	}
95	// dim值可以为负
96	if (currentDim < 0) {
97	currentDim = currentDim + selfDimNum;
98	}
99	// dim值不能重复
100	if (dimMask[currentDim]) {
101	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dim %ld appears multiple times in the list of dims.", currentDim);
102	return false;
103	}
104	dimMask[currentDim] = true;
105	}
106	return true;
107	}
108
109	static void OutInferShape(const op::Shape& selfShape, const aclIntArray* dim, bool keepDim, op::Shape& reduceShape) {
110	bitset<MAX_MASK_NUM> dimTmp = bitset<MAX_MASK_NUM>();
111	for (size_t i = 0; i < dim->Size(); i++) {
112	int64_t index = GetPosDimWithStd(dim->operator[](i), selfShape.GetDimNum());
113	// 前序已检查，此处如果dim不会重复
114	dimTmp.set(index);
115	}
116
117	for (size_t i = 0; i < selfShape.GetDimNum(); i++) {
118	if (!dimTmp[i]) {
119	reduceShape.AppendDim(selfShape.GetDim(i));
120	} else if (keepDim) {
121	reduceShape.AppendDim(1);
122	}
123	}
124	}
125
126	static bool CheckShape(const aclTensor self, const aclIntArray dim, const bool keepDim, const aclTensor stdOut, const aclTensor meanOut) {
127	OP_CHECK_MAX_DIM(self, MAX_SUPPORT_DIMS_NUMS, return false);
128	OP_CHECK_MAX_DIM(stdOut, MAX_SUPPORT_DIMS_NUMS, return false);
129	OP_CHECK_MAX_DIM(meanOut, MAX_SUPPORT_DIMS_NUMS, return false);
130	// dim可以为空指针
131	if (dim == nullptr \|\| dim->Size() == 0) {
132	return true;
133	}
134	op::Shape reduceShape;
135	OutInferShape(self->GetViewShape(), dim, keepDim, reduceShape);
136	// stdOut的shape必须满足Infer shape
137	OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(stdOut, reduceShape, return false);
138	// meanOut的shape必须满足Infer shape
139	OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(meanOut, reduceShape, return false);
140	return true;
141	}
142
143	static aclnnStatus CheckParams(const aclTensor self, const aclIntArray dim, const bool keepdim,
144	const aclTensor stdOut, const aclTensor meanOut) {
145	// 1. 检查参数是否为空指针
146	CHECK_RET(CheckNotNull3Tensor(self, stdOut, meanOut), ACLNN_ERR_PARAM_NULLPTR);
147
148	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验
149	CHECK_RET(CheckDtypeValid(self, stdOut, meanOut), ACLNN_ERR_PARAM_INVALID);
150
151	// 3. 检查reduce的轴是否合理
152	CHECK_RET(CheckDimValid(self, dim), ACLNN_ERR_PARAM_INVALID);
153
154	// 4. 检查shape是否满足推导
155	CHECK_RET(CheckShape(self, dim, keepdim, stdOut, meanOut), ACLNN_ERR_PARAM_INVALID);
156
157	return ACLNN_SUCCESS;
158	}
159
160	static aclIntArray* CalcDim(const aclTensor self, aclOpExecutor executor) {
161	FVector<int64_t> dimVector;
162	auto selfViewShape = self->GetViewShape();
163	size_t selfDimNum = selfViewShape.GetDimNum();
164	for (size_t i = 0; i < selfDimNum; i++) {
165	dimVector.push_back(static_cast<int64_t>(i));
166	}
167	return executor->AllocIntArray(dimVector.data(), dimVector.size());
168	}
169
170	static const aclIntArray* GetDimArray(const aclTensor self, const aclIntArray dim, aclOpExecutor *executor) {
171	const aclIntArray* dimArray = dim;
172	if (dim == nullptr \|\| dim->Size() == 0) {
173	dimArray = CalcDim(self, executor);
174	}
175	CHECK_RET(dimArray != nullptr, nullptr);
176	return dimArray;
177	}
178
179	static int64_t CalcShapeProd(const aclTensor self, const aclIntArray dim) {
180	auto selfViewShape = self->GetViewShape();
181	int64_t shapeProd = 1;
182	size_t selfDimNum = selfViewShape.GetDimNum();
183	if (selfDimNum != 0) {
184	// dim为all reduce
185	if (dim->Size() == 0) {
186	for (size_t i = 0; i < selfDimNum; i++) {
187	shapeProd *= selfViewShape.GetDim(i);
188	}
189	} else {
190	for (size_t i = 0; i < dim->Size(); i++) {
191	auto oriDim = dim->operator[](i);
192	auto realDim = oriDim < 0 ? oriDim + selfDimNum : oriDim;
193	shapeProd *= selfViewShape.GetDim(realDim);
194	}
195	}
196	}
197	return shapeProd;
198	}
199
200	static const aclTensor* GetExpandMean(const aclTensor self, const aclTensor meanOpOut, const aclIntArray* dimArray,
201	bool keepdim, aclOpExecutor *executor) {
202	auto meanOpOutTmp = keepdim ? meanOpOut : l0op::UnsqueezeNd(meanOpOut, dimArray, executor);
203	CHECK_RET(meanOpOutTmp != nullptr, nullptr);
204	// 调用Expand算子kernel
205	FVector<int64_t> shapeVector;
206	auto selfShape = self->GetViewShape();
207	size_t selfDimNum = selfShape.GetDimNum();
208	if(!selfDimNum){
209	return meanOpOutTmp;
210	}
211	for (size_t i = 0; i < selfDimNum; i++) {
212	shapeVector.emplace_back(selfShape[i]);
213	}
214	auto shapeArray = executor->AllocIntArray(shapeVector.data(), selfDimNum);
215	CHECK_RET(shapeArray != nullptr, nullptr);
216	auto expandOpOut = l0op::Expand(meanOpOutTmp, shapeArray, executor);
217	CHECK_RET(expandOpOut != nullptr, nullptr);
218	return expandOpOut;
219	}
220
221	static aclnnStatus DealEmpty(aclTensor stdOut, aclTensor meanOut, aclOpExecutor *executor) {
222	auto ret = CheckFillScalarShapeStdAndVar(stdOut, NAN, executor);
223	CHECK_RET(ret == ACLNN_SUCCESS, ret);
224	ret = CheckFillScalarShapeStdAndVar(meanOut, NAN, executor);
225	CHECK_RET(ret == ACLNN_SUCCESS, ret);
226	return ACLNN_SUCCESS;
227	}
228
229	static aclnnStatus DealshapeProdNAN(const aclTensor meanOpOut, aclTensor stdOut, aclTensor *meanOut,
230	aclOpExecutor *executor) {
231	// stdOut返回NAN
232	auto ret = CheckFillScalarShapeStdAndVar(stdOut, NAN, executor);
233	CHECK_RET(ret == ACLNN_SUCCESS, ret);
234	// 固定写法，将计算结果拷贝到输出meanOut上，meanOut可能是非连续的tensor
235	auto viewCopyMeanResult = l0op::ViewCopy(meanOpOut, meanOut, executor);
236	CHECK_RET(viewCopyMeanResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
237	return ACLNN_SUCCESS;
238	}
239
240	static aclnnStatus DealshapeProdINF(const aclTensor meanOpOut, aclTensor stdOut, aclTensor *meanOut,
241	aclOpExecutor *executor) {
242	// stdOut返回INF
243	auto ret = CheckFillScalarShapeStdAndVar(stdOut, INFINITY, executor);
244	CHECK_RET(ret == ACLNN_SUCCESS, ret);
245	// 固定写法，将计算结果拷贝到输出meanOut上，meanOut可能是非连续的tensor
246	auto viewCopyMeanResult = l0op::ViewCopy(meanOpOut, meanOut, executor);
247	CHECK_RET(viewCopyMeanResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
248	return ACLNN_SUCCESS;
249	}
250
251	static aclnnStatus aclnnStdMeanCorrectionImplUnify(const aclTensor self, const aclIntArray dim, int64_t correction,
252	bool keepdim, aclTensor stdOut, aclTensor meanOut, uint64_t* workspaceSize,
253	UniqueExecutor &uniqueExecutor, aclOpExecutor **executor)
254	{
255	bool isMeanOut = true;
256	auto reduceStdOut = l0op::ReduceStdV2(self, dim, correction, keepdim, isMeanOut, uniqueExecutor.get());
257
258	auto stdOpOut = std::get<0>(reduceStdOut);
259	CHECK_RET(stdOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
260	auto castOut = l0op::Cast(stdOpOut, stdOut->GetDataType(), uniqueExecutor.get());
261	CHECK_RET(castOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
262	auto viewCopyResult = l0op::ViewCopy(castOut, stdOut, uniqueExecutor.get());
263	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
264
265	auto meanOpOut = std::get<1>(reduceStdOut);
266	CHECK_RET(meanOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
267	auto castOut1 = l0op::Cast(meanOpOut, meanOut->GetDataType(), uniqueExecutor.get());
268	CHECK_RET(castOut1 != nullptr, ACLNN_ERR_INNER_NULLPTR);
269	auto viewCopyResult1 = l0op::ViewCopy(castOut1, meanOut, uniqueExecutor.get());
270	CHECK_RET(viewCopyResult1 != nullptr, ACLNN_ERR_INNER_NULLPTR);
271
272	// 获取计算过程中需要使用的workspace大小
273	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
274	uniqueExecutor.ReleaseTo(executor);
275
276	return ACLNN_SUCCESS;
277	}
278
279	aclnnStatus aclnnStdMeanCorrectionGetWorkspaceSize(const aclTensor self, const aclIntArray dim, int64_t correction,
280	bool keepdim, aclTensor stdOut, aclTensor meanOut,
281	uint64_t workspaceSize, aclOpExecutor *executor) {
282	OP_CHECK_COMM_INPUT(workspaceSize, executor);
283
284	L2_DFX_PHASE_1(aclnnStdMeanCorrection, DFX_IN(self, dim, correction, keepdim), DFX_OUT(stdOut, meanOut));
285
286	// 固定写法，创建OpExecutor
287	auto uniqueExecutor = CREATE_EXECUTOR();
288	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
289
290	// 固定写法，参数检查
291	auto ret = CheckParams(self, dim, keepdim, stdOut, meanOut);
292	CHECK_RET(ret == ACLNN_SUCCESS, ret);
293
294	// dim为空指针
295	auto dimArray = GetDimArray(self, dim, uniqueExecutor.get());
296	CHECK_RET(dimArray != nullptr, ACLNN_ERR_INNER_NULLPTR);
297
298	// 空tensor在kernel中支持
299	if (self->IsEmpty()) {
300	// 空tensor填充NAN
301	ret = DealEmpty(stdOut, meanOut, uniqueExecutor.get());
302	CHECK_RET(ret == ACLNN_SUCCESS, ret);
303	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
304	uniqueExecutor.ReleaseTo(executor);
305	return ret;
306	}
307
308	// 固定写法，将输入self转换成连续的tensor
309	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
310	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
311	auto selfReformat = l0op::ReFormat(selfContiguous, Format::FORMAT_ND);
312	CHECK_RET(selfReformat != nullptr, ACLNN_ERR_INNER_NULLPTR);
313
314	if (IsRegBase()) {
315	return aclnnStdMeanCorrectionImplUnify(selfReformat, dimArray, correction, keepdim, stdOut, meanOut,
316	workspaceSize, uniqueExecutor, executor);
317	}
318
319	// 调用Mean算子kernel
320	auto meanOpOut = l0op::ReduceMean(selfContiguous, dimArray, keepdim, uniqueExecutor.get());
321	CHECK_RET(meanOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
322
323	// shapeProd小于等于correction场景
324	int64_t shapeProd = 1;
325	shapeProd = CalcShapeProd(self, dimArray);
326	if ((shapeProd == 1) && (shapeProd <= correction)) {
327	ret = DealshapeProdNAN(meanOpOut, stdOut, meanOut, uniqueExecutor.get());
328	CHECK_RET(ret == ACLNN_SUCCESS, ret);
329	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
330	uniqueExecutor.ReleaseTo(executor);
331	return ret;
332	}
333	if ((correction > 1) && (shapeProd <= correction)) {
334	ret = DealshapeProdINF(meanOpOut, stdOut, meanOut, uniqueExecutor.get());
335	CHECK_RET(ret == ACLNN_SUCCESS, ret);
336	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
337	uniqueExecutor.ReleaseTo(executor);
338	return ret;
339	}
340	// 固定写法，将计算结果拷贝到输出meanOut上，meanOut可能是非连续的tensor
341	auto viewCopyMeanResult = l0op::ViewCopy(meanOpOut, meanOut, uniqueExecutor.get());
342	CHECK_RET(viewCopyMeanResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
343
344	auto expandOpOut = GetExpandMean(self, meanOpOut, dimArray, keepdim, uniqueExecutor.get());
345	CHECK_RET(expandOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
346
347	// 调用StdWithMean算子kernel
348	auto stdWithMeanOpOut = l0op::ReduceStdWithMean(selfContiguous, expandOpOut, dimArray, correction,
349	keepdim, invert, eps, uniqueExecutor.get());
350	CHECK_RET(stdWithMeanOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
351
352	// 固定写法，将计算结果拷贝到输出stdOut上，stdOut可能是非连续的tensor
353	auto viewCopyStdResult = l0op::ViewCopy(stdWithMeanOpOut, stdOut, uniqueExecutor.get());
354	CHECK_RET(viewCopyStdResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
355
356	// 固定写法，获取计算过程中需要使用的workspace大小
357	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
358	uniqueExecutor.ReleaseTo(executor); // 需要把 uniqueExecutor持有executor转移给executor
359	return ACLNN_SUCCESS;
360	}
361
362	aclnnStatus aclnnStdMeanCorrection(void *workspace, uint64_t workspaceSize,
363	aclOpExecutor *executor, const aclrtStream stream) {
364	L2_DFX_PHASE_2(aclnnStdMeanCorrection);
365	// 固定写法，调用框架能力，完成计算
366	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
367	}
368
369	#ifdef __cplusplus
370	}
371	#endif
372

Dmath/reduce_std_with_mean/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/reduce_std_with_mean/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Mmath/reduce_std_with_mean/tests/ut/op_api/test_aclnn_std_mean_correction.cpp+86-93

Mmath/reduce_std_with_mean/tests/ut/op_api/test_batch_norm_stats.cpp+151-144

	@@ -11,9 +11,8 @@
11	#include <vector>	11	#include <vector>
12	#include "gtest/gtest.h"	12	#include "gtest/gtest.h"
13		13
14	#include "reduce_std_with_mean/op_host/op_api/aclnn_batch_norm_stats.h"	14	#include "../../../op_api/aclnn_batch_norm_stats.h"
15		15
16	#include "op_api_ut_common/inner/types.h"
17	#include "op_api_ut_common/op_api_ut.h"	16	#include "op_api_ut_common/op_api_ut.h"
18	#include "op_api_ut_common/scalar_desc.h"	17	#include "op_api_ut_common/scalar_desc.h"
19	#include "op_api_ut_common/tensor_desc.h"	18	#include "op_api_ut_common/tensor_desc.h"
	@@ -21,179 +20,187 @@
21	using namespace std;	20	using namespace std;
22		21
23	class l2_batch_norm_stats_test : public testing::Test {	22	class l2_batch_norm_stats_test : public testing::Test {
24	protected:	23	protected:
25	static void SetUpTestCase() {	24	static void SetUpTestCase() { cout << "l2_batch_norm_stats_test SetUp" << endl; }
26	cout << "l2_batch_norm_stats_test SetUp" << endl;
27	}
28		25
29	static void TearDownTestCase() {	26	static void TearDownTestCase() { cout << "l2_batch_norm_stats_test TearDown" << endl; }
30	cout << "l2_batch_norm_stats_test TearDown" << endl;
31	}
32	};	27	};
33		28
34	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_dtype_float) {	29	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_dtype_float)
35	auto tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});	30	{
36	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	31	auto tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});
37	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	32	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
38	double eps = 1e-5;	33	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
		34	double eps = 1e-5;
39		35
40	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));	36	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
41	ut.TestPrecision();	37	ut.TestPrecision();
42	}	38	}
43		39
44	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_dtype_float16) {	40	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_dtype_float16)
45	auto tensor_desc = TensorDesc({2, 3}, ACL_FLOAT16, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});	41	{
46	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	42	auto tensor_desc = TensorDesc({2, 3}, ACL_FLOAT16, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});
47	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	43	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
48	double eps = 1e-5;	44	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
		45	double eps = 1e-5;
49		46
50	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));	47	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
51	ut.TestPrecision();	48	ut.TestPrecision();
52	}	49	}
53		50
54	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_dtype_int8) {	51	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_dtype_int8)
55	auto tensor_desc = TensorDesc({2, 3}, ACL_INT8, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});	52	{
56	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	53	auto tensor_desc = TensorDesc({2, 3}, ACL_INT8, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});
57	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	54	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
58	double eps = 1e-5;	55	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
		56	double eps = 1e-5;
59		57
60	uint64_t workspace_size = 0;	58	uint64_t workspace_size = 0;
61	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));	59	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
62	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	60	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
63	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);	61	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
64	}	62	}
65		63
66	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_dtype_int32) {	64	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_dtype_int32)
67	auto tensor_desc = TensorDesc({2, 3}, ACL_INT32, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});	65	{
68	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	66	auto tensor_desc = TensorDesc({2, 3}, ACL_INT32, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});
69	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	67	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
70	double eps = 1e-5;	68	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
		69	double eps = 1e-5;
71		70
72	uint64_t workspace_size = 0;	71	uint64_t workspace_size = 0;
73	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));	72	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
74	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	73	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
75	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);	74	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
76	}	75	}
77		76
78	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_dtype_uint8) {	77	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_dtype_uint8)
79	auto tensor_desc = TensorDesc({2, 3}, ACL_UINT8, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});	78	{
80	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	79	auto tensor_desc = TensorDesc({2, 3}, ACL_UINT8, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});
81	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	80	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
82	double eps = 1e-5;	81	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
		82	double eps = 1e-5;
83		83
84	uint64_t workspace_size = 0;	84	uint64_t workspace_size = 0;
85	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));	85	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
86	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	86	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
87	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);	87	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
88	}	88	}
89		89
90	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_dtype_int16) {	90	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_dtype_int16)
91	auto tensor_desc = TensorDesc({2, 3}, ACL_INT16, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});	91	{
92	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	92	auto tensor_desc = TensorDesc({2, 3}, ACL_INT16, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});
93	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	93	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
94	double eps = 1e-5;	94	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
		95	double eps = 1e-5;
95		96
96	uint64_t workspace_size = 0;	97	uint64_t workspace_size = 0;
97	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));	98	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
98	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	99	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
99	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);	100	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
100	}	101	}
101		102
102	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_all_format) {	103	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_all_format)
103	vector<aclFormat> format_list{ACL_FORMAT_NC1HWC0, ACL_FORMAT_NCHW, ACL_FORMAT_NHWC, ACL_FORMAT_ND,	104	{
104	ACL_FORMAT_HWCN, ACL_FORMAT_NDHWC, ACL_FORMAT_NCDHW};	105	vector<aclFormat> format_list{ACL_FORMAT_NC1HWC0, ACL_FORMAT_NCHW, ACL_FORMAT_NHWC, ACL_FORMAT_ND,
105	for (auto format : format_list) {	106	ACL_FORMAT_HWCN, ACL_FORMAT_NDHWC, ACL_FORMAT_NCDHW};
106	cout << "+++++++++++++++++++++++ start to test format " << format << endl;	107	for (auto format : format_list) {
107	auto tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, format).Value(vector<float>{1, 2, 3, 4, 5, 6});	108	cout << "+++++++++++++++++++++++ start to test format " << format << endl;
108	auto mean = TensorDesc({3}, ACL_FLOAT, format);	109	auto tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, format).Value(vector<float>{1, 2, 3, 4, 5, 6});
109	auto invstd = TensorDesc({3}, ACL_FLOAT, format);	110	auto mean = TensorDesc({3}, ACL_FLOAT, format);
		111	auto invstd = TensorDesc({3}, ACL_FLOAT, format);
		112	double eps = 1e-5;
		113
		114	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
		115	uint64_t workspace_size = 0;
		116	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
		117	if (format == ACL_FORMAT_NC1HWC0) {
		118	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
		119	} else {
		120	EXPECT_EQ(aclRet, ACL_SUCCESS);
		121	ut.TestPrecision();
		122	}
		123	}
		124	}
		125
		126	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_nullptr)
		127	{
		128	auto tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});
		129	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
		130	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
		131	double eps = 1e-5;
		132
		133	auto ut_1 = OP_API_UT(aclnnBatchNormStats, INPUT(nullptr, eps), OUTPUT(mean, invstd));
		134	uint64_t workspace_size = 0;
		135	aclnnStatus aclRet = ut_1.TestGetWorkspaceSize(&workspace_size);
		136	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
		137
		138	auto ut_2 = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(nullptr, invstd));
		139	aclRet = ut_2.TestGetWorkspaceSize(&workspace_size);
		140	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
		141
		142	auto ut_3 = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, nullptr));
		143	aclRet = ut_3.TestGetWorkspaceSize(&workspace_size);
		144	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
		145	}
		146
		147	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_empty_tensor)
		148	{
		149	auto tensor_desc = TensorDesc({0, 3}, ACL_FLOAT, ACL_FORMAT_ND);
		150	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
		151	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
		152	double eps = 1e-5;
		153
		154	auto ut_1 = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
		155	uint64_t workspace_size = 0;
		156	aclnnStatus aclRet = ut_1.TestGetWorkspaceSize(&workspace_size);
		157	EXPECT_EQ(aclRet, ACL_SUCCESS);
		158
		159	tensor_desc = TensorDesc({3, 0}, ACL_FLOAT, ACL_FORMAT_ND);
		160	auto ut_2 = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
		161	aclRet = ut_2.TestGetWorkspaceSize(&workspace_size);
		162	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
		163	}
		164
		165	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_non_contiguous)
		166	{
		167	auto tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND, {1, 2}, 0, {3, 2}).ValueRange(-1, 1);
		168	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
		169	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
110	double eps = 1e-5;	170	double eps = 1e-5;
111		171
112	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));	172	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
113	uint64_t workspace_size = 0;	173	uint64_t workspace_size = 0;
114	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);	174	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
115	if (format == ACL_FORMAT_NC1HWC0) {	175	EXPECT_EQ(aclRet, ACL_SUCCESS);
116	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
117	} else {
118	EXPECT_EQ(aclRet, ACL_SUCCESS);
119	ut.TestPrecision();
120	}
121	}
122	}	176	}
123		177
124	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_nullptr) {	178	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_invalid_dim)
125	auto tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});	179	{
126	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	180	auto tensor_desc = TensorDesc({2, 3, 3, 2, 2, 3, 2, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND);
127	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	181	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
128	double eps = 1e-5;	182	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
		183	double eps = 1e-5;
129		184
130	auto ut_1 = OP_API_UT(aclnnBatchNormStats, INPUT(nullptr, eps), OUTPUT(mean, invstd));	185	auto ut_1 = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
131	uint64_t workspace_size = 0;	186	uint64_t workspace_size = 0;
132	aclnnStatus aclRet = ut_1.TestGetWorkspaceSize(&workspace_size);	187	aclnnStatus aclRet = ut_1.TestGetWorkspaceSize(&workspace_size);
133	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);	188	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
134		189
135	auto ut_2 = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(nullptr, invstd));	190	tensor_desc = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
136	aclRet = ut_2.TestGetWorkspaceSize(&workspace_size);	191	auto ut_2 = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
137	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);	192	aclRet = ut_2.TestGetWorkspaceSize(&workspace_size);
138		193	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
139	auto ut_3 = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, nullptr));
140	aclRet = ut_3.TestGetWorkspaceSize(&workspace_size);
141	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
142	}	194	}
143		195
144	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_empty_tensor) {	196	TEST_F(l2_batch_norm_stats_test, ascend950_batch_norm_stats_dtype_float16)
145	auto tensor_desc = TensorDesc({0, 3}, ACL_FLOAT, ACL_FORMAT_ND);	197	{
146	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	198	auto tensor_desc = TensorDesc({2, 3}, ACL_FLOAT16, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});
147	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);	199	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
148	double eps = 1e-5;	200	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
		201	double eps = 1e-5;
149		202
150	auto ut_1 = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));	203	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
151	uint64_t workspace_size = 0;	204	uint64_t workspace_size = 0;
152	aclnnStatus aclRet = ut_1.TestGetWorkspaceSize(&workspace_size);	205	ut.TestGetWorkspaceSize(&workspace_size);
153	EXPECT_EQ(aclRet, ACL_SUCCESS);
154
155	tensor_desc = TensorDesc({3, 0}, ACL_FLOAT, ACL_FORMAT_ND);
156	auto ut_2 = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
157	aclRet = ut_2.TestGetWorkspaceSize(&workspace_size);
158	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
159	}
160
161	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_non_contiguous) {
162	auto tensor_desc = TensorDesc({2, 3}, ACL_FLOAT, ACL_FORMAT_ND, {1, 2}, 0, {3, 2}).ValueRange(-1, 1);
163	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
164	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
165	double eps = 1e-5;
166
167	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
168	uint64_t workspace_size = 0;
169	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
170	EXPECT_EQ(aclRet, ACL_SUCCESS);
171	}
172
173	TEST_F(l2_batch_norm_stats_test, batch_norm_stats_invalid_dim) {
174	auto tensor_desc = TensorDesc({2, 3, 3, 2, 2, 3, 2, 2, 3}, ACL_FLOAT, ACL_FORMAT_ND);
175	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
176	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
177	double eps = 1e-5;
178
179	auto ut_1 = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
180	uint64_t workspace_size = 0;
181	aclnnStatus aclRet = ut_1.TestGetWorkspaceSize(&workspace_size);
182	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
183
184	tensor_desc = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
185	auto ut_2 = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
186	aclRet = ut_2.TestGetWorkspaceSize(&workspace_size);
187	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
188	}
189
190	TEST_F(l2_batch_norm_stats_test, ascend950_batch_norm_stats_dtype_float16) {
191	auto tensor_desc = TensorDesc({2, 3}, ACL_FLOAT16, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});
192	auto mean = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
193	auto invstd = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND);
194	double eps = 1e-5;
195
196	auto ut = OP_API_UT(aclnnBatchNormStats, INPUT(tensor_desc, eps), OUTPUT(mean, invstd));
197	uint64_t workspace_size = 0;
198	ut.TestGetWorkspaceSize(&workspace_size);
199	}	206	}

Dmath/reduce_std_with_mean/tests/ut/op_host/CMakeLists.txt+0-20

	@@ -1,20 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()
18
19	if(OP_API_UT OR (UT_TEST_ALL AND NOT AICPU_ONLY))
20	endif()

Mmath/reduce_var/op_api/aclnn_var.cpp+38-29

	@@ -9,7 +9,7 @@
9	*/	9	*/
10		10
11	#include "aclnn_var.h"	11	#include "aclnn_var.h"
12	#include "math/reduce_std_v2_update/op_host/op_api/reduce_std_v2_update.h"	12	#include "math/reduce_std_v2_update/op_api/reduce_std_v2_update.h"
13	#include "math/reduce_mean/op_api/reduce_mean.h"	13	#include "math/reduce_mean/op_api/reduce_mean.h"
14	#include "reduce_var.h"	14	#include "reduce_var.h"
15	#include "aclnn_kernels/cast.h"	15	#include "aclnn_kernels/cast.h"
	@@ -33,7 +33,6 @@
33		33
34	using namespace op;	34	using namespace op;
35		35
36
37	#ifdef __cplusplus	36	#ifdef __cplusplus
38	extern "C" {	37	extern "C" {
39	#endif	38	#endif
	@@ -41,13 +40,14 @@ extern "C" {
41	constexpr size_t MAX_DIM_LEN = 8;	40	constexpr size_t MAX_DIM_LEN = 8;
42		41
43	// 算子支持的所有dtype	42	// 算子支持的所有dtype
44	static const std::initializer_list<op::DataType> ASCEND910_DTYPE_SUPPORT_LIST = {	43	static const std::initializer_list<op::DataType> ASCEND910_DTYPE_SUPPORT_LIST = {op::DataType::DT_FLOAT,
45	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16};	44	op::DataType::DT_FLOAT16};
46		45
47	static const std::initializer_list<op::DataType> ASCEND910B_DTYPE_SUPPORT_LIST = {	46	static const std::initializer_list<op::DataType> ASCEND910B_DTYPE_SUPPORT_LIST = {
48	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};	47	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};
49		48
50	static bool CheckDtypeValid(const aclTensor* self, aclTensor* out) {	49	static bool CheckDtypeValid(const aclTensor* self, aclTensor* out)
		50	{
51	auto DTYPE_SUPPORT_LIST = GetDtypeSupportListV2(ASCEND910B_DTYPE_SUPPORT_LIST, ASCEND910_DTYPE_SUPPORT_LIST);	51	auto DTYPE_SUPPORT_LIST = GetDtypeSupportListV2(ASCEND910B_DTYPE_SUPPORT_LIST, ASCEND910_DTYPE_SUPPORT_LIST);
52		52
53	OP_CHECK_DTYPE_NOT_SUPPORT(self, DTYPE_SUPPORT_LIST, return false);	53	OP_CHECK_DTYPE_NOT_SUPPORT(self, DTYPE_SUPPORT_LIST, return false);
	@@ -55,7 +55,8 @@ static bool CheckDtypeValid(const aclTensor* self, aclTensor* out) {
55	return true;	55	return true;
56	}	56	}
57		57
58	static bool CheckDimValid(const aclTensor* self, const aclIntArray* dim) {	58	static bool CheckDimValid(const aclTensor* self, const aclIntArray* dim)
		59	{
59	auto selfViewShape = self->GetViewShape();	60	auto selfViewShape = self->GetViewShape();
60	auto selfDimNum = static_cast<int64_t>(selfViewShape.GetDimNum());	61	auto selfDimNum = static_cast<int64_t>(selfViewShape.GetDimNum());
61	// self为标量时，dim range [-1, 0]	62	// self为标量时，dim range [-1, 0]
	@@ -66,8 +67,8 @@ static bool CheckDimValid(const aclTensor* self, const aclIntArray* dim) {
66	// 获取dim元素	67	// 获取dim元素
67	for (size_t i = 0; i < dim->Size(); i++) {	68	for (size_t i = 0; i < dim->Size(); i++) {
68	if (dim->operator[](i) >= selfDimNum \|\| dim->operator[](i) < (-selfDimNum)) {	69	if (dim->operator[](i) >= selfDimNum \|\| dim->operator[](i) < (-selfDimNum)) {
69	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Provided dim %ld must be in the range of [%ld, %ld].",	70	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Provided dim %ld must be in the range of [%ld, %ld].", dim->operator[](i),
70	dim->operator[](i), -selfDimNum, selfDimNum - 1);	71	-selfDimNum, selfDimNum - 1);
71	return false;	72	return false;
72	}	73	}
73	}	74	}
	@@ -77,7 +78,7 @@ static bool CheckDimValid(const aclTensor* self, const aclIntArray* dim) {
77	if (dim->operator[](i) < 0) {	78	if (dim->operator[](i) < 0) {
78	if (dimMask[selfDimNum + dim->operator[](i)] == 1) {	79	if (dimMask[selfDimNum + dim->operator[](i)] == 1) {
79	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dim %ld appears multiple times in the list of dims.",	80	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dim %ld appears multiple times in the list of dims.",
80	selfDimNum + dim->operator[](i));	81	selfDimNum + dim->operator[](i));
81	return false;	82	return false;
82	} else {	83	} else {
83	dimMask[selfDimNum + dim->operator[](i)] = 1;	84	dimMask[selfDimNum + dim->operator[](i)] = 1;
	@@ -94,8 +95,8 @@ static bool CheckDimValid(const aclTensor* self, const aclIntArray* dim) {
94	return true;	95	return true;
95	}	96	}
96		97
97	static bool CheckShape(const aclTensor* self, const aclIntArray* dim,	98	static bool CheckShape(const aclTensor* self, const aclIntArray* dim, bool keepdim, aclTensor* out)
98	bool keepdim, aclTensor* out) {	99	{
99	OP_CHECK_MAX_DIM(self, MAX_SUPPORT_DIMS_NUMS, return false);	100	OP_CHECK_MAX_DIM(self, MAX_SUPPORT_DIMS_NUMS, return false);
100		101
101	op::Shape reduceShape = ReduceShapeGetWithVar(self, dim, keepdim);	102	op::Shape reduceShape = ReduceShapeGetWithVar(self, dim, keepdim);
	@@ -105,8 +106,8 @@ static bool CheckShape(const aclTensor* self, const aclIntArray* dim,
105	return true;	106	return true;
106	}	107	}
107		108
108	static aclnnStatus CheckParams(const aclTensor* self, const aclIntArray* dim,	109	static aclnnStatus CheckParams(const aclTensor* self, const aclIntArray* dim, bool keepdim, aclTensor* out)
109	bool keepdim, aclTensor* out) {	110	{
110	// 1. 检查参数是否为空指针	111	// 1. 检查参数是否为空指针
111	CHECK_RET(CheckNotNull2Tensor(self, out), ACLNN_ERR_PARAM_NULLPTR);	112	CHECK_RET(CheckNotNull2Tensor(self, out), ACLNN_ERR_PARAM_NULLPTR);
112		113
	@@ -121,7 +122,8 @@ static aclnnStatus CheckParams(const aclTensor* self, const aclIntArray* dim,
121	return ACLNN_SUCCESS;	122	return ACLNN_SUCCESS;
122	}	123	}
123		124
124	static int64_t CalcShapeProd(const aclTensor* self, const aclIntArray* dim) {	125	static int64_t CalcShapeProd(const aclTensor* self, const aclIntArray* dim)
		126	{
125	auto selfViewShape = self->GetViewShape();	127	auto selfViewShape = self->GetViewShape();
126	auto selfDimNum = static_cast<int64_t>(selfViewShape.GetDimNum());	128	auto selfDimNum = static_cast<int64_t>(selfViewShape.GetDimNum());
127	int64_t shapeProd = 1;	129	int64_t shapeProd = 1;
	@@ -136,8 +138,9 @@ static int64_t CalcShapeProd(const aclTensor* self, const aclIntArray* dim) {
136	return shapeProd;	138	return shapeProd;
137	}	139	}
138		140
139	static aclnnStatus aclnnVarImplUnify(const aclTensor self, const aclIntArray dim, bool unbiased, bool keepdim,	141	static aclnnStatus aclnnVarImplUnify(const aclTensor* self, const aclIntArray* dim, bool unbiased, bool keepdim,
140	aclTensor out, uint64_t workspaceSize, UniqueExecutor &uniqueExecutor, aclOpExecutor **executor)	142	aclTensor* out, uint64_t* workspaceSize, UniqueExecutor& uniqueExecutor,
		143	aclOpExecutor** executor)
141	{	144	{
142	int64_t correction = unbiased ? 1 : 0;	145	int64_t correction = unbiased ? 1 : 0;
143	bool isMeanOut = false;	146	bool isMeanOut = false;
	@@ -157,8 +160,9 @@ static aclnnStatus aclnnVarImplUnify(const aclTensor self, const aclIntArray d
157	return ACLNN_SUCCESS;	160	return ACLNN_SUCCESS;
158	}	161	}
159		162
160	aclnnStatus aclnnVarGetWorkspaceSize(const aclTensor* self, const aclIntArray* dim, bool unbiased, bool keepdim,	163	aclnnStatus aclnnVarGetWorkspaceSize(const aclTensor* self, const aclIntArray* dim, bool unbiased, bool keepdim,
161	aclTensor* out, uint64_t* workspaceSize, aclOpExecutor* *executor) {	164	aclTensor* out, uint64_t* workspaceSize, aclOpExecutor** executor)
		165	{
162	OP_CHECK_COMM_INPUT(workspaceSize, executor);	166	OP_CHECK_COMM_INPUT(workspaceSize, executor);
163		167
164	L2_DFX_PHASE_1(aclnnVar, DFX_IN(self, dim, unbiased, keepdim), DFX_OUT(out));	168	L2_DFX_PHASE_1(aclnnVar, DFX_IN(self, dim, unbiased, keepdim), DFX_OUT(out));
	@@ -193,8 +197,8 @@ aclnnStatus aclnnVarGetWorkspaceSize(const aclTensor* self, const aclIntArray* d
193	CHECK_RET(selfReformat != nullptr, ACLNN_ERR_INNER_NULLPTR);	197	CHECK_RET(selfReformat != nullptr, ACLNN_ERR_INNER_NULLPTR);
194		198
195	if (IsRegBase()) {	199	if (IsRegBase()) {
196	return aclnnVarImplUnify(selfReformat, dimArray, unbiased, keepdim, out, workspaceSize,	200	return aclnnVarImplUnify(selfReformat, dimArray, unbiased, keepdim, out, workspaceSize, uniqueExecutor,
197	uniqueExecutor, executor);	201	executor);
198	}	202	}
199		203
200	// 调用mean算子kernel	204	// 调用mean算子kernel
	@@ -234,14 +238,16 @@ aclnnStatus aclnnVarGetWorkspaceSize(const aclTensor* self, const aclIntArray* d
234	return ACLNN_SUCCESS;	238	return ACLNN_SUCCESS;
235	}	239	}
236		240
237	aclnnStatus aclnnVar(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream) {	241	aclnnStatus aclnnVar(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
		242	{
238	L2_DFX_PHASE_2(aclnnVar);	243	L2_DFX_PHASE_2(aclnnVar);
239	// 固定写法，调用框架能力，完成计算	244	// 固定写法，调用框架能力，完成计算
240	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	245	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
241	}	246	}
242		247
243	static aclnnStatus aclnnVarCorrectionImplUnify(const aclTensor self, const aclIntArray dim, int64_t correction,	248	static aclnnStatus aclnnVarCorrectionImplUnify(const aclTensor* self, const aclIntArray* dim, int64_t correction,
244	bool keepdim, aclTensor out, uint64_t workspaceSize, UniqueExecutor &uniqueExecutor, aclOpExecutor **executor)	249	bool keepdim, aclTensor* out, uint64_t* workspaceSize,
		250	UniqueExecutor& uniqueExecutor, aclOpExecutor** executor)
245	{	251	{
246	bool isMeanOut = false;	252	bool isMeanOut = false;
247	auto reduceVarOut = l0op::ReduceVar(self, dim, correction, keepdim, isMeanOut, uniqueExecutor.get());	253	auto reduceVarOut = l0op::ReduceVar(self, dim, correction, keepdim, isMeanOut, uniqueExecutor.get());
	@@ -260,8 +266,10 @@ static aclnnStatus aclnnVarCorrectionImplUnify(const aclTensor *self, const aclI
260	return ACLNN_SUCCESS;	266	return ACLNN_SUCCESS;
261	}	267	}
262		268
263	aclnnStatus aclnnVarCorrectionGetWorkspaceSize(const aclTensor* self, const aclIntArray* dim, int64_t correction, bool keepdim,	269	aclnnStatus aclnnVarCorrectionGetWorkspaceSize(const aclTensor* self, const aclIntArray* dim, int64_t correction,
264	aclTensor* out, uint64_t* workspaceSize, aclOpExecutor** executor) {	270	bool keepdim, aclTensor* out, uint64_t* workspaceSize,
		271	aclOpExecutor** executor)
		272	{
265	OP_CHECK_COMM_INPUT(workspaceSize, executor);	273	OP_CHECK_COMM_INPUT(workspaceSize, executor);
266		274
267	L2_DFX_PHASE_1(aclnnVarCorrection, DFX_IN(self, dim, correction, keepdim), DFX_OUT(out));	275	L2_DFX_PHASE_1(aclnnVarCorrection, DFX_IN(self, dim, correction, keepdim), DFX_OUT(out));
	@@ -337,8 +345,8 @@ aclnnStatus aclnnVarCorrectionGetWorkspaceSize(const aclTensor* self, const aclI
337	}	345	}
338		346
339	// 调用算子完成方差计算	347	// 调用算子完成方差计算
340	auto varOut = l0op::ReduceStdV2UpdateCorrection(selfReformat, meanOpOut, dimArray,	348	auto varOut = l0op::ReduceStdV2UpdateCorrection(selfReformat, meanOpOut, dimArray, correction, keepdim,
341	correction, keepdim, uniqueExecutor.get());	349	uniqueExecutor.get());
342	CHECK_RET(varOut != nullptr, ACLNN_ERR_INNER_NULLPTR);	350	CHECK_RET(varOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
343		351
344	// 固定写法，将计算结果转换成输出out的数据类型	352	// 固定写法，将计算结果转换成输出out的数据类型
	@@ -356,7 +364,8 @@ aclnnStatus aclnnVarCorrectionGetWorkspaceSize(const aclTensor* self, const aclI
356	return ACLNN_SUCCESS;	364	return ACLNN_SUCCESS;
357	}	365	}
358		366
359	aclnnStatus aclnnVarCorrection(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream) {	367	aclnnStatus aclnnVarCorrection(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
		368	{
360	L2_DFX_PHASE_2(aclnnVarCorrection);	369	L2_DFX_PHASE_2(aclnnVarCorrection);
361	// 固定写法，调用框架能力，完成计算	370	// 固定写法，调用框架能力，完成计算
362	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	371	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
	@@ -364,4 +373,4 @@ aclnnStatus aclnnVarCorrection(void* workspace, uint64_t workspaceSize, aclOpExe
364		373
365	#ifdef __cplusplus	374	#ifdef __cplusplus
366	}	375	}
367	#endif	376	#endif

Mmath/reduce_var/op_api/aclnn_var_mean.cpp+32-26

	@@ -9,7 +9,7 @@
9	*/	9	*/
10		10
11	#include "aclnn_var_mean.h"	11	#include "aclnn_var_mean.h"
12	#include "math/reduce_std_v2_update/op_host/op_api/reduce_std_v2_update.h"	12	#include "math/reduce_std_v2_update/op_api/reduce_std_v2_update.h"
13	#include "math/reduce_mean/op_api/reduce_mean.h"	13	#include "math/reduce_mean/op_api/reduce_mean.h"
14	#include "reduce_var.h"	14	#include "reduce_var.h"
15	#include "aclnn_kernels/reshape.h"	15	#include "aclnn_kernels/reshape.h"
	@@ -39,13 +39,14 @@ extern "C" {
39	#endif	39	#endif
40		40
41	// 算子支持的所有dtype	41	// 算子支持的所有dtype
42	static const std::initializer_list<op::DataType> DTYPE_SUPPORT_LIST = {	42	static const std::initializer_list<op::DataType> DTYPE_SUPPORT_LIST = {op::DataType::DT_FLOAT,
43	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16};	43	op::DataType::DT_FLOAT16};
44		44
45	static const std::initializer_list<op::DataType> ARCH3510_DTYPE_SUPPORT_LIST = {	45	static const std::initializer_list<op::DataType> ARCH3510_DTYPE_SUPPORT_LIST = {
46	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};	46	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};
47		47
48	static const std::initializer_list<DataType>& GetDtypeSupportList() {	48	static const std::initializer_list<DataType>& GetDtypeSupportList()
		49	{
49	if (IsRegBase()) {	50	if (IsRegBase()) {
50	return ARCH3510_DTYPE_SUPPORT_LIST;	51	return ARCH3510_DTYPE_SUPPORT_LIST;
51	} else {	52	} else {
	@@ -53,7 +54,8 @@ static const std::initializer_list<DataType>& GetDtypeSupportList() {
53	}	54	}
54	}	55	}
55		56
56	static bool CheckDtypeValid(const aclTensor* self, aclTensor* meanOut, aclTensor* varOut) {	57	static bool CheckDtypeValid(const aclTensor* self, aclTensor* meanOut, aclTensor* varOut)
		58	{
57	auto dtypeSupportList = GetDtypeSupportList();	59	auto dtypeSupportList = GetDtypeSupportList();
58	OP_CHECK_DTYPE_NOT_SUPPORT(self, dtypeSupportList, return false);	60	OP_CHECK_DTYPE_NOT_SUPPORT(self, dtypeSupportList, return false);
59	OP_CHECK_DTYPE_NOT_SUPPORT(meanOut, dtypeSupportList, return false);	61	OP_CHECK_DTYPE_NOT_SUPPORT(meanOut, dtypeSupportList, return false);
	@@ -61,7 +63,8 @@ static bool CheckDtypeValid(const aclTensor* self, aclTensor* meanOut, aclTensor
61	return true;	63	return true;
62	}	64	}
63		65
64	static bool CheckDimValid(const aclTensor* self, const aclIntArray* dim) {	66	static bool CheckDimValid(const aclTensor* self, const aclIntArray* dim)
		67	{
65	auto selfViewShape = self->GetViewShape();	68	auto selfViewShape = self->GetViewShape();
66	auto selfDimNum = static_cast<int64_t>(selfViewShape.GetDimNum());	69	auto selfDimNum = static_cast<int64_t>(selfViewShape.GetDimNum());
67	// self为标量时，dim range [-1, 0]	70	// self为标量时，dim range [-1, 0]
	@@ -73,14 +76,14 @@ static bool CheckDimValid(const aclTensor* self, const aclIntArray* dim) {
73	uint64_t dimMask[64] = {0};	76	uint64_t dimMask[64] = {0};
74	for (size_t i = 0; i < dim->Size(); i++) {	77	for (size_t i = 0; i < dim->Size(); i++) {
75	if (dim->operator[](i) >= selfDimNum \|\| dim->operator[](i) < (-selfDimNum)) {	78	if (dim->operator[](i) >= selfDimNum \|\| dim->operator[](i) < (-selfDimNum)) {
76	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Provided dim %ld must be in the range of [%ld, %ld].",	79	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Provided dim %ld must be in the range of [%ld, %ld].", dim->operator[](i),
77	dim->operator[](i), -selfDimNum, selfDimNum - 1);	80	-selfDimNum, selfDimNum - 1);
78	return false;	81	return false;
79	}	82	}
80	if (dim->operator[](i) < 0) {	83	if (dim->operator[](i) < 0) {
81	if (dimMask[selfDimNum + dim->operator[](i)] == 1) {	84	if (dimMask[selfDimNum + dim->operator[](i)] == 1) {
82	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dim %ld appears multiple times in the list of dims.",	85	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dim %ld appears multiple times in the list of dims.",
83	selfDimNum + dim->operator[](i));	86	selfDimNum + dim->operator[](i));
84	return false;	87	return false;
85	}	88	}
86	dimMask[selfDimNum + dim->operator[](i)] = 1;	89	dimMask[selfDimNum + dim->operator[](i)] = 1;
	@@ -95,8 +98,9 @@ static bool CheckDimValid(const aclTensor* self, const aclIntArray* dim) {
95	return true;	98	return true;
96	}	99	}
97		100
98	static bool CheckShape(const aclTensor* self, const aclIntArray* dim, bool keepdim,	101	static bool CheckShape(const aclTensor* self, const aclIntArray* dim, bool keepdim, aclTensor* meanOut,
99	aclTensor* meanOut, aclTensor* varOut) {	102	aclTensor* varOut)
		103	{
100	OP_CHECK_MAX_DIM(self, MAX_SUPPORT_DIMS_NUMS, return false);	104	OP_CHECK_MAX_DIM(self, MAX_SUPPORT_DIMS_NUMS, return false);
101		105
102	op::Shape reduceShape = ReduceShapeGetWithVar(self, dim, keepdim);	106	op::Shape reduceShape = ReduceShapeGetWithVar(self, dim, keepdim);
	@@ -107,8 +111,9 @@ static bool CheckShape(const aclTensor* self, const aclIntArray* dim, bool keepd
107	return true;	111	return true;
108	}	112	}
109		113
110	static aclnnStatus CheckParams(const aclTensor* self, const aclIntArray* dim, bool keepdim,	114	static aclnnStatus CheckParams(const aclTensor* self, const aclIntArray* dim, bool keepdim, aclTensor* meanOut,
111	aclTensor* meanOut, aclTensor* varOut) {	115	aclTensor* varOut)
		116	{
112	// 1. 检查参数是否为空指针	117	// 1. 检查参数是否为空指针
113	CHECK_RET(CheckNotNull3Tensor(self, meanOut, varOut), ACLNN_ERR_PARAM_NULLPTR);	118	CHECK_RET(CheckNotNull3Tensor(self, meanOut, varOut), ACLNN_ERR_PARAM_NULLPTR);
114		119
	@@ -123,9 +128,9 @@ static aclnnStatus CheckParams(const aclTensor* self, const aclIntArray* dim, bo
123	return ACLNN_SUCCESS;	128	return ACLNN_SUCCESS;
124	}	129	}
125		130
126	static aclnnStatus aclnnVarMeanImplUnify(const aclTensor self, const aclIntArray dim, int64_t correction,	131	static aclnnStatus aclnnVarMeanImplUnify(const aclTensor* self, const aclIntArray* dim, int64_t correction,
127	bool keepdim, aclTensor varOut, aclTensor meanOut, uint64_t* workspaceSize,	132	bool keepdim, aclTensor* varOut, aclTensor* meanOut, uint64_t* workspaceSize,
128	UniqueExecutor &uniqueExecutor, aclOpExecutor **executor)	133	UniqueExecutor& uniqueExecutor, aclOpExecutor** executor)
129	{	134	{
130	bool isMeanOut = true;	135	bool isMeanOut = true;
131	auto reduceVarOut = l0op::ReduceVar(self, dim, correction, keepdim, isMeanOut, uniqueExecutor.get());	136	auto reduceVarOut = l0op::ReduceVar(self, dim, correction, keepdim, isMeanOut, uniqueExecutor.get());
	@@ -151,10 +156,10 @@ static aclnnStatus aclnnVarMeanImplUnify(const aclTensor *self, const aclIntArra
151	return ACLNN_SUCCESS;	156	return ACLNN_SUCCESS;
152	}	157	}
153		158
154	aclnnStatus aclnnVarMeanGetWorkspaceSize(const aclTensor* self, const aclIntArray* dim,	159	aclnnStatus aclnnVarMeanGetWorkspaceSize(const aclTensor* self, const aclIntArray* dim, int64_t correction,
155	int64_t correction, bool keepdim,	160	bool keepdim, aclTensor* varOut, aclTensor* meanOut, uint64_t* workspaceSize,
156	aclTensor* varOut, aclTensor* meanOut,	161	aclOpExecutor** executor)
157	uint64_t* workspaceSize, aclOpExecutor** executor) {	162	{
158	OP_CHECK_COMM_INPUT(workspaceSize, executor);	163	OP_CHECK_COMM_INPUT(workspaceSize, executor);
159		164
160	L2_DFX_PHASE_1(aclnnVarMean, DFX_IN(self, dim, correction, keepdim), DFX_OUT(varOut, meanOut));	165	L2_DFX_PHASE_1(aclnnVarMean, DFX_IN(self, dim, correction, keepdim), DFX_OUT(varOut, meanOut));
	@@ -200,8 +205,8 @@ aclnnStatus aclnnVarMeanGetWorkspaceSize(const aclTensor* self, const aclIntArra
200	CHECK_RET(selfReformat != nullptr, ACLNN_ERR_INNER_NULLPTR);	205	CHECK_RET(selfReformat != nullptr, ACLNN_ERR_INNER_NULLPTR);
201		206
202	if (IsRegBase()) {	207	if (IsRegBase()) {
203	return aclnnVarMeanImplUnify(selfReformat, dimArray, correction, keepdim, varOut, meanOut,	208	return aclnnVarMeanImplUnify(selfReformat, dimArray, correction, keepdim, varOut, meanOut, workspaceSize,
204	workspaceSize, uniqueExecutor, executor);	209	uniqueExecutor, executor);
205	}	210	}
206		211
207	// 调用mean算子kernel	212	// 调用mean算子kernel
	@@ -265,8 +270,8 @@ aclnnStatus aclnnVarMeanGetWorkspaceSize(const aclTensor* self, const aclIntArra
265	}	270	}
266		271
267	// 调用算子完成方差计算	272	// 调用算子完成方差计算
268	auto varOpOut = l0op::ReduceStdV2UpdateCorrection(selfReformat, meanOpOut, dimArray,	273	auto varOpOut = l0op::ReduceStdV2UpdateCorrection(selfReformat, meanOpOut, dimArray, correction, keepdim,
269	correction, keepdim, uniqueExecutor.get());	274	uniqueExecutor.get());
270	CHECK_RET(varOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);	275	CHECK_RET(varOpOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
271		276
272	// 固定写法，将计算结果转换成输出out的数据类型	277	// 固定写法，将计算结果转换成输出out的数据类型
	@@ -284,7 +289,8 @@ aclnnStatus aclnnVarMeanGetWorkspaceSize(const aclTensor* self, const aclIntArra
284	return ACLNN_SUCCESS;	289	return ACLNN_SUCCESS;
285	}	290	}
286		291
287	aclnnStatus aclnnVarMean(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream) {	292	aclnnStatus aclnnVarMean(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
		293	{
288	L2_DFX_PHASE_2(aclnnVarMean);	294	L2_DFX_PHASE_2(aclnnVarMean);
289	// 固定写法，调用框架能力，完成计算	295	// 固定写法，调用框架能力，完成计算
290	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	296	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
	@@ -292,4 +298,4 @@ aclnnStatus aclnnVarMean(void* workspace, uint64_t workspaceSize, aclOpExecutor*
292		298
293	#ifdef __cplusplus	299	#ifdef __cplusplus
294	}	300	}
295	#endif	301	#endif

Mmath/rfft1_d/CMakeLists.txt+7-15

	@@ -1,19 +1,11 @@
1	# This program is free software, you can redistribute it and/or modify it.	1	# ----------------------------------------------------------------------------
2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. See LICENSE in the root of	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ============================================================================	9	# ----------------------------------------------------------------------------
10		10
11	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE rfft1_d ACLNNTYPE aclnn_exclude)
12	if(NOT ENABLE_TEST AND NOT BENCHMARK)
13	list(REMOVE_ITEM CURRENT_DIRS tests)
14	endif()
15	foreach(SUB_DIR ${CURRENT_DIRS})
16	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
17	add_subdirectory(${SUB_DIR})
18	endif()
19	endforeach()

Rmath/rfft1_d/op_host/op_api/acl_rfft1d.cpp→math/rfft1_d/op_api/acl_rfft1d.cpp+59-78

	@@ -1,10 +1,10 @@
1	/**	1	/**
2	* Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This file is a part of the CANN Open Software.	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	* BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/	9	*/
10		10
	@@ -56,12 +56,7 @@ static const int64_t PAD_VALUE = 0;
56	static const size_t MIN_INPUT_DIM_NUM = 1;	56	static const size_t MIN_INPUT_DIM_NUM = 1;
57	static const size_t MAX_INPUT_DIM_NUM = 7;	57	static const size_t MAX_INPUT_DIM_NUM = 7;
58		58
59	enum NORM_VALUES	59	enum NORM_VALUES { BACKWARD = 1, FORWARD = 2, ORTHO = 3 };
60	{
61	BACKWARD = 1,
62	FORWARD = 2,
63	ORTHO = 3
64	};
65		60
66	static const std::initializer_list<DataType> NULL_SUPPORT_LIST = {};	61	static const std::initializer_list<DataType> NULL_SUPPORT_LIST = {};
67	static const int DEVICE_MAX_CACHE_NUM = 100;	62	static const int DEVICE_MAX_CACHE_NUM = 100;
	@@ -107,26 +102,16 @@ public:
107	return planCache[key];	102	return planCache[key];
108	}	103	}
109		104
110	void AddTensorLen(int64_t len, int64_t tensorLen)	105	void AddTensorLen(int64_t len, int64_t tensorLen) { tensorLenCache[len] = tensorLen; }
111	{
112	tensorLenCache[len] = tensorLen;
113	}
114		106
115	int64_t FindTensorLen(int64_t len)	107	int64_t FindTensorLen(int64_t len) { return tensorLenCache[len]; }
116	{
117	return tensorLenCache[len];
118	}
119		108
120	bool operator<(const Rfft1DSingleton& other) const	109	bool operator<(const Rfft1DSingleton& other) const { return deviceCacheNum < other.deviceCacheNum; }
121	{
122	return deviceCacheNum < other.deviceCacheNum;
123	}
124	};	110	};
125		111
126	static const std::initializer_list<DataType>& GetDtypeSupportList()	112	static const std::initializer_list<DataType>& GetDtypeSupportList()
127	{	113	{
128	if (IsRegBase() \|\|	114	if (IsRegBase() \|\| GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910_93 \|\|
129	GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910_93 \|\|
130	GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910B) {	115	GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910B) {
131	return ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST;	116	return ASCEND910B_DTYPE_DTYPE_SUPPORT_LIST;
132	} else {	117	} else {
	@@ -167,15 +152,13 @@ static bool CheckParamsValid(const aclTensor* self, int64_t n, int64_t dim, int6
167	return false;	152	return false;
168	}	153	}
169	if (!((norm == BACKWARD) \|\| (norm == FORWARD) \|\| (norm == ORTHO))) {	154	if (!((norm == BACKWARD) \|\| (norm == FORWARD) \|\| (norm == ORTHO))) {
170	OP_LOGE(	155	OP_LOGE(ACLNN_ERR_PARAM_INVALID,
171	ACLNN_ERR_PARAM_INVALID,	156	"'norm' should be equal {BACKWARD, FORWARD, ORTHO} via pytorch call or {1, 2, 3} in other cases");
172	"'norm' should be equal {BACKWARD, FORWARD, ORTHO} via pytorch call or {1, 2, 3} in other cases");
173	return false;	157	return false;
174	}	158	}
175	if (!((dim >= -dims) && (dim < dims))) {	159	if (!((dim >= -dims) && (dim < dims))) {
176	OP_LOGE(	160	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "'dim' out of range (expected to be in range of [%ld, %ld], but got %ld",
177	ACLNN_ERR_PARAM_INVALID, "'dim' out of range (expected to be in range of [%ld, %ld], but got %ld", -dims,	161	-dims, dims - 1, dim);
178	dims - 1, dim);
179	return false;	162	return false;
180	}	163	}
181	return true;	164	return true;
	@@ -183,8 +166,7 @@ static bool CheckParamsValid(const aclTensor* self, int64_t n, int64_t dim, int6
183		166
184	static bool CheckPlatform()	167	static bool CheckPlatform()
185	{	168	{
186	if (IsRegBase() \|\|	169	if (IsRegBase() \|\| GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910_93 \|\|
187	GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910_93 \|\|
188	GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910B) {	170	GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910B) {
189	return true;	171	return true;
190	} else {	172	} else {
	@@ -193,8 +175,7 @@ static bool CheckPlatform()
193	}	175	}
194	}	176	}
195		177
196	static aclnnStatus CheckParams(	178	static aclnnStatus CheckParams(const aclTensor* self, int64_t n, int64_t dim, int64_t norm, int64_t dims)
197	const aclTensor* self, int64_t n, int64_t dim, int64_t norm, int64_t dims)
198	{	179	{
199	CHECK_RET(CheckDtypeValid(self), ACLNN_ERR_PARAM_INVALID);	180	CHECK_RET(CheckDtypeValid(self), ACLNN_ERR_PARAM_INVALID);
200	CHECK_RET(CheckParamsValid(self, n, dim, norm, dims), ACLNN_ERR_PARAM_INVALID);	181	CHECK_RET(CheckParamsValid(self, n, dim, norm, dims), ACLNN_ERR_PARAM_INVALID);
	@@ -299,10 +280,10 @@ static void DoubleRI(std::vector<double>& ret, std::vector<std::complex<double>>
299	}	280	}
300	}	281	}
301		282
302	static void CalculateBeta(	283	static void CalculateBeta(std::complex<double>& b, std::vector<double>& betaTmp, std::vector<double>& betaReverseReal,
303	std::complex<double>& b, std::vector<double>& betaTmp, std::vector<double>& betaReverseReal,	284	std::vector<double>& betaReverseImag, std::vector<double>& betaConj,
304	std::vector<double>& betaReverseImag, std::vector<double>& betaConj, std::vector<double>& betaConjImag,	285	std::vector<double>& betaConjImag, const int64_t len, const uint64_t lenPow2,
305	const int64_t len, const uint64_t lenPow2, const int64_t startIndex)	286	const int64_t startIndex)
306	{	287	{
307	for (int64_t i = 0; i < len; ++i) {	288	for (int64_t i = 0; i < len; ++i) {
308	std::complex<double> curBeta = std::pow(b, i * i);	289	std::complex<double> curBeta = std::pow(b, i * i);
	@@ -369,8 +350,8 @@ static std::vector<double> GenerateAlphaBeta(const int64_t& len, const uint64_t&
369	CalculateBeta(B, betaTmp, betaReverseReal, betaReverseImag, betaConj, betaConjImag, len, lenPow2, startIndex);	350	CalculateBeta(B, betaTmp, betaReverseReal, betaReverseImag, betaConj, betaConjImag, len, lenPow2, startIndex);
370		351
371	ret.insert(ret.end(), std::make_move_iterator(betaConj.begin()), std::make_move_iterator(betaConj.end()));	352	ret.insert(ret.end(), std::make_move_iterator(betaConj.begin()), std::make_move_iterator(betaConj.end()));
372	ret.insert(	353	ret.insert(ret.end(), std::make_move_iterator(betaConjImag.begin()),
373	ret.end(), std::make_move_iterator(betaConjImag.begin()), std::make_move_iterator(betaConjImag.end()));	354	std::make_move_iterator(betaConjImag.end()));
374		355
375	for (int64_t i = 0; i < len; ++i) {	356	for (int64_t i = 0; i < len; ++i) {
376	std::complex<double> curBeta = std::pow(B, i * i);	357	std::complex<double> curBeta = std::pow(B, i * i);
	@@ -433,8 +414,8 @@ static const aclTensor* GenerateDftMatrix(int64_t len, int64_t norm, aclOpExecut
433	return deviceTensor;	414	return deviceTensor;
434	}	415	}
435		416
436	static void CalculateIntermediateFactors(	417	static void CalculateIntermediateFactors(std::vector<uint32_t>& interFactors, std::vector<uint32_t> availableFactors,
437	std::vector<uint32_t>& interFactors, std::vector<uint32_t> availableFactors, uint32_t tmpN, int curFactorsIndex)	418	uint32_t tmpN, int curFactorsIndex)
438	{	419	{
439	while (curFactorsIndex >= 0) {	420	while (curFactorsIndex >= 0) {
440	while (tmpN % availableFactors[curFactorsIndex] == 0) {	421	while (tmpN % availableFactors[curFactorsIndex] == 0) {
	@@ -489,10 +470,10 @@ static void CalculateFactors(uint32_t factors[], int64_t len, bool& isBluestein)
489	}	470	}
490	}	471	}
491		472
492	static void CalculationDft(	473	static void CalculationDft(std::vector<double>& dftRealCurVal, std::vector<double>& dftImagCurVal,
493	std::vector<double>& dftRealCurVal, std::vector<double>& dftImagCurVal, std::vector<double>& dftRealBackCurVal,	474	std::vector<double>& dftRealBackCurVal, std::vector<double>& dftImagBackCurVal,
494	std::vector<double>& dftImagBackCurVal, size_t curIndex, bool isBluestein, size_t colsNum, size_t curFactor,	475	size_t curIndex, bool isBluestein, size_t colsNum, size_t curFactor, const size_t& i,
495	const size_t& i, size_t& k)	476	size_t& k)
496	{	477	{
497	for (size_t j = 0; j < colsNum / (COMPLEX - int(curIndex != 0)); ++j) {	478	for (size_t j = 0; j < colsNum / (COMPLEX - int(curIndex != 0)); ++j) {
498	double param = curFactor != 0 ? -2. * M_PI * i * j / curFactor : 0;	479	double param = curFactor != 0 ? -2. * M_PI * i * j / curFactor : 0;
	@@ -519,14 +500,16 @@ static void CalculationDft(
519	}	500	}
520	}	501	}
521		502
522	static void CalculationMatricesValues(	503	static void CalculationMatricesValues(std::vector<double>& dftRealVal, std::vector<double>& dftImagVal,
523	std::vector<double>& dftRealVal, std::vector<double>& dftImagVal, std::vector<double>& dftRealBackVal,	504	std::vector<double>& dftRealBackVal, std::vector<double>& dftImagBackVal,
524	std::vector<double>& dftImagBackVal, std::vector<double>& twiddleRealVal, std::vector<double>& twiddleImagVal,	505	std::vector<double>& twiddleRealVal, std::vector<double>& twiddleImagVal,
525	std::vector<double>& twiddleImagBackVal, std::vector<double>& dftRealCurVal, std::vector<double>& dftImagCurVal,	506	std::vector<double>& twiddleImagBackVal, std::vector<double>& dftRealCurVal,
526	std::vector<double>& dftRealBackCurVal, std::vector<double>& dftImagBackCurVal,	507	std::vector<double>& dftImagCurVal, std::vector<double>& dftRealBackCurVal,
527	std::vector<double>& twiddleRealCurVal, std::vector<double>& twiddleImagCurVal,	508	std::vector<double>& dftImagBackCurVal, std::vector<double>& twiddleRealCurVal,
528	std::vector<double>& twiddleImagBackCurVal, int64_t len, int64_t norm, size_t curIndex, bool isBluestein,	509	std::vector<double>& twiddleImagCurVal,
529	size_t rowsNum, size_t colsNum, size_t curFactor, size_t twiddleCurSize, size_t prevFactors)	510	std::vector<double>& twiddleImagBackCurVal, int64_t len, int64_t norm,
		511	size_t curIndex, bool isBluestein, size_t rowsNum, size_t colsNum,
		512	size_t curFactor, size_t twiddleCurSize, size_t prevFactors)
530	{	513	{
531	size_t k = 0, l = 0;	514	size_t k = 0, l = 0;
532	double normParam = 1.;	515	double normParam = 1.;
	@@ -534,9 +517,8 @@ static void CalculationMatricesValues(
534	normParam = norm == FORWARD ? normParam / double(len) : normParam / sqrt(double(len));	517	normParam = norm == FORWARD ? normParam / double(len) : normParam / sqrt(double(len));
535	}	518	}
536	for (size_t i = 0; i < rowsNum / (1 + int(curIndex == 0 && isBluestein)); ++i) {	519	for (size_t i = 0; i < rowsNum / (1 + int(curIndex == 0 && isBluestein)); ++i) {
537	CalculationDft(	520	CalculationDft(dftRealCurVal, dftImagCurVal, dftRealBackCurVal, dftImagBackCurVal, curIndex, isBluestein,
538	dftRealCurVal, dftImagCurVal, dftRealBackCurVal, dftImagBackCurVal, curIndex, isBluestein, colsNum,	521	colsNum, curFactor, i, k);
539	curFactor, i, k);
540		522
541	if (curIndex != 0) {	523	if (curIndex != 0) {
542	for (size_t j = 0; j < prevFactors; ++j) {	524	for (size_t j = 0; j < prevFactors; ++j) {
	@@ -593,10 +575,11 @@ static void SetMatricesValues(std::vector<double> matrix, float* addrStart, size
593	}	575	}
594	}	576	}
595		577
596	static const aclTensor* FinalCalculation(	578	static const aclTensor* FinalCalculation(std::vector<double> dftRealVal, std::vector<double> dftImagVal,
597	std::vector<double> dftRealVal, std::vector<double> dftImagVal, std::vector<double> twiddleRealVal,	579	std::vector<double> twiddleRealVal, std::vector<double> twiddleImagVal,
598	std::vector<double> twiddleImagVal, std::vector<double> dftRealBackVal, std::vector<double> dftImagBackVal,	580	std::vector<double> dftRealBackVal, std::vector<double> dftImagBackVal,
599	std::vector<double> twiddleImagBackVal, int64_t len, bool isBluestein, uint32_t& tensorLen, aclOpExecutor* executor)	581	std::vector<double> twiddleImagBackVal, int64_t len, bool isBluestein,
		582	uint32_t& tensorLen, aclOpExecutor* executor)
600	{	583	{
601	std::vector<double> bluesteinRet;	584	std::vector<double> bluesteinRet;
602	if (isBluestein) {	585	if (isBluestein) {
	@@ -661,20 +644,19 @@ static const aclTensor* GenerateTerminatorMatrix(int64_t len, int64_t norm, aclO
661	twiddleImagCurVal(twiddleCurSize, INIT_VALUE), twiddleImagBackCurVal(twiddleCurSize, INIT_VALUE);	644	twiddleImagCurVal(twiddleCurSize, INIT_VALUE), twiddleImagBackCurVal(twiddleCurSize, INIT_VALUE);
662		645
663	if (curFactor != 1) {	646	if (curFactor != 1) {
664	CalculationMatricesValues(	647	CalculationMatricesValues(dftRealVal, dftImagVal, dftRealBackVal, dftImagBackVal, twiddleRealVal,
665	dftRealVal, dftImagVal, dftRealBackVal, dftImagBackVal, twiddleRealVal, twiddleImagVal,	648	twiddleImagVal, twiddleImagBackVal, dftRealCurVal, dftImagCurVal,
666	twiddleImagBackVal, dftRealCurVal, dftImagCurVal, dftRealBackCurVal, dftImagBackCurVal,	649	dftRealBackCurVal, dftImagBackCurVal, twiddleRealCurVal, twiddleImagCurVal,
667	twiddleRealCurVal, twiddleImagCurVal, twiddleImagBackCurVal, len, norm, curIndex, isBluestein, rowsNum,	650	twiddleImagBackCurVal, len, norm, curIndex, isBluestein, rowsNum, colsNum,
668	colsNum, curFactor, twiddleCurSize, prevFactors);	651	curFactor, twiddleCurSize, prevFactors);
669	}	652	}
670	prevFactors *= curFactor;	653	prevFactors *= curFactor;
671	}	654	}
672		655
673	uint32_t tensorLen = dftRealVal.size() + dftImagVal.size() + twiddleRealVal.size() + twiddleImagVal.size();	656	uint32_t tensorLen = dftRealVal.size() + dftImagVal.size() + twiddleRealVal.size() + twiddleImagVal.size();
674		657
675	auto dftMatrix = FinalCalculation(	658	auto dftMatrix = FinalCalculation(dftRealVal, dftImagVal, twiddleRealVal, twiddleImagVal, dftRealBackVal,
676	dftRealVal, dftImagVal, twiddleRealVal, twiddleImagVal, dftRealBackVal, dftImagBackVal, twiddleImagBackVal, len,	659	dftImagBackVal, twiddleImagBackVal, len, isBluestein, tensorLen, executor);
677	isBluestein, tensorLen, executor);
678		660
679	const aclTensor* deviceTensor = nullptr;	661	const aclTensor* deviceTensor = nullptr;
680	auto deviceIdCacheNum = Rfft1DSingleton::GetInstance().FindCacheNum(deviceId);	662	auto deviceIdCacheNum = Rfft1DSingleton::GetInstance().FindCacheNum(deviceId);
	@@ -714,8 +696,8 @@ static const aclTensor* TransposeOutput(const aclTensor* out, int64_t dim, aclOp
714	return outContiguous;	696	return outContiguous;
715	}	697	}
716		698
717	static const aclTensor* GeneratePadInput(	699	static const aclTensor* GeneratePadInput(const aclTensor* self, int64_t n, int64_t lastDimLength, int64_t batches,
718	const aclTensor* self, int64_t n, int64_t lastDimLength, int64_t batches, aclOpExecutor* executor)	700	aclOpExecutor* executor)
719	{	701	{
720	size_t dims = 2;	702	size_t dims = 2;
721	int64_t left = 0;	703	int64_t left = 0;
	@@ -738,8 +720,8 @@ static const aclTensor* GeneratePadInput(
738	return l0op::Pad(self, padTensor, executor);	720	return l0op::Pad(self, padTensor, executor);
739	}	721	}
740		722
741	static const aclTensor* InputProcessing(	723	static const aclTensor* InputProcessing(const aclTensor* selfContiguous, int64_t n, int64_t dims,
742	const aclTensor* selfContiguous, int64_t n, int64_t dims, aclOpExecutor* executor)	724	aclOpExecutor* executor)
743	{	725	{
744	op::Shape newInputShape = selfContiguous->GetViewShape();	726	op::Shape newInputShape = selfContiguous->GetViewShape();
745	int64_t lastDimLength = newInputShape.GetDim(dims - 1);	727	int64_t lastDimLength = newInputShape.GetDim(dims - 1);
	@@ -787,9 +769,8 @@ static const aclTensor* InputProcessing(
787	return selfContiguous;	769	return selfContiguous;
788	}	770	}
789		771
790	aclnnStatus aclRfft1DGetWorkspaceSize(	772	aclnnStatus aclRfft1DGetWorkspaceSize(const aclTensor* self, int64_t n, int64_t dim, int64_t norm, aclTensor* out,
791	const aclTensor* self, int64_t n, int64_t dim, int64_t norm, aclTensor* out, uint64_t* workspaceSize,	773	uint64_t* workspaceSize, aclOpExecutor** executor)
792	aclOpExecutor** executor)
793	{	774	{
794	L2_DFX_PHASE_1(aclRfft1D, DFX_IN(self, n, norm), DFX_OUT(out));	775	L2_DFX_PHASE_1(aclRfft1D, DFX_IN(self, n, norm), DFX_OUT(out));
795	OP_LOGD("Rfft1D: n %ld, norm %ld", n, norm);	776	OP_LOGD("Rfft1D: n %ld, norm %ld", n, norm);
	@@ -867,4 +848,4 @@ aclnnStatus aclRfft1D(void* workspace, uint64_t workspaceSize, aclOpExecutor* ex
867	{	848	{
868	L2_DFX_PHASE_2(aclRfft1D);	849	L2_DFX_PHASE_2(aclRfft1D);
869	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	850	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
870	}	851	}

Rmath/rfft1_d/op_host/op_api/acl_rfft1d.h→math/rfft1_d/op_api/acl_rfft1d.h+7-8

	@@ -1,10 +1,10 @@
1	/**	1	/**
2	* Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This file is a part of the CANN Open Software.	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	* BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/	9	*/
10		10
	@@ -40,9 +40,8 @@ extern "C" {
40	* @return aclnnStatus: Return the status code.	40	* @return aclnnStatus: Return the status code.
41	*/	41	*/
42		42
43	aclnnStatus aclRfft1DGetWorkspaceSize(	43	aclnnStatus aclRfft1DGetWorkspaceSize(const aclTensor* self, int64_t n, int64_t dim, int64_t norm, aclTensor* out,
44	const aclTensor* self, int64_t n, int64_t dim, int64_t norm, aclTensor* out, uint64_t* workspaceSize,	44	uint64_t* workspaceSize, aclOpExecutor** executor);
45	aclOpExecutor** executor);
46		45
47	/**	46	/**
48	* @brief A second interface of aclRfft1D, used to perform calculation.	47	* @brief A second interface of aclRfft1D, used to perform calculation.

Rmath/rfft1_d/op_host/op_api/rfft1d.cpp→math/rfft1_d/op_api/rfft1d.cpp+15-16

	@@ -1,10 +1,10 @@
1	/**	1	/**
2	* Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This file is a part of the CANN Open Software.	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	* BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/	9	*/
10		10
	@@ -31,8 +31,7 @@ bool IsRfft1DAiCoreSupported(const aclTensor* self, int64_t n)
31	{	31	{
32	bool res = false;	32	bool res = false;
33		33
34	if ((GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910B \|\|	34	if ((GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910B \|\| IsRegBase() \|\|
35	IsRegBase() \|\|
36	GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910_93) &&	35	GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910_93) &&
37	(n <= UPPER_BORDER) && self->GetDataType() == op::DataType::DT_FLOAT) {	36	(n <= UPPER_BORDER) && self->GetDataType() == op::DataType::DT_FLOAT) {
38	res = true;	37	res = true;
	@@ -40,24 +39,24 @@ bool IsRfft1DAiCoreSupported(const aclTensor* self, int64_t n)
40	return res;	39	return res;
41	}	40	}
42		41
43	static const aclTensor* Rfft1DAiCore(	42	static const aclTensor* Rfft1DAiCore(const aclTensor* self, const aclTensor* dft, aclTensor* out, int64_t n,
44	const aclTensor* self, const aclTensor* dft, aclTensor* out, int64_t n, int64_t norm, aclOpExecutor* executor)	43	int64_t norm, aclOpExecutor* executor)
45	{	44	{
46	L0_DFX(Rfft1DAiCore, self, dft, n, norm, out);	45	L0_DFX(Rfft1DAiCore, self, dft, n, norm, out);
47		46
48	ADD_TO_LAUNCHER_LIST_AICORE(	47	ADD_TO_LAUNCHER_LIST_AICORE(Rfft1D, OP_ATTR_NAMES({"n", "norm"}), OP_INPUT(self, dft), OP_OUTPUT(out),
49	Rfft1D, OP_ATTR_NAMES({"n", "norm"}), OP_INPUT(self, dft), OP_OUTPUT(out), OP_ATTR(n, norm));	48	OP_ATTR(n, norm));
50	return out;	49	return out;
51	}	50	}
52		51
53	static const aclTensor* Rfft1DAiCpu(	52	static const aclTensor* Rfft1DAiCpu(const aclTensor* self, const aclTensor* dft, aclTensor* out, int64_t n,
54	const aclTensor* self, const aclTensor* dft, aclTensor* out, int64_t n, int64_t norm, aclOpExecutor* executor)	53	int64_t norm, aclOpExecutor* executor)
55	{	54	{
56	L0_DFX(Rfft1DAiCpu, self, dft, n, norm, out);	55	L0_DFX(Rfft1DAiCpu, self, dft, n, norm, out);
57		56
58	static internal::AicpuTaskSpace space("Rfft1D");	57	static internal::AicpuTaskSpace space("Rfft1D");
59	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(	58	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(Rfft1D, OP_ATTR_NAMES({"n", "norm"}), OP_INPUT(self, dft), OP_OUTPUT(out),
60	Rfft1D, OP_ATTR_NAMES({"n", "norm"}), OP_INPUT(self, dft), OP_OUTPUT(out), OP_ATTR(n, norm));	59	OP_ATTR(n, norm));
61	CHECK_RET(ret == ACLNN_SUCCESS, nullptr);	60	CHECK_RET(ret == ACLNN_SUCCESS, nullptr);
62	return out;	61	return out;
63	}	62	}
	@@ -94,4 +93,4 @@ const aclTensor* Rfft1D(const aclTensor* self, const aclTensor* dft, int64_t n,
94	}	93	}
95	}	94	}
96		95
97	} // namespace l0op	96	} // namespace l0op

Rmath/rfft1_d/op_host/op_api/rfft1d.h→math/rfft1_d/op_api/rfft1d.h+7-7

	@@ -1,10 +1,10 @@
1	/**	1	/**
2	* Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This file is a part of the CANN Open Software.	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	* BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/	9	*/
10		10
	@@ -16,6 +16,6 @@
16	namespace l0op {	16	namespace l0op {
17	bool IsRfft1DAiCoreSupported(const aclTensor* self, int64_t n);	17	bool IsRfft1DAiCoreSupported(const aclTensor* self, int64_t n);
18	const aclTensor* Rfft1D(const aclTensor* self, const aclTensor* dft, int64_t n, int64_t norm, aclOpExecutor* executor);	18	const aclTensor* Rfft1D(const aclTensor* self, const aclTensor* dft, int64_t n, int64_t norm, aclOpExecutor* executor);
19	} // namespace l0op	19	} // namespace l0op
20		20
21	#endif // OP_API_INC_LEVEL0_RFFT1D_H_	21	#endif // OP_API_INC_LEVEL0_RFFT1D_H_

Dmath/rfft1_d/op_host/CMakeLists.txt+0-11

	@@ -1,11 +0,0 @@
1	# This program is free software, you can redistribute it and/or modify it.
2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	# This file is a part of the CANN Open Software.
4	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. See LICENSE in the root of
8	# the software repository for the full text of the License.
9	# ============================================================================
10
11	add_modules_sources(OPTYPE rfft1_d ACLNNTYPE aclnn_exclude)

Dmath/rfft1_d/tests/CMakeLists.txt+0-16

	@@ -1,16 +0,0 @@
1	# This program is free software, you can redistribute it and/or modify it.
2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	# This file is a part of the CANN Open Software.
4	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. See LICENSE in the root of
8	# the software repository for the full text of the License.
9	# ============================================================================
10
11	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
12	foreach(SUB_DIR ${CURRENT_DIRS})
13	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
14	add_subdirectory(${SUB_DIR})
15	endif()
16	endforeach()

Dmath/rfft1_d/tests/ut/CMakeLists.txt+0-15

	@@ -1,15 +0,0 @@
1	# This program is free software, you can redistribute it and/or modify it.
2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	# This file is a part of the CANN Open Software.
4	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. See LICENSE in the root of
8	# the software repository for the full text of the License.
9	# ============================================================================
10	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
11	foreach(SUB_DIR ${CURRENT_DIRS})
12	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
13	add_subdirectory(${SUB_DIR})
14	endif()
15	endforeach()

Rmath/rfft1_d/tests/ut/op_host/op_api/test_aclnn_rfft1d.cpp→math/rfft1_d/tests/ut/op_api/test_aclnn_rfft1d.cpp+10-10

	@@ -1,12 +1,12 @@
1	// /**	1	/**
2	// * Copyright(c) Huawei Technologies Co., Ltd.2025. All rights reserved.	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	// * This File is a part of the CANN Open Software.	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	// * Licensed under CANN Open Software License Agreement Version 2.0 (the "License");	4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	// * Please refer to the Licence for details. You may not use this file except in compliance with the License.	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	// * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED,	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	// * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	// * See LICENSE in the root of the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
9	// */	9	*/
10		10
11	// #include <array>	11	// #include <array>
12	// #include <vector>	12	// #include <vector>
	@@ -180,4 +180,4 @@
180	// EXPECT_EQ(aclRet, ACL_SUCCESS);	180	// EXPECT_EQ(aclRet, ACL_SUCCESS);
181		181
182	// // ut.TestPrecision();	182	// // ut.TestPrecision();
183	// }	183	// }

Dmath/rfft1_d/tests/ut/op_host/CMakeLists.txt+0-21

	@@ -1,21 +0,0 @@
1	# This program is free software, you can redistribute it and/or modify it.
2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	# This file is a part of the CANN Open Software.
4	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. See LICENSE in the root of
8	# the software repository for the full text of the License.
9	# ============================================================================
10
11	if(UT_TEST_ALL OR OP_HOST_UT)
12	add_modules_ut_sources(UT_NAME ${OP_TILING_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
13	# add_modules_ut_sources(UT_NAME ${OP_INFERSHAPE_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
14	endif()
15
16	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
17	foreach(SUB_DIR ${CURRENT_DIRS})
18	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
19	add_subdirectory(${SUB_DIR})
20	endif()
21	endforeach()

Dmath/rfft1_d/tests/ut/op_host/op_api/CMakeLists.txt+0-13

	@@ -1,13 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
3	# This file is a part of the CANN Open Software.
4	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
5	# Please refer to the License for details. You may not use this file except in compliance with the License.
6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	# See LICENSE in the root of the software repository for the full text of the License.
9	# ----------------------------------------------------------------------------
10
11	if(UT_TEST_ALL OR OP_API_UT)
12	#add_modules_ut_sources(HOSTNAME ${OP_API_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
13	endif()

Mmath/sign_bits_pack/CMakeLists.txt+3-12

	@@ -1,20 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11		10
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE sign_bits_pack ACLNNTYPE aclnn_exclude)
13	if(NOT ENABLE_TEST AND NOT BENCHMARK)
14	list(REMOVE_ITEM CURRENT_DIRS tests)
15	endif()
16	foreach(SUB_DIR ${CURRENT_DIRS})
17	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
18	add_subdirectory(${SUB_DIR})
19	endif()
20	endforeach()

Rmath/sign_bits_pack/op_host/op_api/aclnn_sign_bits_pack.cpp→math/sign_bits_pack/op_api/aclnn_sign_bits_pack.cpp+28-28

	@@ -34,33 +34,32 @@ static const int64_t DIM_NUM_1D = 1;
34	static const int64_t DIM_NUM_2D = 2;	34	static const int64_t DIM_NUM_2D = 2;
35	static const int64_t PACK_SIZE = 8;	35	static const int64_t PACK_SIZE = 8;
36		36
37	static const std::initializer_list<op::DataType> SELF_DTYPE_SUPPORT_LIST = {	37	static const std::initializer_list<op::DataType> SELF_DTYPE_SUPPORT_LIST = {op::DataType::DT_FLOAT,
38	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16};	38	op::DataType::DT_FLOAT16};
39		39
40	static const std::initializer_list<op::DataType> OUT_DTYPE_SUPPORT_LIST = {	40	static const std::initializer_list<op::DataType> OUT_DTYPE_SUPPORT_LIST = {op::DataType::DT_UINT8};
41	op::DataType::DT_UINT8};
42		41
43	static bool CheckNotNullPtr(const aclTensor self, aclTensor out)	42	static bool CheckNotNullPtr(const aclTensor* self, aclTensor* out)
44	{	43	{
45	OP_CHECK_NULL(self, return false);	44	OP_CHECK_NULL(self, return false);
46	OP_CHECK_NULL(out, return false);	45	OP_CHECK_NULL(out, return false);
47	return true;	46	return true;
48	}	47	}
49		48
50	static inline bool CheckSocVersionIsSupport(void) {	49	static inline bool CheckSocVersionIsSupport(void)
51	return GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910B \|\|	50	{
52	GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND310P \|\|	51	return GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910B \|\|
53	GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910_93;	52	GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND310P \|\|
		53	GetCurrentPlatformInfo().GetSocVersion() == SocVersion::ASCEND910_93;
54	}	54	}
55		55
56	static bool CheckDtypeValid(const aclTensor self, const aclTensor out)	56	static bool CheckDtypeValid(const aclTensor* self, const aclTensor* out)
57	{	57	{
58	bool isSupport = CheckSocVersionIsSupport();	58	bool isSupport = CheckSocVersionIsSupport();
59	if(!isSupport) {	59	if (!isSupport) {
60	auto socVersion = GetCurrentPlatformInfo().GetSocVersion();	60	auto socVersion = GetCurrentPlatformInfo().GetSocVersion();
61	OP_LOGE(ACLNN_ERR_PARAM_INVALID,	61	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "SignBitsPack is unsupported by the current SOC version [%s]",
62	"SignBitsPack is unsupported by the current SOC version [%s]",	62	op::ToString(socVersion).GetString());
63	op::ToString(socVersion).GetString());
64	return false;	63	return false;
65	}	64	}
66	// 检查self的数据类型是否在支持列表内	65	// 检查self的数据类型是否在支持列表内
	@@ -71,32 +70,33 @@ static bool CheckDtypeValid(const aclTensor self, const aclTensor out)
71	return true;	70	return true;
72	}	71	}
73		72
74	static bool CheckFormat(const aclTensor self, const aclTensor out)	73	static bool CheckFormat(const aclTensor* self, const aclTensor* out)
75	{	74	{
76	// 检查self的format是否为ND	75	// 检查self的format是否为ND
77	if (self->GetStorageFormat() != Format::FORMAT_ND) {	76	if (self->GetStorageFormat() != Format::FORMAT_ND) {
78	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "self format should be ND. Actual: self is [%s].",	77	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "self format should be ND. Actual: self is [%s].",
79	op::ToString(self->GetStorageFormat()).GetString());	78	op::ToString(self->GetStorageFormat()).GetString());
80	return false;	79	return false;
81	}	80	}
82		81
83	// 检查out的format是否为ND	82	// 检查out的format是否为ND
84	if (out->GetStorageFormat() != Format::FORMAT_ND) {	83	if (out->GetStorageFormat() != Format::FORMAT_ND) {
85	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "out format should be ND. Actual: out is [%s].",	84	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "out format should be ND. Actual: out is [%s].",
86	op::ToString(out->GetStorageFormat()).GetString());	85	op::ToString(out->GetStorageFormat()).GetString());
87	return false;	86	return false;
88	}	87	}
89		88
90	// 如果输入格式是私有格式，记录日志，直接报错	89	// 如果输入格式是私有格式，记录日志，直接报错
91	if (op::IsPrivateFormat(self->GetStorageFormat())) {	90	if (op::IsPrivateFormat(self->GetStorageFormat())) {
92	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Not support format [%s].", op::ToString(self->GetStorageFormat()).GetString());	91	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Not support format [%s].",
		92	op::ToString(self->GetStorageFormat()).GetString());
93	return false;	93	return false;
94	}	94	}
95		95
96	return true;	96	return true;
97	}	97	}
98		98
99	static bool CheckShape(const aclTensor self, const aclTensor out)	99	static bool CheckShape(const aclTensor* self, const aclTensor* out)
100	{	100	{
101	size_t selfdimNum = self->GetViewShape().GetDimNum();	101	size_t selfdimNum = self->GetViewShape().GetDimNum();
102	if (selfdimNum != DIM_NUM_1D) {	102	if (selfdimNum != DIM_NUM_1D) {
	@@ -112,7 +112,7 @@ static bool CheckShape(const aclTensor self, const aclTensor out)
112	return true;	112	return true;
113	}	113	}
114		114
115	static bool CheckValue(const aclTensor self, int64_t size, const aclTensor out)	115	static bool CheckValue(const aclTensor* self, int64_t size, const aclTensor* out)
116	{	116	{
117	for (size_t i = 0; i < out->GetViewShape().GetDimNum(); i++) {	117	for (size_t i = 0; i < out->GetViewShape().GetDimNum(); i++) {
118	if (out->GetViewShape().GetDim(i) < 0) {	118	if (out->GetViewShape().GetDim(i) < 0) {
	@@ -123,20 +123,19 @@ static bool CheckValue(const aclTensor self, int64_t size, const aclTensor out
123		123
124	size_t selfdim = self->GetViewShape().GetDim(0);	124	size_t selfdim = self->GetViewShape().GetDim(0);
125	auto ysize = (selfdim + 7) / 8;	125	auto ysize = (selfdim + 7) / 8;
126	if(size <= 0)	126	if (size <= 0) {
127	{
128	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "size value must bigger zero.");	127	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "size value must bigger zero.");
129	return false;	128	return false;
130	}	129	}
131		130
132	if(size != 0 && ysize % size != 0){	131	if (size != 0 && ysize % size != 0) {
133	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "all must need be divisible by size");	132	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "all must need be divisible by size");
134	return false;	133	return false;
135	}	134	}
136	return true;	135	return true;
137	}	136	}
138		137
139	static aclnnStatus CheckParams(const aclTensor self, int64_t size, aclTensor out)	138	static aclnnStatus CheckParams(const aclTensor* self, int64_t size, aclTensor* out)
140	{	139	{
141	// 检查参数是否为空指针	140	// 检查参数是否为空指针
142	CHECK_RET(CheckNotNullPtr(self, out), ACLNN_ERR_PARAM_NULLPTR);	141	CHECK_RET(CheckNotNullPtr(self, out), ACLNN_ERR_PARAM_NULLPTR);
	@@ -156,7 +155,8 @@ static aclnnStatus CheckParams(const aclTensor self, int64_t size, aclTensor o
156	return ACLNN_SUCCESS;	155	return ACLNN_SUCCESS;
157	}	156	}
158		157
159	aclnnStatus aclnnSignBitsPackGetWorkspaceSize(const aclTensor self, int64_t size, aclTensor out, uint64_t workspaceSize, aclOpExecutor *executor)	158	aclnnStatus aclnnSignBitsPackGetWorkspaceSize(const aclTensor* self, int64_t size, aclTensor* out,
		159	uint64_t* workspaceSize, aclOpExecutor** executor)
160	{	160	{
161	L2_DFX_PHASE_1(aclnnSignBitsPack, DFX_IN(self, size), DFX_OUT(out));	161	L2_DFX_PHASE_1(aclnnSignBitsPack, DFX_IN(self, size), DFX_OUT(out));
162		162
	@@ -178,7 +178,7 @@ aclnnStatus aclnnSignBitsPackGetWorkspaceSize(const aclTensor *self, int64_t siz
178	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());	178	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
179	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);	179	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
180		180
181	const aclTensor *calcOut = nullptr;	181	const aclTensor* calcOut = nullptr;
182	calcOut = l0op::SignBitsPack(selfContiguous, size, uniqueExecutor.get());	182	calcOut = l0op::SignBitsPack(selfContiguous, size, uniqueExecutor.get());
183	CHECK_RET(calcOut != nullptr, ACLNN_ERR_PARAM_NULLPTR);	183	CHECK_RET(calcOut != nullptr, ACLNN_ERR_PARAM_NULLPTR);
184		184
	@@ -193,7 +193,7 @@ aclnnStatus aclnnSignBitsPackGetWorkspaceSize(const aclTensor *self, int64_t siz
193	return ACLNN_SUCCESS;	193	return ACLNN_SUCCESS;
194	}	194	}
195		195
196	aclnnStatus aclnnSignBitsPack(void workspace, uint64_t workspaceSize, aclOpExecutor executor, aclrtStream stream)	196	aclnnStatus aclnnSignBitsPack(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
197	{	197	{
198	L2_DFX_PHASE_2(aclnnSignBitsPack);	198	L2_DFX_PHASE_2(aclnnSignBitsPack);
199	// 固定写法，调用框架能力，完成计算	199	// 固定写法，调用框架能力，完成计算

Rmath/sign_bits_pack/op_host/op_api/aclnn_sign_bits_pack.h→math/sign_bits_pack/op_api/aclnn_sign_bits_pack.h+5-4

	@@ -32,8 +32,8 @@ extern "C" {
32	* @param [out] executor: 返回op执行器，包含算子计算流程。	32	* @param [out] executor: 返回op执行器，包含算子计算流程。
33	* @return aclnnStatus: 返回状态码。	33	* @return aclnnStatus: 返回状态码。
34	*/	34	*/
35	ACLNN_API aclnnStatus aclnnSignBitsPackGetWorkspaceSize(const aclTensor* self, int64_t size,	35	ACLNN_API aclnnStatus aclnnSignBitsPackGetWorkspaceSize(const aclTensor* self, int64_t size, aclTensor* out,
36	aclTensor* out, uint64_t* workspaceSize, aclOpExecutor** executor);	36	uint64_t* workspaceSize, aclOpExecutor** executor);
37		37
38	/**	38	/**
39	* @brief aclnnSignBitsPack的第二段接口，用于执行计算。	39	* @brief aclnnSignBitsPack的第二段接口，用于执行计算。
	@@ -43,10 +43,11 @@ ACLNN_API aclnnStatus aclnnSignBitsPackGetWorkspaceSize(const aclTensor* self, i
43	* @param [in] stream: acl stream流。	43	* @param [in] stream: acl stream流。
44	* @return aclnnStatus: 返回状态码。	44	* @return aclnnStatus: 返回状态码。
45	*/	45	*/
46	ACLNN_API aclnnStatus aclnnSignBitsPack(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream);	46	ACLNN_API aclnnStatus aclnnSignBitsPack(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor,
		47	aclrtStream stream);
47		48
48	#ifdef __cplusplus	49	#ifdef __cplusplus
49	}	50	}
50	#endif	51	#endif
51		52
52	#endif // OP_API_INC_SIGNBITSPACK_H_	53	#endif // OP_API_INC_SIGNBITSPACK_H_

Rmath/sign_bits_pack/op_host/op_api/sign_bits_pack.cpp→math/sign_bits_pack/op_api/sign_bits_pack.cpp+23-22

	@@ -18,29 +18,30 @@ namespace l0op {
18	OP_TYPE_REGISTER(SignBitsPack);	18	OP_TYPE_REGISTER(SignBitsPack);
19	static constexpr size_t OUT_DIM = 2;	19	static constexpr size_t OUT_DIM = 2;
20		20
21	const aclTensor* SignBitsPack(const aclTensor* self, int64_t size,aclOpExecutor* executor) {	21	const aclTensor* SignBitsPack(const aclTensor* self, int64_t size, aclOpExecutor* executor)
22	L0_DFX(SignBitsPack, self, size);	22	{
23		23	L0_DFX(SignBitsPack, self, size);
24	int64_t selfDimOne = self->GetViewShape().GetDim(0);
25	int64_t outDimTwo = 0;
26		24
27	auto ysize = (selfDimOne + 7) / 8;	25	int64_t selfDimOne = self->GetViewShape().GetDim(0);
28	if(size != 0)	26	int64_t outDimTwo = 0;
29	{
30	outDimTwo = ysize / size;
31	}
32
33	op::Shape outShape;
34	outShape.SetDimNum(OUT_DIM);
35	outShape.SetDim(0, size);
36	outShape.SetDim(1, outDimTwo);
37		27
38	auto out = executor->AllocTensor(outShape, op::DataType::DT_UINT8, op::Format::FORMAT_ND);	28	auto ysize = (selfDimOne + 7) / 8;
39	CHECK_RET(out != nullptr, nullptr);	29	if (size != 0) {
		30	outDimTwo = ysize / size;
		31	}
40		32
41	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(SignBitsPack, OP_INPUT(self), OP_OUTPUT(out), OP_ATTR(size));	33	op::Shape outShape;
42	OP_CHECK(ret == ACLNN_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "SignBitsPackAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."),	34	outShape.SetDimNum(OUT_DIM);
43	return nullptr);	35	outShape.SetDim(0, size);
44	return out;	36	outShape.SetDim(1, outDimTwo);
		37
		38	auto out = executor->AllocTensor(outShape, op::DataType::DT_UINT8, op::Format::FORMAT_ND);
		39	CHECK_RET(out != nullptr, nullptr);
		40
		41	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(SignBitsPack, OP_INPUT(self), OP_OUTPUT(out), OP_ATTR(size));
		42	OP_CHECK(ret == ACLNN_SUCCESS,
		43	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "SignBitsPackAiCore ADD_TO_LAUNCHER_LIST_AICORE failed."),
		44	return nullptr);
		45	return out;
45	}	46	}
46	} // namespace l0op	47	} // namespace l0op

Rmath/sign_bits_pack/op_host/op_api/sign_bits_pack.h→math/sign_bits_pack/op_api/sign_bits_pack.h+2-2

	@@ -13,7 +13,7 @@
13	#include "opdev/op_executor.h"	13	#include "opdev/op_executor.h"
14		14
15	namespace l0op {	15	namespace l0op {
16	const aclTensor SignBitsPack(const aclTensor self, int64_t size, aclOpExecutor *executor);	16	const aclTensor* SignBitsPack(const aclTensor* self, int64_t size, aclOpExecutor* executor);
17	}	17	}
18		18
19	#endif // OP_API_INC_LEVEL0_SIGNBITSPACK_H_OP	19	#endif // OP_API_INC_LEVEL0_SIGNBITSPACK_H_OP

Dmath/sign_bits_pack/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources(OPTYPE sign_bits_pack ACLNNTYPE aclnn_exclude)

Dmath/sign_bits_pack/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/sign_bits_pack/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Rmath/sign_bits_pack/tests/ut/op_host/op_api/test_aclnn_sign_bits_pack.cpp→math/sign_bits_pack/tests/ut/op_api/test_aclnn_sign_bits_pack.cpp+36-52

	@@ -14,7 +14,7 @@
14	#include <vector>	14	#include <vector>
15		15
16	#include "gtest/gtest.h"	16	#include "gtest/gtest.h"
17	#include "aclnn_sign_bits_pack.h"	17	#include "../../../op_api/aclnn_sign_bits_pack.h"
18	#include "op_api_ut_common/op_api_ut.h"	18	#include "op_api_ut_common/op_api_ut.h"
19	#include "op_api_ut_common/scalar_desc.h"	19	#include "op_api_ut_common/scalar_desc.h"
20	#include "op_api_ut_common/tensor_desc.h"	20	#include "op_api_ut_common/tensor_desc.h"
	@@ -22,17 +22,16 @@
22	using namespace std;	22	using namespace std;
23		23
24	class sign_bits_pack_test : public testing::Test {	24	class sign_bits_pack_test : public testing::Test {
25	protected:	25	protected:
26	static void SetUpTestCase() { cout << "sign_test SetUp" << endl; }	26	static void SetUpTestCase() { cout << "sign_test SetUp" << endl; }
27		27
28	static void TearDownTestCase() { cout << "sign_test TeastDown" << endl; }	28	static void TearDownTestCase() { cout << "sign_test TeastDown" << endl; }
29	};	29	};
30		30
31
32	// CheckNotNull self	31	// CheckNotNull self
33	TEST_F(sign_bits_pack_test, ascend910B2_case_null_self)	32	TEST_F(sign_bits_pack_test, ascend910B2_case_null_self)
34	{	33	{
35	int64_t size = 2;	34	int64_t size = 2;
36	auto tensor_desc = TensorDesc({10}, ACL_FLOAT, ACL_FORMAT_ND);	35	auto tensor_desc = TensorDesc({10}, ACL_FLOAT, ACL_FORMAT_ND);
37	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(nullptr, size), OUTPUT(tensor_desc));	36	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(nullptr, size), OUTPUT(tensor_desc));
38		37
	@@ -43,9 +42,9 @@ TEST_F(sign_bits_pack_test, ascend910B2_case_null_self)
43		42
44	// CheckNotNull out	43	// CheckNotNull out
45	TEST_F(sign_bits_pack_test, ascend910B2_case_null_out)	44	TEST_F(sign_bits_pack_test, ascend910B2_case_null_out)
46	{	45	{
47	int64_t size = 2;	46	int64_t size = 2;
48	auto tensor_desc = TensorDesc({1,2}, ACL_UINT8, ACL_FORMAT_ND);	47	auto tensor_desc = TensorDesc({1, 2}, ACL_UINT8, ACL_FORMAT_ND);
49	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(tensor_desc, size), OUTPUT(nullptr));	48	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(tensor_desc, size), OUTPUT(nullptr));
50		49
51	uint64_t workspaceSize = 0;	50	uint64_t workspaceSize = 0;
	@@ -55,10 +54,10 @@ TEST_F(sign_bits_pack_test, ascend910B2_case_null_out)
55		54
56	// CheckDtypeVaild self	55	// CheckDtypeVaild self
57	TEST_F(sign_bits_pack_test, ascend910B2_case_vaild_self)	56	TEST_F(sign_bits_pack_test, ascend910B2_case_vaild_self)
58	{	57	{
59	int64_t size = 2;	58	int64_t size = 2;
60	auto self_tensor_desc = TensorDesc({14}, ACL_UINT8, ACL_FORMAT_ND);	59	auto self_tensor_desc = TensorDesc({14}, ACL_UINT8, ACL_FORMAT_ND);
61	auto out_tensor_desc = TensorDesc({2,1}, ACL_UINT8, ACL_FORMAT_ND);	60	auto out_tensor_desc = TensorDesc({2, 1}, ACL_UINT8, ACL_FORMAT_ND);
62	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));	61	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));
63		62
64	uint64_t workspaceSize = 0;	63	uint64_t workspaceSize = 0;
	@@ -68,10 +67,10 @@ TEST_F(sign_bits_pack_test, ascend910B2_case_vaild_self)
68		67
69	// CheckDtypeVaild out	68	// CheckDtypeVaild out
70	TEST_F(sign_bits_pack_test, ascend910B2_case_vaild_out)	69	TEST_F(sign_bits_pack_test, ascend910B2_case_vaild_out)
71	{	70	{
72	int64_t size = 2;	71	int64_t size = 2;
73	auto self_tensor_desc = TensorDesc({14}, ACL_FLOAT, ACL_FORMAT_ND);	72	auto self_tensor_desc = TensorDesc({14}, ACL_FLOAT, ACL_FORMAT_ND);
74	auto out_tensor_desc = TensorDesc({2,1}, ACL_FLOAT, ACL_FORMAT_ND);	73	auto out_tensor_desc = TensorDesc({2, 1}, ACL_FLOAT, ACL_FORMAT_ND);
75	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));	74	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));
76		75
77	uint64_t workspaceSize = 0;	76	uint64_t workspaceSize = 0;
	@@ -81,10 +80,10 @@ TEST_F(sign_bits_pack_test, ascend910B2_case_vaild_out)
81		80
82	// CheckValue size	81	// CheckValue size
83	TEST_F(sign_bits_pack_test, ascend910B2_case_value_size)	82	TEST_F(sign_bits_pack_test, ascend910B2_case_value_size)
84	{	83	{
85	int64_t size = 0;	84	int64_t size = 0;
86	auto self_tensor_desc = TensorDesc({14}, ACL_FLOAT, ACL_FORMAT_ND);	85	auto self_tensor_desc = TensorDesc({14}, ACL_FLOAT, ACL_FORMAT_ND);
87	auto out_tensor_desc = TensorDesc({2,1}, ACL_UINT8, ACL_FORMAT_ND);	86	auto out_tensor_desc = TensorDesc({2, 1}, ACL_UINT8, ACL_FORMAT_ND);
88	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));	87	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));
89		88
90	uint64_t workspaceSize = 0;	89	uint64_t workspaceSize = 0;
	@@ -92,12 +91,12 @@ TEST_F(sign_bits_pack_test, ascend910B2_case_value_size)
92	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);	91	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
93	}	92	}
94		93
95	// CheckValue size	94	// CheckValue size
96	TEST_F(sign_bits_pack_test, ascend910B2_case_value_size2)	95	TEST_F(sign_bits_pack_test, ascend910B2_case_value_size2)
97	{	96	{
98	int64_t size = 3;	97	int64_t size = 3;
99	auto self_tensor_desc = TensorDesc({14}, ACL_FLOAT, ACL_FORMAT_ND);	98	auto self_tensor_desc = TensorDesc({14}, ACL_FLOAT, ACL_FORMAT_ND);
100	auto out_tensor_desc = TensorDesc({3,1}, ACL_UINT8, ACL_FORMAT_ND);	99	auto out_tensor_desc = TensorDesc({3, 1}, ACL_UINT8, ACL_FORMAT_ND);
101	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));	100	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));
102		101
103	uint64_t workspaceSize = 0;	102	uint64_t workspaceSize = 0;
	@@ -105,12 +104,12 @@ TEST_F(sign_bits_pack_test, ascend910B2_case_value_size2)
105	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);	104	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
106	}	105	}
107		106
108	// CheckValue shape	107	// CheckValue shape
109	TEST_F(sign_bits_pack_test, ascend910B2_case_shape_self)	108	TEST_F(sign_bits_pack_test, ascend910B2_case_shape_self)
110	{	109	{
111	int64_t size = 2;	110	int64_t size = 2;
112	auto self_tensor_desc = TensorDesc({16,2}, ACL_FLOAT, ACL_FORMAT_ND);	111	auto self_tensor_desc = TensorDesc({16, 2}, ACL_FLOAT, ACL_FORMAT_ND);
113	auto out_tensor_desc = TensorDesc({3,1}, ACL_UINT8, ACL_FORMAT_ND);	112	auto out_tensor_desc = TensorDesc({3, 1}, ACL_UINT8, ACL_FORMAT_ND);
114	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));	113	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));
115		114
116	uint64_t workspaceSize = 0;	115	uint64_t workspaceSize = 0;
	@@ -118,10 +117,10 @@ TEST_F(sign_bits_pack_test, ascend910B2_case_shape_self)
118	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);	117	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
119	}	118	}
120		119
121	// CheckValue shape	120	// CheckValue shape
122	TEST_F(sign_bits_pack_test, ascend910B2_case_shape_out)	121	TEST_F(sign_bits_pack_test, ascend910B2_case_shape_out)
123	{	122	{
124	int64_t size = 2;	123	int64_t size = 2;
125	auto self_tensor_desc = TensorDesc({16}, ACL_FLOAT, ACL_FORMAT_ND);	124	auto self_tensor_desc = TensorDesc({16}, ACL_FLOAT, ACL_FORMAT_ND);
126	auto out_tensor_desc = TensorDesc({3}, ACL_UINT8, ACL_FORMAT_ND);	125	auto out_tensor_desc = TensorDesc({3}, ACL_UINT8, ACL_FORMAT_ND);
127	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));	126	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));
	@@ -134,9 +133,9 @@ TEST_F(sign_bits_pack_test, ascend910B2_case_shape_out)
134	// Check empty_tensor	133	// Check empty_tensor
135	TEST_F(sign_bits_pack_test, ascend910B2_case_float_empty_tensor)	134	TEST_F(sign_bits_pack_test, ascend910B2_case_float_empty_tensor)
136	{	135	{
137	int64_t size = 2;	136	int64_t size = 2;
138	auto self_tensor_desc = TensorDesc({0}, ACL_FLOAT16, ACL_FORMAT_ND);	137	auto self_tensor_desc = TensorDesc({0}, ACL_FLOAT16, ACL_FORMAT_ND);
139	auto out_tensor_desc = TensorDesc({2,0}, ACL_UINT8, ACL_FORMAT_ND);	138	auto out_tensor_desc = TensorDesc({2, 0}, ACL_UINT8, ACL_FORMAT_ND);
140	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));	139	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));
141		140
142	uint64_t workspaceSize = 0;	141	uint64_t workspaceSize = 0;
	@@ -144,25 +143,12 @@ TEST_F(sign_bits_pack_test, ascend910B2_case_float_empty_tensor)
144	EXPECT_EQ(aclRet, ACL_SUCCESS);	143	EXPECT_EQ(aclRet, ACL_SUCCESS);
145	}	144	}
146		145
147	//not 910B
148	TEST_F(sign_bits_pack_test, case_float_float16)
149	{
150	int64_t size = 2;
151	auto self_tensor_desc = TensorDesc({16}, ACL_FLOAT16, ACL_FORMAT_ND);
152	auto out_tensor_desc = TensorDesc({2,1}, ACL_UINT8, ACL_FORMAT_ND);
153	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));
154
155	uint64_t workspaceSize = 0;
156	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
157	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
158	}
159
160	// Checkfloat_float16	146	// Checkfloat_float16
161	TEST_F(sign_bits_pack_test, ascend910B2_case_float_float16)	147	TEST_F(sign_bits_pack_test, ascend910B2_case_float_float16)
162	{	148	{
163	int64_t size = 2;	149	int64_t size = 2;
164	auto self_tensor_desc = TensorDesc({16}, ACL_FLOAT16, ACL_FORMAT_ND);	150	auto self_tensor_desc = TensorDesc({16}, ACL_FLOAT16, ACL_FORMAT_ND);
165	auto out_tensor_desc = TensorDesc({2,1}, ACL_UINT8, ACL_FORMAT_ND);	151	auto out_tensor_desc = TensorDesc({2, 1}, ACL_UINT8, ACL_FORMAT_ND);
166	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));	152	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));
167		153
168	uint64_t workspaceSize = 0;	154	uint64_t workspaceSize = 0;
	@@ -173,14 +159,12 @@ TEST_F(sign_bits_pack_test, ascend910B2_case_float_float16)
173	// Checkfloat_float	159	// Checkfloat_float
174	TEST_F(sign_bits_pack_test, ascend910B2_case_float_float)	160	TEST_F(sign_bits_pack_test, ascend910B2_case_float_float)
175	{	161	{
176	int64_t size = 2;	162	int64_t size = 2;
177	auto self_tensor_desc = TensorDesc({16}, ACL_FLOAT, ACL_FORMAT_ND);	163	auto self_tensor_desc = TensorDesc({16}, ACL_FLOAT, ACL_FORMAT_ND);
178	auto out_tensor_desc = TensorDesc({2,1}, ACL_UINT8, ACL_FORMAT_ND);	164	auto out_tensor_desc = TensorDesc({2, 1}, ACL_UINT8, ACL_FORMAT_ND);
179	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));	165	auto ut = OP_API_UT(aclnnSignBitsPack, INPUT(self_tensor_desc, size), OUTPUT(out_tensor_desc));
180		166
181	uint64_t workspaceSize = 0;	167	uint64_t workspaceSize = 0;
182	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);	168	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
183	EXPECT_EQ(aclRet, ACL_SUCCESS);	169	EXPECT_EQ(aclRet, ACL_SUCCESS);
184	}	170	}
185
186

Dmath/sign_bits_pack/tests/ut/op_host/CMakeLists.txt+0-19

	@@ -1,19 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
12	foreach(SUB_DIR ${CURRENT_DIRS})
13	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
14	add_subdirectory(${SUB_DIR})
15	endif()
16	endforeach()
17
18	if(OP_API_UT OR (UT_TEST_ALL AND NOT AICPU_ONLY))
19	endif()

Dmath/sign_bits_pack/tests/ut/op_host/op_api/CMakeLists.txt+0-11

	@@ -1,11 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11

Mmath/sign_bits_unpack/CMakeLists.txt+3-12

	@@ -1,20 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11		10
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE sign_bits_unpack ACLNNTYPE aclnn_exclude)
13	if(NOT ENABLE_TEST AND NOT BENCHMARK)
14	list(REMOVE_ITEM CURRENT_DIRS tests)
15	endif()
16	foreach(SUB_DIR ${CURRENT_DIRS})
17	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
18	add_subdirectory(${SUB_DIR})
19	endif()
20	endforeach()

Rmath/sign_bits_unpack/op_host/op_api/aclnn_sign_bits_unpack.cpp→math/sign_bits_unpack/op_api/aclnn_sign_bits_unpack.cpp+75-67

	@@ -48,22 +48,23 @@ static const size_t DIM_NUM_2D = 2;
48	static const int64_t PACK_SIZE = 8;	48	static const int64_t PACK_SIZE = 8;
49		49
50	// 根据API定义，需要列出所能支持的所有dtype	50	// 根据API定义，需要列出所能支持的所有dtype
51	static const std::initializer_list<op::DataType> SELF_DTYPE_SUPPORT_LIST = {	51	static const std::initializer_list<op::DataType> SELF_DTYPE_SUPPORT_LIST = {op::DataType::DT_UINT8};
52	op::DataType::DT_UINT8};
53		52
54	static const std::initializer_list<op::DataType> OUT_DTYPE_SUPPORT_LIST = {	53	static const std::initializer_list<op::DataType> OUT_DTYPE_SUPPORT_LIST = {op::DataType::DT_FLOAT,
55	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16};	54	op::DataType::DT_FLOAT16};
56		55
57	static bool CheckNotNull(const aclTensor self, const aclTensor out) {	56	static bool CheckNotNull(const aclTensor* self, const aclTensor* out)
		57	{
58	// 检查输入和输出是否是空指针	58	// 检查输入和输出是否是空指针
59	OP_CHECK_NULL(self, return false);	59	OP_CHECK_NULL(self, return false);
60	OP_CHECK_NULL(out, return false);	60	OP_CHECK_NULL(out, return false);
61	return true;	61	return true;
62	}	62	}
63		63
64	static bool CheckDtypeValid(const aclTensor self, const aclTensor out, aclDataType dtype) {	64	static bool CheckDtypeValid(const aclTensor* self, const aclTensor* out, aclDataType dtype)
		65	{
65	// 检查芯片类型是否支持	66	// 检查芯片类型是否支持
66	if(GetCurrentPlatformInfo().GetSocVersion() != SocVersion::ASCEND310P &&	67	if (GetCurrentPlatformInfo().GetSocVersion() != SocVersion::ASCEND310P &&
67	GetCurrentPlatformInfo().GetSocVersion() != SocVersion::ASCEND910B &&	68	GetCurrentPlatformInfo().GetSocVersion() != SocVersion::ASCEND910B &&
68	GetCurrentPlatformInfo().GetSocVersion() != SocVersion::ASCEND910_93) {	69	GetCurrentPlatformInfo().GetSocVersion() != SocVersion::ASCEND910_93) {
69	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "SignBitsUnpack is not supported on this device.");	70	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "SignBitsUnpack is not supported on this device.");
	@@ -83,23 +84,24 @@ static bool CheckDtypeValid(const aclTensor self, const aclTensor out, aclData
83	return true;	84	return true;
84	}	85	}
85		86
86	static bool CheckFormat(const aclTensor self, const aclTensor out) {	87	static bool CheckFormat(const aclTensor* self, const aclTensor* out)
		88	{
87	// 检查self的format是否为ND	89	// 检查self的format是否为ND
88	if(self->GetStorageFormat() != Format::FORMAT_ND) {	90	if (self->GetStorageFormat() != Format::FORMAT_ND) {
89	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "self fromat should be ND. Actual: self is [%s].",	91	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "self fromat should be ND. Actual: self is [%s].",
90	op::ToString(self->GetStorageFormat()).GetString());	92	op::ToString(self->GetStorageFormat()).GetString());
91	return false;	93	return false;
92	}	94	}
93		95
94	// 检查out的format是否为ND	96	// 检查out的format是否为ND
95	if(out->GetStorageFormat() != Format::FORMAT_ND) {	97	if (out->GetStorageFormat() != Format::FORMAT_ND) {
96	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "out fromat should be ND. Actual: out is [%s].",	98	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "out fromat should be ND. Actual: out is [%s].",
97	op::ToString(out->GetStorageFormat()).GetString());	99	op::ToString(out->GetStorageFormat()).GetString());
98	return false;	100	return false;
99	}	101	}
100		102
101	// 如果输入格式是私有格式，记录日志，直接报错	103	// 如果输入格式是私有格式，记录日志，直接报错
102	if(op::IsPrivateFormat(self->GetStorageFormat())) {	104	if (op::IsPrivateFormat(self->GetStorageFormat())) {
103	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Not support format [%s].",	105	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Not support format [%s].",
104	op::ToString(self->GetStorageFormat()).GetString());	106	op::ToString(self->GetStorageFormat()).GetString());
105	return false;	107	return false;
	@@ -108,32 +110,34 @@ static bool CheckFormat(const aclTensor self, const aclTensor out) {
108	return true;	110	return true;
109	}	111	}
110		112
111	static inline bool CheckShape(const aclTensor self, const aclTensor out) {	113	static inline bool CheckShape(const aclTensor* self, const aclTensor* out)
		114	{
112	// 检查输入shape	115	// 检查输入shape
113	size_t selfDimNum = self->GetViewShape().GetDimNum();	116	size_t selfDimNum = self->GetViewShape().GetDimNum();
114	if(selfDimNum != DIM_NUM_1D) {	117	if (selfDimNum != DIM_NUM_1D) {
115	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Self dims %zu should be 1.", selfDimNum);	118	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Self dims %zu should be 1.", selfDimNum);
116	return false;	119	return false;
117	}	120	}
118		121
119	// 检查输出shape	122	// 检查输出shape
120	size_t outDimNum = out->GetViewShape().GetDimNum();	123	size_t outDimNum = out->GetViewShape().GetDimNum();
121	if(outDimNum != DIM_NUM_2D) {	124	if (outDimNum != DIM_NUM_2D) {
122	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Out dims %zu should be 2.", outDimNum);	125	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Out dims %zu should be 2.", outDimNum);
123	return false;	126	return false;
124	}	127	}
125	return true;	128	return true;
126	}	129	}
127		130
128	static inline bool CheckValue(const aclTensor self, int64_t size, const aclTensor out) {	131	static inline bool CheckValue(const aclTensor* self, int64_t size, const aclTensor* out)
		132	{
129	// 检查size的值	133	// 检查size的值
130	if(size <= 0) {	134	if (size <= 0) {
131	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Size value must bigger than zero.");	135	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Size value must bigger than zero.");
132	return false;	136	return false;
133	}	137	}
134		138
135	for(size_t i = 0; i < out->GetViewShape().GetDimNum(); i++) {	139	for (size_t i = 0; i < out->GetViewShape().GetDimNum(); i++) {
136	if(out->GetViewShape().GetDim(i) < 0) {	140	if (out->GetViewShape().GetDim(i) < 0) {
137	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dim Value of out is negative.");	141	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Dim Value of out is negative.");
138	return false;	142	return false;
139	}	143	}
	@@ -141,80 +145,84 @@ static inline bool CheckValue(const aclTensor *self, int64_t size, const aclTens
141		145
142	// size可被uint8的拆包输出整除。输出大小为（self的元素个数) * 8	146	// size可被uint8的拆包输出整除。输出大小为（self的元素个数) * 8
143	int64_t selfDim = self->GetViewShape().GetDim(0);	147	int64_t selfDim = self->GetViewShape().GetDim(0);
144	if((selfDim * PACK_SIZE) % size != 0) {	148	if ((selfDim * PACK_SIZE) % size != 0) {
145	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The number of elements in self * 8 cannot be divided by size.");	149	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The number of elements in self * 8 cannot be divided by size.");
146	return false;	150	return false;
147	}	151	}
148		152
149	// 检查out第一维度是否等于size	153	// 检查out第一维度是否等于size
150	int64_t outDimOneNum = out->GetViewShape().GetDim(0);	154	int64_t outDimOneNum = out->GetViewShape().GetDim(0);
151	if(size != outDimOneNum) {	155	if (size != outDimOneNum) {
152	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The value of the first dimension of 'out' is incorrect and should be equal to size.");	156	OP_LOGE(ACLNN_ERR_PARAM_INVALID,
		157	"The value of the first dimension of 'out' is incorrect and should be equal to size.");
153	return false;	158	return false;
154	}	159	}
155	return true;	160	return true;
156	}	161	}
157		162
158	static inline aclnnStatus CheckParams(const aclTensor self, aclDataType dtype, int64_t size, const aclTensor out) {	163	static inline aclnnStatus CheckParams(const aclTensor* self, aclDataType dtype, int64_t size, const aclTensor* out)
159	// 1. 检查参数是否为空指针	164	{
160	CHECK_RET(CheckNotNull(self, out), ACLNN_ERR_PARAM_NULLPTR);	165	// 1. 检查参数是否为空指针
		166	CHECK_RET(CheckNotNull(self, out), ACLNN_ERR_PARAM_NULLPTR);
161		167
162	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验	168	// 2. 检查输入的数据类型是否在API支持的数据类型范围之内，需要根据api定义校验
163	CHECK_RET(CheckDtypeValid(self, out, dtype), ACLNN_ERR_PARAM_INVALID);	169	CHECK_RET(CheckDtypeValid(self, out, dtype), ACLNN_ERR_PARAM_INVALID);
164		170
165	// 3. 检查数据格式是否支持	171	// 3. 检查数据格式是否支持
166	CHECK_RET(CheckFormat(self, out), ACLNN_ERR_PARAM_INVALID);	172	CHECK_RET(CheckFormat(self, out), ACLNN_ERR_PARAM_INVALID);
167		173
168	// 4. 检查入参数值是否合法	174	// 4. 检查入参数值是否合法
169	CHECK_RET(CheckValue(self, size, out), ACLNN_ERR_PARAM_INVALID);	175	CHECK_RET(CheckValue(self, size, out), ACLNN_ERR_PARAM_INVALID);
170		176
171	// 5. 检查输入和输出tensor的shape是否为异常，输入必须1维	177	// 5. 检查输入和输出tensor的shape是否为异常，输入必须1维
172	CHECK_RET(CheckShape(self, out), ACLNN_ERR_PARAM_INVALID);	178	CHECK_RET(CheckShape(self, out), ACLNN_ERR_PARAM_INVALID);
173		179
174	return ACLNN_SUCCESS;	180	return ACLNN_SUCCESS;
175	}	181	}
176		182
177	aclnnStatus aclnnSignBitsUnpackGetWorkspaceSize(const aclTensor* self, int64_t size, aclDataType dtype, aclTensor* out,	183	aclnnStatus aclnnSignBitsUnpackGetWorkspaceSize(const aclTensor* self, int64_t size, aclDataType dtype, aclTensor* out,
178	uint64_t* workspaceSize, aclOpExecutor** executor) {	184	uint64_t* workspaceSize, aclOpExecutor** executor)
179	L2_DFX_PHASE_1(aclnnSignBitsUnpack, DFX_IN(self, size, dtype), DFX_OUT(out));	185	{
		186	L2_DFX_PHASE_1(aclnnSignBitsUnpack, DFX_IN(self, size, dtype), DFX_OUT(out));
180		187
181	// 固定写法，创建OpExecutor	188	// 固定写法，创建OpExecutor
182	auto uniqueExecutor = CREATE_EXECUTOR();	189	auto uniqueExecutor = CREATE_EXECUTOR();
183	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);	190	CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
184		191
185	// 固定写法，参数检查	192	// 固定写法，参数检查
186	auto ret = CheckParams(self, dtype, size, out);	193	auto ret = CheckParams(self, dtype, size, out);
187	CHECK_RET(ret == ACLNN_SUCCESS, ret);	194	CHECK_RET(ret == ACLNN_SUCCESS, ret);
188		195
189	// 输入为空tensor时，直接返回dtype类型的空tensor	196	// 输入为空tensor时，直接返回dtype类型的空tensor
190	if (self->IsEmpty() \|\| out->IsEmpty()) {	197	if (self->IsEmpty() \|\| out->IsEmpty()) {
191	*workspaceSize = 0;	198	*workspaceSize = 0;
		199	uniqueExecutor.ReleaseTo(executor);
		200	return ACLNN_SUCCESS;
		201	}
		202
		203	// 固定写法，将输入self转换成连续的tensor
		204	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
		205	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
		206
		207	// 调用SignBitsUnpack算子kernel,将输入self的数据类型转换成指定的数据类型
		208	auto castOut = l0op::SignBitsUnpack(selfContiguous, size, op::ToOpDataType(dtype), uniqueExecutor.get());
		209	CHECK_RET(castOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
		210
		211	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor
		212	auto viewCopyResult = l0op::ViewCopy(castOut, out, uniqueExecutor.get());
		213	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
		214
		215	// 固定写法，获取计算过程中需要使用的workspace大小
		216	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
192	uniqueExecutor.ReleaseTo(executor);	217	uniqueExecutor.ReleaseTo(executor);
193	return ACLNN_SUCCESS;	218	return ACLNN_SUCCESS;
194	}
195
196	// 固定写法，将输入self转换成连续的tensor
197	auto selfContiguous = l0op::Contiguous(self, uniqueExecutor.get());
198	CHECK_RET(selfContiguous != nullptr, ACLNN_ERR_INNER_NULLPTR);
199
200	// 调用SignBitsUnpack算子kernel,将输入self的数据类型转换成指定的数据类型
201	auto castOut = l0op::SignBitsUnpack(selfContiguous, size, op::ToOpDataType(dtype), uniqueExecutor.get());
202	CHECK_RET(castOut != nullptr, ACLNN_ERR_INNER_NULLPTR);
203
204	// 固定写法，将计算结果拷贝到输出out上，out可能是非连续的tensor
205	auto viewCopyResult = l0op::ViewCopy(castOut, out, uniqueExecutor.get());
206	CHECK_RET(viewCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
207
208	// 固定写法，获取计算过程中需要使用的workspace大小
209	*workspaceSize = uniqueExecutor->GetWorkspaceSize();
210	uniqueExecutor.ReleaseTo(executor);
211	return ACLNN_SUCCESS;
212	}	219	}
213		220
214	aclnnStatus aclnnSignBitsUnpack(void workspace, uint64_t workspaceSize, aclOpExecutor executor, aclrtStream stream) {	221	aclnnStatus aclnnSignBitsUnpack(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream)
215	L2_DFX_PHASE_2(aclnnSignBitsUnpack);	222	{
216	// 固定写法，调用框架能力，完成计算	223	L2_DFX_PHASE_2(aclnnSignBitsUnpack);
217	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);	224	// 固定写法，调用框架能力，完成计算
		225	return CommonOpExecutorRun(workspace, workspaceSize, executor, stream);
218	}	226	}
219		227
220	#ifdef __cplusplus	228	#ifdef __cplusplus

Rmath/sign_bits_unpack/op_host/op_api/aclnn_sign_bits_unpack.h→math/sign_bits_unpack/op_api/aclnn_sign_bits_unpack.h+8-6

	@@ -23,18 +23,19 @@ extern "C" {
23	*	23	*
24	* 算子功能：将uint8类型1位Adam拆包为float32或者float16。	24	* 算子功能：将uint8类型1位Adam拆包为float32或者float16。
25	*	25	*
26	* @param [in] self:	26	* @param [in] self:
27	* device侧的aclTensor，数据类型支持UINT8，支持空Tensor。支持非连续的Tensor，数据类型支持UINT8，数据格式支持ND。	27	* device侧的aclTensor，数据类型支持UINT8，支持空Tensor。支持非连续的Tensor，数据类型支持UINT8，数据格式支持ND。
28	* @param [in] size: host侧的int64_t，reshape时输出张量的第一个维度。	28	* @param [in] size: host侧的int64_t，reshape时输出张量的第一个维度。
29	* @param [in] dtype: host侧的aclDataType，表示量化输出Tensor的数据类型，数据类型支持ACL_FLOAT16、ACL_FLOAT。	29	* @param [in] dtype: host侧的aclDataType，表示量化输出Tensor的数据类型，数据类型支持ACL_FLOAT16、ACL_FLOAT。
30	* @param [in] out:	30	* @param [in] out:
31	* device侧的aclTensor，数据类型支持FLOAT16、FLOAT。数据类型由dtype决定，支持非连续的Tensor，数据格式支持ND。	31	* device侧的aclTensor，数据类型支持FLOAT16、FLOAT。数据类型由dtype决定，支持非连续的Tensor，数据格式支持ND。
32	* @param [out] workspaceSize: 返回用户需要在npu device侧申请的workspace大小。	32	* @param [out] workspaceSize: 返回用户需要在npu device侧申请的workspace大小。
33	* @param [out] executor: 返回op执行器，包含算子计算流程。	33	* @param [out] executor: 返回op执行器，包含算子计算流程。
34	* @return aclnnStatus: 返回状态码。	34	* @return aclnnStatus: 返回状态码。
35	*/	35	*/
36	ACLNN_API aclnnStatus aclnnSignBitsUnpackGetWorkspaceSize(const aclTensor* self, int64_t size, aclDataType dtype, aclTensor* out,	36	ACLNN_API aclnnStatus aclnnSignBitsUnpackGetWorkspaceSize(const aclTensor* self, int64_t size, aclDataType dtype,
37	uint64_t* workspaceSize, aclOpExecutor** executor);	37	aclTensor* out, uint64_t* workspaceSize,
		38	aclOpExecutor** executor);
38	/**	39	/**
39	* @brief aclnnSignBitsUnpack的第二段接口，用于执行计算。	40	* @brief aclnnSignBitsUnpack的第二段接口，用于执行计算。
40	*	41	*
	@@ -44,10 +45,11 @@ ACLNN_API aclnnStatus aclnnSignBitsUnpackGetWorkspaceSize(const aclTensor* self,
44	* @param [in] stream: acl stream流。	45	* @param [in] stream: acl stream流。
45	* @return aclnnStatus: 返回状态码。	46	* @return aclnnStatus: 返回状态码。
46	*/	47	*/
47	ACLNN_API aclnnStatus aclnnSignBitsUnpack(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream);	48	ACLNN_API aclnnStatus aclnnSignBitsUnpack(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor,
		49	aclrtStream stream);
48		50
49	#ifdef __cplusplus	51	#ifdef __cplusplus
50	}	52	}
51	#endif	53	#endif
52		54
53	#endif // OP_API_INC_SIGN_BITS_UNPACK_H_	55	#endif // OP_API_INC_SIGN_BITS_UNPACK_H_

Rmath/sign_bits_unpack/op_host/op_api/sign_bits_unpack.cpp→math/sign_bits_unpack/op_api/sign_bits_unpack.cpp+8-8

	@@ -15,15 +15,15 @@
15	#include "opdev/op_executor.h"	15	#include "opdev/op_executor.h"
16	#include "opdev/shape_utils.h"	16	#include "opdev/shape_utils.h"
17		17
18
19	using namespace op;	18	using namespace op;
20		19
21	namespace l0op {	20	namespace l0op {
22	OP_TYPE_REGISTER(SignBitsUnpack);	21	OP_TYPE_REGISTER(SignBitsUnpack);
23	static constexpr size_t OUT_DIM = 2;	22	static constexpr size_t OUT_DIM = 2;
24	static constexpr size_t OUT_SIZE = 8;	23	static constexpr size_t OUT_SIZE = 8;
25		24
26	const aclTensor SignBitsUnpack(const aclTensor self, int64_t size, op::DataType dtype, aclOpExecutor *executor) {	25	const aclTensor* SignBitsUnpack(const aclTensor* self, int64_t size, op::DataType dtype, aclOpExecutor* executor)
		26	{
27	L0_DFX(SignBitsUnpack, self, size, dtype);	27	L0_DFX(SignBitsUnpack, self, size, dtype);
28		28
29	int64_t selfDimOne = self->GetViewShape().GetDim(0);	29	int64_t selfDimOne = self->GetViewShape().GetDim(0);
	@@ -31,22 +31,22 @@ const aclTensor SignBitsUnpack(const aclTensor self, int64_t size, op::DataTyp
31	outShape.SetDimNum(OUT_DIM);	31	outShape.SetDimNum(OUT_DIM);
32	outShape.SetDim(0, size);	32	outShape.SetDim(0, size);
33		33
34	if(size <= 0) {	34	if (size <= 0) {
35	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "size is zero or less than zero, cannot perform division.");	35	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "size is zero or less than zero, cannot perform division.");
36	return nullptr;	36	return nullptr;
37	}	37	}
38	outShape.SetDim(1, (selfDimOne * OUT_SIZE) / size);	38	outShape.SetDim(1, (selfDimOne * OUT_SIZE) / size);
39		39
40	auto out = executor->AllocTensor(outShape, dtype, op::Format::FORMAT_ND);	40	auto out = executor->AllocTensor(outShape, dtype, op::Format::FORMAT_ND);
41	if(out == nullptr) {	41	if (out == nullptr) {
42	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "alloc out tensor failed.");	42	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "alloc out tensor failed.");
43	return nullptr;	43	return nullptr;
44	}	44	}
45		45
46	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(SignBitsUnpack, OP_INPUT(self), OP_OUTPUT(out), OP_ATTR(size, dtype));	46	auto ret = ADD_TO_LAUNCHER_LIST_AICORE(SignBitsUnpack, OP_INPUT(self), OP_OUTPUT(out), OP_ATTR(size, dtype));
47	OP_CHECK(ret == ACLNN_SUCCESS, OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "SignBitsUnpack ADD_TO_LAUNCHER_LIST_AICORE failed."),	47	OP_CHECK(ret == ACLNN_SUCCESS,
48	return nullptr);	48	OP_LOGE(ACLNN_ERR_INNER_NULLPTR, "SignBitsUnpack ADD_TO_LAUNCHER_LIST_AICORE failed."), return nullptr);
49		49
50	return out;	50	return out;
51	}	51	}
52	} // namespace l0op	52	} // namespace l0op

Rmath/sign_bits_unpack/op_host/op_api/sign_bits_unpack.h→math/sign_bits_unpack/op_api/sign_bits_unpack.h+3-3

	@@ -14,7 +14,7 @@
14	#include "opdev/op_executor.h"	14	#include "opdev/op_executor.h"
15		15
16	namespace l0op {	16	namespace l0op {
17	const aclTensor SignBitsUnpack(const aclTensor self, int64_t size, op::DataType dtype, aclOpExecutor *executor);	17	const aclTensor* SignBitsUnpack(const aclTensor* self, int64_t size, op::DataType dtype, aclOpExecutor* executor);
18	} // namespace l0op	18	} // namespace l0op
19		19
20	#endif // OP_API_INC_LEVEL0_SIGN_BITS_UNPACK_H_	20	#endif // OP_API_INC_LEVEL0_SIGN_BITS_UNPACK_H_

Dmath/sign_bits_unpack/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources(OPTYPE sign_bits_unpack ACLNNTYPE aclnn_exclude)

Dmath/sign_bits_unpack/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/sign_bits_unpack/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Rmath/sign_bits_unpack/tests/ut/op_host/op_api/test_aclnn_sign_bits_unpack.cpp→math/sign_bits_unpack/tests/ut/op_api/test_aclnn_sign_bits_unpack.cpp+9-20

	@@ -14,7 +14,7 @@
14	#include <vector>	14	#include <vector>
15		15
16	#include "gtest/gtest.h"	16	#include "gtest/gtest.h"
17	#include "aclnn_sign_bits_unpack.h"	17	#include "../../../op_api/aclnn_sign_bits_unpack.h"
18	#include "op_api_ut_common/op_api_ut.h"	18	#include "op_api_ut_common/op_api_ut.h"
19	#include "op_api_ut_common/scalar_desc.h"	19	#include "op_api_ut_common/scalar_desc.h"
20	#include "op_api_ut_common/tensor_desc.h"	20	#include "op_api_ut_common/tensor_desc.h"
	@@ -22,10 +22,10 @@
22	using namespace std;	22	using namespace std;
23		23
24	class sign_bits_unpack_test : public testing::Test {	24	class sign_bits_unpack_test : public testing::Test {
25	protected:	25	protected:
26	static void SetUpTestCase() { cout << "sign_bits_unpack_test SetUp" << endl; }	26	static void SetUpTestCase() { cout << "sign_bits_unpack_test SetUp" << endl; }
27		27
28	static void TearDownTestCase() { cout << "sign_bits_unpack_test TeastDown" << endl; }	28	static void TearDownTestCase() { cout << "sign_bits_unpack_test TeastDown" << endl; }
29	};	29	};
30		30
31	// CheckNotNull self	31	// CheckNotNull self
	@@ -180,19 +180,6 @@ TEST_F(sign_bits_unpack_test, ascend910B2_case_shape_out)
180	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);	180	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
181	}	181	}
182		182
183	TEST_F(sign_bits_unpack_test, case_float_float16_910)
184	{
185	int64_t size = 2;
186	aclDataType dType = ACL_FLOAT16;
187	auto self_tensor_desc = TensorDesc({2}, ACL_UINT8, ACL_FORMAT_ND);
188	auto out_tensor_desc = TensorDesc({2, 8}, ACL_FLOAT16, ACL_FORMAT_ND);
189	auto ut = OP_API_UT(aclnnSignBitsUnpack, INPUT(self_tensor_desc, size, dType), OUTPUT(out_tensor_desc));
190
191	uint64_t workspaceSize = 0;
192	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
193	EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
194	}
195
196	// CheckEmpty_Tensor	183	// CheckEmpty_Tensor
197	TEST_F(sign_bits_unpack_test, ascend910B2_case_empty_tensor)	184	TEST_F(sign_bits_unpack_test, ascend910B2_case_empty_tensor)
198	{	185	{
	@@ -214,7 +201,8 @@ TEST_F(sign_bits_unpack_test, ascend910B2_case_float_float16)
214	int64_t size = 2;	201	int64_t size = 2;
215	aclDataType dType = ACL_FLOAT16;	202	aclDataType dType = ACL_FLOAT16;
216	auto self_tensor_desc = TensorDesc({2}, ACL_UINT8, ACL_FORMAT_ND).Value(vector<uint8_t>{159, 15});	203	auto self_tensor_desc = TensorDesc({2}, ACL_UINT8, ACL_FORMAT_ND).Value(vector<uint8_t>{159, 15});
217	auto out_tensor_desc = TensorDesc({2, 8}, ACL_FLOAT16, ACL_FORMAT_ND).Value(vector<int16_t>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});	204	auto out_tensor_desc = TensorDesc({2, 8}, ACL_FLOAT16, ACL_FORMAT_ND)
		205	.Value(vector<int16_t>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
218	auto ut = OP_API_UT(aclnnSignBitsUnpack, INPUT(self_tensor_desc, size, dType), OUTPUT(out_tensor_desc));	206	auto ut = OP_API_UT(aclnnSignBitsUnpack, INPUT(self_tensor_desc, size, dType), OUTPUT(out_tensor_desc));
219		207
220	uint64_t workspaceSize = 0;	208	uint64_t workspaceSize = 0;
	@@ -228,10 +216,11 @@ TEST_F(sign_bits_unpack_test, ascend910B2_case_float_float)
228	int64_t size = 2;	216	int64_t size = 2;
229	aclDataType dType = ACL_FLOAT;	217	aclDataType dType = ACL_FLOAT;
230	auto self_tensor_desc = TensorDesc({2}, ACL_UINT8, ACL_FORMAT_ND).Value(vector<uint8_t>{159, 15});	218	auto self_tensor_desc = TensorDesc({2}, ACL_UINT8, ACL_FORMAT_ND).Value(vector<uint8_t>{159, 15});
231	auto out_tensor_desc = TensorDesc({2, 8}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});	219	auto out_tensor_desc = TensorDesc({2, 8}, ACL_FLOAT, ACL_FORMAT_ND)
		220	.Value(vector<float>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
232	auto ut = OP_API_UT(aclnnSignBitsUnpack, INPUT(self_tensor_desc, size, dType), OUTPUT(out_tensor_desc));	221	auto ut = OP_API_UT(aclnnSignBitsUnpack, INPUT(self_tensor_desc, size, dType), OUTPUT(out_tensor_desc));
233		222
234	uint64_t workspaceSize = 0;	223	uint64_t workspaceSize = 0;
235	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);	224	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
236	EXPECT_EQ(aclRet, ACL_SUCCESS);	225	EXPECT_EQ(aclRet, ACL_SUCCESS);
237	}	226	}

Dmath/sign_bits_unpack/tests/ut/op_host/CMakeLists.txt+0-20

	@@ -1,20 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()
18
19	if(OP_API_UT OR (UT_TEST_ALL AND NOT AICPU_ONLY))
20	endif()

Dmath/sign_bits_unpack/tests/ut/op_host/op_api/CMakeLists.txt+0-11

	@@ -1,11 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11

Mmath/sinkhorn/CMakeLists.txt+3-12

	@@ -1,20 +1,11 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11		10
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE sinkhorn ACLNNTYPE aclnn_exclude)
13	if(NOT ENABLE_TEST AND NOT BENCHMARK)
14	list(REMOVE_ITEM CURRENT_DIRS tests)
15	endif()
16	foreach(SUB_DIR ${CURRENT_DIRS})
17	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
18	add_subdirectory(${SUB_DIR})
19	endif()
20	endforeach()

Rmath/sinkhorn/op_host/op_api/aclnn_sinkhorn.cpp→math/sinkhorn/op_api/aclnn_sinkhorn.cpp+9-10

	@@ -7,7 +7,7 @@
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/	9	*/
10		10
11	#include "aclnn_sinkhorn.h"	11	#include "aclnn_sinkhorn.h"
12	#include "sinkhorn.h"	12	#include "sinkhorn.h"
13	#include "aclnn_kernels/cast.h"	13	#include "aclnn_kernels/cast.h"
	@@ -33,14 +33,14 @@ constexpr int32_t COST_COL_DIM = 1;
33	constexpr int32_t MAX_COST_COL = 4096;	33	constexpr int32_t MAX_COST_COL = 4096;
34		34
35	// 根据API定义，需要列出所能支持的所有dtype	35	// 根据API定义，需要列出所能支持的所有dtype
36	static const std::initializer_list<op::DataType> SELF_DTYPE_SUPPORT_LIST_NOT_SUPPORT_BF16 = {	36	static const std::initializer_list<op::DataType> SELF_DTYPE_SUPPORT_LIST_NOT_SUPPORT_BF16 = {op::DataType::DT_FLOAT,
37	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16};	37	op::DataType::DT_FLOAT16};
38		38
39	static const std::initializer_list<op::DataType> SELF_DTYPE_SUPPORT_LIST_SUPPORT_BF16 = {	39	static const std::initializer_list<op::DataType> SELF_DTYPE_SUPPORT_LIST_SUPPORT_BF16 = {
40	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};	40	op::DataType::DT_FLOAT, op::DataType::DT_FLOAT16, op::DataType::DT_BF16};
41		41
42	static const std::initializer_list<op::DataType> MASK_DTYPE_SUPPORT_LIST = {	42	static const std::initializer_list<op::DataType> MASK_DTYPE_SUPPORT_LIST = {op::DataType::DT_UINT8,
43	op::DataType::DT_UINT8, op::DataType::DT_BOOL};	43	op::DataType::DT_BOOL};
44		44
45	inline static bool CheckNotNull(const aclTensor* cost, const aclTensor* p)	45	inline static bool CheckNotNull(const aclTensor* cost, const aclTensor* p)
46	{	46	{
	@@ -76,9 +76,8 @@ static bool CheckShape(const aclTensor* cost, const aclTensor* p)
76		76
77	int32_t col = cost->GetViewShape().GetDim(COST_COL_DIM);	77	int32_t col = cost->GetViewShape().GetDim(COST_COL_DIM);
78	if (col > MAX_COST_COL) {	78	if (col > MAX_COST_COL) {
79	OP_LOGE(	79	OP_LOGE(ACLNN_ERR_PARAM_INVALID, "the column number of cost is %d, it cannot be larger than %d.", col,
80	ACLNN_ERR_PARAM_INVALID, "the column number of cost is %d, it cannot be larger than %d.", col,	80	MAX_COST_COL);
81	MAX_COST_COL);
82	return false;	81	return false;
83	}	82	}
84		83
	@@ -100,8 +99,8 @@ inline static aclnnStatus CheckParams(const aclTensor* cost, const aclTensor* p)
100	return ACLNN_SUCCESS;	99	return ACLNN_SUCCESS;
101	}	100	}
102		101
103	aclnnStatus aclnnSinkhornGetWorkspaceSize(	102	aclnnStatus aclnnSinkhornGetWorkspaceSize(const aclTensor* cost, const aclScalar* tol, aclTensor* p,
104	const aclTensor* cost, const aclScalar* tol, aclTensor* p, uint64_t* workspaceSize, aclOpExecutor** executor)	103	uint64_t* workspaceSize, aclOpExecutor** executor)
105	{	104	{
106	OP_CHECK_COMM_INPUT(workspaceSize, executor);	105	OP_CHECK_COMM_INPUT(workspaceSize, executor);
107		106

Rmath/sinkhorn/op_host/op_api/aclnn_sinkhorn.h→math/sinkhorn/op_api/aclnn_sinkhorn.h+4-4

	@@ -31,8 +31,8 @@ extern "C" {
31	* @param [out] executor: 返回op执行器，包含算子计算流程。	31	* @param [out] executor: 返回op执行器，包含算子计算流程。
32	* @return aclnnStatus: 返回状态码。	32	* @return aclnnStatus: 返回状态码。
33	*/	33	*/
34	ACLNN_API aclnnStatus aclnnSinkhornGetWorkspaceSize(	34	ACLNN_API aclnnStatus aclnnSinkhornGetWorkspaceSize(const aclTensor* cost, const aclScalar* tol, aclTensor* p,
35	const aclTensor* cost, const aclScalar* tol, aclTensor* p, uint64_t* workspaceSize, aclOpExecutor** executor);	35	uint64_t* workspaceSize, aclOpExecutor** executor);
36	/**	36	/**
37	* @brief aclnnSinkhorn的第二段接口，用于执行计算。	37	* @brief aclnnSinkhorn的第二段接口，用于执行计算。
38	*	38	*
	@@ -44,8 +44,8 @@ ACLNN_API aclnnStatus aclnnSinkhornGetWorkspaceSize(
44	* @param [in] executor: op执行器，包含了算子计算流程。	44	* @param [in] executor: op执行器，包含了算子计算流程。
45	* @return aclnnStatus: 返回状态码。	45	* @return aclnnStatus: 返回状态码。
46	*/	46	*/
47	ACLNN_API aclnnStatus	47	ACLNN_API aclnnStatus aclnnSinkhorn(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor,
48	aclnnSinkhorn(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, aclrtStream stream);	48	aclrtStream stream);
49		49
50	#ifdef __cplusplus	50	#ifdef __cplusplus
51	}	51	}

Rmath/sinkhorn/op_host/op_api/sinkhorn.cpp→math/sinkhorn/op_api/sinkhorn.cpp+0-0

文件重命名但无更改。

Rmath/sinkhorn/op_host/op_api/sinkhorn.h→math/sinkhorn/op_api/sinkhorn.h+0-0

文件重命名但无更改。

Dmath/sinkhorn/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources(OPTYPE sinkhorn ACLNNTYPE aclnn_exclude)

Dmath/sinkhorn/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/sinkhorn/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Amath/sinkhorn/tests/ut/op_api/test_aclnn_sinkhorn.cpp+89-0

@@ -0,0 +1,89 @@
	1	/**
	2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
	3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	* CANN Open Software License Agreement Version 2.0 (the "License").
	5	* Please refer to the License for details. You may not use this file except in compliance with the License.
	6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	* See LICENSE in the root of the software repository for the full text of the License.
	9	*/
	10
	11	#include <array>
	12	#include <vector>
	13	#include "gtest/gtest.h"
	14
	15	#include "../../../op_api/aclnn_sinkhorn.h"
	16
	17	#include "op_api_ut_common/op_api_ut.h"
	18	#include "op_api_ut_common/scalar_desc.h"
	19	#include "op_api_ut_common/tensor_desc.h"
	20	#include <cstdlib>
	21	#include <ctime>
	22
	23	using namespace std;
	24
	25	class l2_sinkhorn_test : public testing::Test {
	26	protected:
	27	static void SetUpTestCase() { cout << "sinkhorn_test SetUp" << endl; }
	28
	29	static void TearDownTestCase() { cout << "sinkhorn_test TearDown" << endl; }
	30	};
	31
	32	TEST_F(l2_sinkhorn_test, aclnnSinkhorn_float_8_2)
	33	{
	34	const vector<int64_t>& costShape = {8, 2};
	35	aclDataType dType = ACL_FLOAT;
	36	aclFormat dFormat = ACL_FORMAT_ND;
	37
	38	const vector<int64_t>& pShape = {8, 2};
	39
	40	auto costTensorDesc = TensorDesc(costShape, dType, dFormat)
	41	.Value(vector<float>{45.0f, 48.0f, 65.0f, 68.0f, 68.0f, 10.0f, 84.0f, 22.0f, 37.0f, 71.0f,
	42	13.0f, 59.0f, 66.0f, 40.0f, 47.0f, 82.0f});
	43	auto pTensorDesc = TensorDesc(pShape, dType, dFormat).ValidCount(16);
	44	auto tolScalarDesc = ScalarDesc(0.0001f);
	45
	46	auto ut = OP_API_UT(aclnnSinkhorn, INPUT(costTensorDesc, tolScalarDesc), OUTPUT(pTensorDesc));
	47
	48	uint64_t workspaceSize = 0;
	49	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	50	EXPECT_EQ(aclRet, ACL_SUCCESS);
	51	}
	52
	53	TEST_F(l2_sinkhorn_test, ascend910B2_aclnnSinkhorn_bf16_8_2)
	54	{
	55	const vector<int64_t>& costShape = {8, 2};
	56	aclDataType dType = ACL_BF16;
	57	aclFormat dFormat = ACL_FORMAT_ND;
	58
	59	const vector<int64_t>& pShape = {8, 2};
	60
	61	auto costTensorDesc = TensorDesc(costShape, dType, dFormat).ValueRange(0.0, 1.0);
	62	auto pTensorDesc = TensorDesc(pShape, dType, dFormat).ValidCount(16);
	63	auto tolScalarDesc = ScalarDesc(0.0001f);
	64
	65	auto ut = OP_API_UT(aclnnSinkhorn, INPUT(costTensorDesc, tolScalarDesc), OUTPUT(pTensorDesc));
	66
	67	uint64_t workspaceSize = 0;
	68	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	69	EXPECT_EQ(aclRet, ACL_SUCCESS);
	70	}
	71
	72	TEST_F(l2_sinkhorn_test, ascend910B2_aclnnSinkhorn_float16_8_2)
	73	{
	74	const vector<int64_t>& costShape = {8, 2};
	75	aclDataType dType = ACL_FLOAT16;
	76	aclFormat dFormat = ACL_FORMAT_ND;
	77
	78	const vector<int64_t>& pShape = {8, 2};
	79
	80	auto costTensorDesc = TensorDesc(costShape, dType, dFormat).ValueRange(0, 1);
	81	auto pTensorDesc = TensorDesc(pShape, dType, dFormat).ValidCount(16);
	82	auto tolScalarDesc = ScalarDesc(0.0001f);
	83
	84	auto ut = OP_API_UT(aclnnSinkhorn, INPUT(costTensorDesc, tolScalarDesc), OUTPUT(pTensorDesc));
	85
	86	uint64_t workspaceSize = 0;
	87	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
	88	EXPECT_EQ(aclRet, ACL_SUCCESS);
	89	}

Dmath/sinkhorn/tests/ut/op_host/CMakeLists.txt+0-21

	@@ -1,21 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	if(UT_TEST_ALL OR OP_HOST_UT)
13	add_modules_ut_sources(UT_NAME ${OP_TILING_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
14	endif()
15
16	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
17	foreach(SUB_DIR ${CURRENT_DIRS})
18	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
19	add_subdirectory(${SUB_DIR})
20	endif()
21	endforeach()

Dmath/sinkhorn/tests/ut/op_host/op_api/CMakeLists.txt+0-10

	@@ -1,10 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------

Dmath/sinkhorn/tests/ut/op_host/op_api/test_aclnn_sinkhorn.cpp+0-91

	@@ -1,91 +0,0 @@
1	/**
2	* Copyright (c) 2025 Huawei Technologies Co., Ltd.
3	* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4	* CANN Open Software License Agreement Version 2.0 (the "License").
5	* Please refer to the License for details. You may not use this file except in compliance with the License.
6	* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/
10
11	#include <array>
12	#include <vector>
13	#include "gtest/gtest.h"
14
15	#include "aclnn_sinkhorn.h"
16
17	#include "op_api_ut_common/op_api_ut.h"
18	#include "op_api_ut_common/scalar_desc.h"
19	#include "op_api_ut_common/tensor_desc.h"
20	#include <cstdlib>
21	#include <ctime>
22
23
24	using namespace std;
25
26	class l2_sinkhorn_test : public testing::Test {
27	protected:
28	static void SetUpTestCase() {
29	cout << "sinkhorn_test SetUp" << endl;
30	}
31
32	static void TearDownTestCase() {
33	cout << "sinkhorn_test TearDown" << endl;
34	}
35	};
36
37	TEST_F(l2_sinkhorn_test, aclnnSinkhorn_float_8_2) {
38	const vector<int64_t>& costShape = {8, 2};
39	aclDataType dType = ACL_FLOAT;
40	aclFormat dFormat = ACL_FORMAT_ND;
41
42	const vector<int64_t>& pShape = {8, 2};
43
44	auto costTensorDesc = TensorDesc(costShape, dType, dFormat)
45	.Value(vector<float>{45.0f, 48.0f, 65.0f, 68.0f, 68.0f, 10.0f, 84.0f, 22.0f, 37.0f, 71.0f, 13.0f, 59.0f, 66.0f, 40.0f, 47.0f, 82.0f});
46	auto pTensorDesc = TensorDesc(pShape, dType, dFormat).ValidCount(16);
47	auto tolScalarDesc = ScalarDesc(0.0001f);
48
49	auto ut = OP_API_UT(aclnnSinkhorn, INPUT(costTensorDesc, tolScalarDesc), OUTPUT(pTensorDesc));
50
51	uint64_t workspaceSize = 0;
52	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
53	EXPECT_EQ(aclRet, ACL_SUCCESS);
54	}
55
56	TEST_F(l2_sinkhorn_test, ascend910B2_aclnnSinkhorn_bf16_8_2) {
57	const vector<int64_t>& costShape = {8, 2};
58	aclDataType dType = ACL_BF16;
59	aclFormat dFormat = ACL_FORMAT_ND;
60
61	const vector<int64_t>& pShape = {8, 2};
62
63	auto costTensorDesc = TensorDesc(costShape, dType, dFormat).ValueRange(0.0, 1.0);
64	auto pTensorDesc = TensorDesc(pShape, dType, dFormat).ValidCount(16);
65	auto tolScalarDesc = ScalarDesc(0.0001f);
66
67	auto ut = OP_API_UT(aclnnSinkhorn, INPUT(costTensorDesc, tolScalarDesc), OUTPUT(pTensorDesc));
68
69	uint64_t workspaceSize = 0;
70	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
71	EXPECT_EQ(aclRet, ACL_SUCCESS);
72	}
73
74	TEST_F(l2_sinkhorn_test, ascend910B2_aclnnSinkhorn_float16_8_2) {
75	const vector<int64_t>& costShape = {8, 2};
76	aclDataType dType = ACL_FLOAT16;
77	aclFormat dFormat = ACL_FORMAT_ND;
78
79	const vector<int64_t>& pShape = {8, 2};
80
81	auto costTensorDesc = TensorDesc(costShape, dType, dFormat)
82	.ValueRange(0, 1);
83	auto pTensorDesc = TensorDesc(pShape, dType, dFormat).ValidCount(16);
84	auto tolScalarDesc = ScalarDesc(0.0001f);
85
86	auto ut = OP_API_UT(aclnnSinkhorn, INPUT(costTensorDesc, tolScalarDesc), OUTPUT(pTensorDesc));
87
88	uint64_t workspaceSize = 0;
89	aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
90	EXPECT_EQ(aclRet, ACL_SUCCESS);
91	}

Mmath/topk/CMakeLists.txt+3-12

	@@ -1,23 +1,14 @@
1	# ----------------------------------------------------------------------------	1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.	2	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.	3	# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").	4	# CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.	5	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING	6	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.	8	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------	9	# ----------------------------------------------------------------------------
11		10
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)	11	add_all_modules_sources(OPTYPE topk ACLNNTYPE aclnn_exclude)
13	if(NOT ENABLE_TEST AND NOT BENCHMARK)
14	list(REMOVE_ITEM CURRENT_DIRS tests)
15	endif()
16	foreach(SUB_DIR ${CURRENT_DIRS})
17	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
18	add_subdirectory(${SUB_DIR})
19	endif()
20	endforeach()
21		12
22	if(ENABLE_TEST AND (UT_TEST_ALL OR OP_KERNEL_AICPU_UT))	13	if(ENABLE_TEST AND (UT_TEST_ALL OR OP_KERNEL_AICPU_UT))
23	list(FIND ASCEND_OP_NAME topk TOPK_INDEX)	14	list(FIND ASCEND_OP_NAME topk TOPK_INDEX)

Rmath/topk/op_host/op_api/topk.cpp→math/topk/op_api/topk.cpp+32-34

	@@ -49,8 +49,8 @@ constexpr int64_t RADIX_TOP_K_S_K_RATIO_2 = 50;
49	constexpr int64_t RADIX_TOP_K_MIN_K = 1000;	49	constexpr int64_t RADIX_TOP_K_MIN_K = 1000;
50	constexpr int64_t MAX_INT32_INPUTSIZE = 2147483647;	50	constexpr int64_t MAX_INT32_INPUTSIZE = 2147483647;
51		51
52	static const std::initializer_list<op::DataType> ANCIENT_DTYPE_SUPPORT_LIST = {	52	static const std::initializer_list<op::DataType> ANCIENT_DTYPE_SUPPORT_LIST = {op::DataType::DT_FLOAT16,
53	op::DataType::DT_FLOAT16, op::DataType::DT_FLOAT};	53	op::DataType::DT_FLOAT};
54		54
55	static const std::initializer_list<op::DataType> CURRENT_DTYPE_SUPPORT_LIST = {	55	static const std::initializer_list<op::DataType> CURRENT_DTYPE_SUPPORT_LIST = {
56	op::DataType::DT_FLOAT16, op::DataType::DT_FLOAT, op::DataType::DT_BF16};	56	op::DataType::DT_FLOAT16, op::DataType::DT_FLOAT, op::DataType::DT_BF16};
	@@ -112,8 +112,8 @@ static bool IsAiCoreSupport(const aclTensor* self, int64_t k)
112	}	112	}
113		113
114	if (IsFloatTypeSoc(version)) {	114	if (IsFloatTypeSoc(version)) {
115	return CheckType(	115	return CheckType(self->GetDataType(),
116	self->GetDataType(), {op::DataType::DT_FLOAT16, op::DataType::DT_FLOAT, op::DataType::DT_BF16});	116	{op::DataType::DT_FLOAT16, op::DataType::DT_FLOAT, op::DataType::DT_BF16});
117	}	117	}
118	// 910、310芯片	118	// 910、310芯片
119	return self->GetDataType() == op::DataType::DT_FLOAT16;	119	return self->GetDataType() == op::DataType::DT_FLOAT16;
	@@ -149,9 +149,9 @@ static bool IsAscendCSupport(const aclTensor* self, int64_t k)
149	}	149	}
150		150
151	// AICORE算子kernel	151	// AICORE算子kernel
152	std::tuple<aclTensor, aclTensor> TopkV2AiCore(	152	std::tuple<aclTensor, aclTensor> TopkV2AiCore(const aclTensor* self, const aclTensor* k, int64_t dim, bool largest,
153	const aclTensor* self, const aclTensor* k, int64_t dim, bool largest, bool sorted, aclTensor* values,	153	bool sorted, aclTensor* values, aclTensor* indices,
154	aclTensor* indices, aclOpExecutor* executor)	154	aclOpExecutor* executor)
155	{	155	{
156	L0_DFX(TopkV2AiCore, self, k, dim, largest, sorted, values, indices);	156	L0_DFX(TopkV2AiCore, self, k, dim, largest, sorted, values, indices);
157	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICORE，将AiCore TopKV2算子加入任务队列	157	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICORE，将AiCore TopKV2算子加入任务队列
	@@ -159,29 +159,29 @@ std::tuple<aclTensor, aclTensor> TopkV2AiCore(
159	return std::tuple<aclTensor, aclTensor>(values, indices);	159	return std::tuple<aclTensor, aclTensor>(values, indices);
160	}	160	}
161		161
162	std::tuple<aclTensor, aclTensor> TopkV2AiCoreForDavid(	162	std::tuple<aclTensor, aclTensor> TopkV2AiCoreForDavid(const aclTensor* self, const aclTensor* k, int64_t dim,
163	const aclTensor* self, const aclTensor* k, int64_t dim, bool largest, bool sorted, aclTensor* values,	163	bool largest, bool sorted, aclTensor* values,
164	aclTensor* indices, op::DataType indicesDType, aclOpExecutor* executor)	164	aclTensor* indices, op::DataType indicesDType,
		165	aclOpExecutor* executor)
165	{	166	{
166	L0_DFX(TopkV2AiCoreForDavid, self, k, dim, largest, sorted, values, indices, indicesDType);	167	L0_DFX(TopkV2AiCoreForDavid, self, k, dim, largest, sorted, values, indices, indicesDType);
167	ADD_TO_LAUNCHER_LIST_AICORE(	168	ADD_TO_LAUNCHER_LIST_AICORE(TopKV2, OP_INPUT(self, k), OP_OUTPUT(values, indices),
168	TopKV2, OP_INPUT(self, k), OP_OUTPUT(values, indices), OP_ATTR(sorted, dim, largest, indicesDType));	169	OP_ATTR(sorted, dim, largest, indicesDType));
169	return std::tuple<aclTensor, aclTensor>(values, indices);	170	return std::tuple<aclTensor, aclTensor>(values, indices);
170	}	171	}
171		172
172	std::tuple<aclTensor, aclTensor> RadixTopK(	173	std::tuple<aclTensor, aclTensor> RadixTopK(const aclTensor* self, const aclTensor* k, int64_t dim, bool largest,
173	const aclTensor* self, const aclTensor* k, int64_t dim, bool largest, bool sorted, aclTensor* values,	174	bool sorted, aclTensor* values, aclTensor* indices,
174	aclTensor* indices, op::DataType indicesDType, aclOpExecutor* executor)	175	op::DataType indicesDType, aclOpExecutor* executor)
175	{	176	{
176	L0_DFX(RadixTopK, self, k, dim, largest, sorted, values, indices, indicesDType);	177	L0_DFX(RadixTopK, self, k, dim, largest, sorted, values, indices, indicesDType);
177	ADD_TO_LAUNCHER_LIST_AICORE(	178	ADD_TO_LAUNCHER_LIST_AICORE(RadixTopK, OP_INPUT(self, k), OP_OUTPUT(values, indices),
178	RadixTopK, OP_INPUT(self, k), OP_OUTPUT(values, indices), OP_ATTR(sorted, dim, largest, indicesDType));	179	OP_ATTR(sorted, dim, largest, indicesDType));
179	return std::tuple<aclTensor, aclTensor>(values, indices);	180	return std::tuple<aclTensor, aclTensor>(values, indices);
180	}	181	}
181		182
182	std::tuple<aclTensor, aclTensor> TopkV3(	183	std::tuple<aclTensor, aclTensor> TopkV3(const aclTensor* self, const aclTensor* k, int64_t dim, bool largest,
183	const aclTensor* self, const aclTensor* k, int64_t dim, bool largest, bool sorted, aclTensor* values,	184	bool sorted, aclTensor* values, aclTensor* indices, aclOpExecutor* executor)
184	aclTensor* indices, aclOpExecutor* executor)
185	{	185	{
186	L0_DFX(TopkV3, self, k, dim, largest, sorted, values, indices);	186	L0_DFX(TopkV3, self, k, dim, largest, sorted, values, indices);
187	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICORE，将AiCore TopKV3算子加入任务队列	187	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICORE，将AiCore TopKV3算子加入任务队列
	@@ -190,7 +190,8 @@ std::tuple<aclTensor, aclTensor> TopkV3(
190	}	190	}
191		191
192	// SortWithIndex排序时，将输出索引类型int64转为int32，计算结束后再将结果转为int64，能获取更好的性能	192	// SortWithIndex排序时，将输出索引类型int64转为int32，计算结束后再将结果转为int64，能获取更好的性能
193	static bool IsSortWithIndex(const aclTensor* self, int64_t k, bool sorted) {	193	static bool IsSortWithIndex(const aclTensor* self, int64_t k, bool sorted)
		194	{
194	auto inputShape = self->GetViewShape();	195	auto inputShape = self->GetViewShape();
195	int64_t dimNum = static_cast<int64_t>(inputShape.GetDimNum());	196	int64_t dimNum = static_cast<int64_t>(inputShape.GetDimNum());
196		197
	@@ -198,24 +199,22 @@ static bool IsSortWithIndex(const aclTensor* self, int64_t k, bool sorted) {
198	}	199	}
199		200
200	// AICPU算子kernel	201	// AICPU算子kernel
201	std::tuple<aclTensor, aclTensor> TopkAiCpu(	202	std::tuple<aclTensor, aclTensor> TopkAiCpu(const aclTensor* self, const aclTensor* k, int64_t dim, bool largest,
202	const aclTensor* self, const aclTensor* k, int64_t dim, bool largest, bool sorted, aclTensor* values,	203	bool sorted, aclTensor* values, aclTensor* indices,
203	aclTensor* indices, aclOpExecutor* executor)	204	aclOpExecutor* executor)
204	{	205	{
205	L0_DFX(TopkAiCpu, self, k, dim, largest, sorted, values, indices);	206	L0_DFX(TopkAiCpu, self, k, dim, largest, sorted, values, indices);
206	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICPU，将AiCpu TopK算子加入任务队列	207	// 使用框架宏ADD_TO_LAUNCHER_LIST_AICPU，将AiCpu TopK算子加入任务队列
207	static internal::AicpuTaskSpace space("TopK");	208	static internal::AicpuTaskSpace space("TopK");
208	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(	209	auto ret = ADD_TO_LAUNCHER_LIST_AICPU(TopK, OP_ATTR_NAMES({"sorted", "largest", "dim"}), OP_INPUT(self, k),
209	TopK, OP_ATTR_NAMES({"sorted", "largest", "dim"}), OP_INPUT(self, k), OP_OUTPUT(values, indices),	210	OP_OUTPUT(values, indices), OP_ATTR(sorted, largest, dim));
210	OP_ATTR(sorted, largest, dim));
211	if (ret != ACLNN_SUCCESS) {	211	if (ret != ACLNN_SUCCESS) {
212	return std::tuple<aclTensor, aclTensor>(nullptr, nullptr);	212	return std::tuple<aclTensor, aclTensor>(nullptr, nullptr);
213	}	213	}
214	return std::tuple<aclTensor, aclTensor>(values, indices);	214	return std::tuple<aclTensor, aclTensor>(values, indices);
215	}	215	}
216	std::tuple<aclTensor, aclTensor> Topk(	216	std::tuple<aclTensor, aclTensor> Topk(const aclTensor* self, int64_t k, int64_t dim, bool largest, bool sorted,
217	const aclTensor* self, int64_t k, int64_t dim, bool largest, bool sorted, op::DataType indicesDType,	217	op::DataType indicesDType, aclOpExecutor* executor)
218	aclOpExecutor* executor)
219	{	218	{
220	op::Shape outShape = self->GetStorageShape();	219	op::Shape outShape = self->GetStorageShape();
221	outShape.SetDim(dim, k);	220	outShape.SetDim(dim, k);
	@@ -239,11 +238,10 @@ std::tuple<aclTensor, aclTensor> Topk(
239	return TopkV3(self, kTensor, dim, largest, sorted, valuesOut, indicesOut, executor);	238	return TopkV3(self, kTensor, dim, largest, sorted, valuesOut, indicesOut, executor);
240	} else {	239	} else {
241	if (IsRegBase()) {	240	if (IsRegBase()) {
242	return TopkV2AiCoreForDavid(	241	return TopkV2AiCoreForDavid(self, kTensor, dim, largest, sorted, valuesOut, indicesOut, indicesDType,
243	self, kTensor, dim, largest, sorted, valuesOut, indicesOut, indicesDType, executor);	242	executor);
244	} else if (IsRadixTopKSupport(self, k)) {	243	} else if (IsRadixTopKSupport(self, k)) {
245	return RadixTopK(	244	return RadixTopK(self, kTensor, dim, largest, sorted, valuesOut, indicesOut, indicesDType, executor);
246	self, kTensor, dim, largest, sorted, valuesOut, indicesOut, indicesDType, executor);
247	} else {	245	} else {
248	return TopkV2AiCore(self, kTensor, dim, largest, sorted, valuesOut, indicesOut, executor);	246	return TopkV2AiCore(self, kTensor, dim, largest, sorted, valuesOut, indicesOut, executor);
249	}	247	}

Rmath/topk/op_host/op_api/topk.h→math/topk/op_api/topk.h+3-4

	@@ -7,7 +7,7 @@
7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.	7	* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8	* See LICENSE in the root of the software repository for the full text of the License.	8	* See LICENSE in the root of the software repository for the full text of the License.
9	*/	9	*/
10		10
11	#ifndef OP_API_OP_API_COMMON_INC_LEVEL0_OP_TOPK_H_	11	#ifndef OP_API_OP_API_COMMON_INC_LEVEL0_OP_TOPK_H_
12	#define OP_API_OP_API_COMMON_INC_LEVEL0_OP_TOPK_H_	12	#define OP_API_OP_API_COMMON_INC_LEVEL0_OP_TOPK_H_
13		13
	@@ -15,9 +15,8 @@
15	#include "opdev/make_op_executor.h"	15	#include "opdev/make_op_executor.h"
16		16
17	namespace l0op {	17	namespace l0op {
18	std::tuple<aclTensor, aclTensor> Topk(	18	std::tuple<aclTensor, aclTensor> Topk(const aclTensor* self, int64_t k, int64_t dim, bool largest, bool sorted,
19	const aclTensor* self, int64_t k, int64_t dim, bool largest, bool sorted, op::DataType indicesDType,	19	op::DataType indicesDType, aclOpExecutor* executor);
20	aclOpExecutor* executor);
21	}	20	}
22		21
23	#endif // OP_API_OP_API_COMMON_INC_LEVEL0_OP_TOPK_H_	22	#endif // OP_API_OP_API_COMMON_INC_LEVEL0_OP_TOPK_H_

Dmath/topk/op_host/CMakeLists.txt+0-12

	@@ -1,12 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	add_modules_sources(OPTYPE topk ACLNNTYPE aclnn_exclude)

Dmath/topk/tests/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/topk/tests/ut/CMakeLists.txt+0-17

	@@ -1,17 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------
11
12	file(GLOB CURRENT_DIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
13	foreach(SUB_DIR ${CURRENT_DIRS})
14	if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUB_DIR}/CMakeLists.txt")
15	add_subdirectory(${SUB_DIR})
16	endif()
17	endforeach()

Dmath/topk/tests/ut/op_host/CMakeLists.txt+0-10

	@@ -1,10 +0,0 @@
1	# ----------------------------------------------------------------------------
2	# This program is free software, you can redistribute it and/or modify it.
3	# Copyright (c) 2025 Huawei Technologies Co., Ltd.
4	# This file is a part of the CANN Open Software.
5	# Licensed under CANN Open Software License Agreement Version 2.0 (the "License").
6	# Please refer to the License for details. You may not use this file except in compliance with the License.
7	# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
8	# BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
9	# See LICENSE in the root of the software repository for the full text of the License.
10	# ----------------------------------------------------------------------------

Mrandom/stateless_sample_multinomial/op_api/aclnn_multinomial.cpp+1-1

	@@ -17,7 +17,7 @@
17	#include "math/real_div/op_api/realdiv.h"	17	#include "math/real_div/op_api/realdiv.h"
18	#include "math/log/op_api/log.h"	18	#include "math/log/op_api/log.h"
19	#include "math/arg_max_v2/op_api/argmax_v2.h"	19	#include "math/arg_max_v2/op_api/argmax_v2.h"
20	#include "math/topk/op_host/op_api/topk.h"	20	#include "math/topk/op_api/topk.h"
21	#include "math/cumsum/op_api/cumsum.h"	21	#include "math/cumsum/op_api/cumsum.h"
22	#include "conversion/unsqueeze/op_host/op_api/unsqueeze.h"	22	#include "conversion/unsqueeze/op_host/op_api/unsqueeze.h"
23	#include "random/dsa_random_uniform/op_host/op_api/dsa_random_uniform.h"	23	#include "random/dsa_random_uniform/op_host/op_api/dsa_random_uniform.h"

	@@ -55,7 +55,7 @@ math@ops-math:
55	- ops/ops-math/math/addcdiv/op_api/	55	- ops/ops-math/math/addcdiv/op_api/
56	- ops/ops-math/math/addcmul/op_api/	56	- ops/ops-math/math/addcmul/op_api/
57	- ops/ops-math/math/addr/op_api/	57	- ops/ops-math/math/addr/op_api/
58	- ops/ops-math/math/affine_grid/op_host/op_api/	58	- ops/ops-math/math/affine_grid/op_api/
59	- ops/ops-math/math/amp_update_scale/op_kernel/	59	- ops/ops-math/math/amp_update_scale/op_kernel/
60	- ops/ops-math/math/angle_v2/op_kernel/	60	- ops/ops-math/math/angle_v2/op_kernel/
61	- ops/ops-math/math/arg_max_v2/op_api/	61	- ops/ops-math/math/arg_max_v2/op_api/
	@@ -74,10 +74,9 @@ math@ops-math:
74	- ops/ops-math/math/bias_add_grad/op_kernel/	74	- ops/ops-math/math/bias_add_grad/op_kernel/
75	- ops/ops-math/math/bincount/op_api/	75	- ops/ops-math/math/bincount/op_api/
76	- ops/ops-math/math/bitwise_and/op_api/	76	- ops/ops-math/math/bitwise_and/op_api/
77	- ops/ops-math/math/bitwise_not/op_host/op_api/	77	- ops/ops-math/math/bitwise_not/op_api/
78	- ops/ops-math/math/bitwise_or/op_api/	78	- ops/ops-math/math/bitwise_or/op_api/
79	- ops/ops-math/math/bitwise_xor/op_api/	79	- ops/ops-math/math/bitwise_xor/op_api/
80	- ops/ops-math/math/bitwise_xor/op_host/op_api/
81	- ops/ops-math/math/cast/op_api/	80	- ops/ops-math/math/cast/op_api/
82	- ops/ops-math/math/cdist/op_api/	81	- ops/ops-math/math/cdist/op_api/
83	- ops/ops-math/math/cdist/op_kernel/	82	- ops/ops-math/math/cdist/op_kernel/
	@@ -86,7 +85,7 @@ math@ops-math:
86	- ops/ops-math/math/cdist_grad/op_kernel/	85	- ops/ops-math/math/cdist_grad/op_kernel/
87	- ops/ops-math/math/ceil/op_api/	86	- ops/ops-math/math/ceil/op_api/
88	- ops/ops-math/math/cholesky/op_host/	87	- ops/ops-math/math/cholesky/op_host/
89	- ops/ops-math/math/cholesky/op_host/op_api/	88	- ops/ops-math/math/cholesky/op_api/
90	- ops/ops-math/math/cholesky/op_kernel/	89	- ops/ops-math/math/cholesky/op_kernel/
91	- ops/ops-math/math/complex/op_api/	90	- ops/ops-math/math/complex/op_api/
92	- ops/ops-math/math/complex/op_host/arch35/	91	- ops/ops-math/math/complex/op_host/arch35/
	@@ -95,16 +94,16 @@ math@ops-math:
95	- ops/ops-math/math/cosh/op_api/	94	- ops/ops-math/math/cosh/op_api/
96	- ops/ops-math/math/cross/op_api/	95	- ops/ops-math/math/cross/op_api/
97	- ops/ops-math/math/cross/op_host/arch35/	96	- ops/ops-math/math/cross/op_host/arch35/
98	- ops/ops-math/math/cummax/op_host/op_api/	97	- ops/ops-math/math/cummax/op_api/
99	- ops/ops-math/math/cummin/op_api/	98	- ops/ops-math/math/cummin/op_api/
100	- ops/ops-math/math/cummin/op_host/arch35/	99	- ops/ops-math/math/cummin/op_host/arch35/
101	- ops/ops-math/math/cumprod/op_host/op_api/	100	- ops/ops-math/math/cumprod/op_api/
102	- ops/ops-math/math/cumsum/op_api/	101	- ops/ops-math/math/cumsum/op_api/
103	- ops/ops-math/math/div/op_api/	102	- ops/ops-math/math/div/op_api/
104	- ops/ops-math/math/dot/op_api/	103	- ops/ops-math/math/dot/op_api/
105	- ops/ops-math/math/equal/op_api/	104	- ops/ops-math/math/equal/op_api/
106	- ops/ops-math/math/erf/op_api/	105	- ops/ops-math/math/erf/op_api/
107	- ops/ops-math/math/erfc/op_host/op_api/	106	- ops/ops-math/math/erfc/op_api/
108	- ops/ops-math/math/exp/op_api/	107	- ops/ops-math/math/exp/op_api/
109	- ops/ops-math/math/expand/op_api/	108	- ops/ops-math/math/expand/op_api/
110	- ops/ops-math/math/expint/op_kernel/	109	- ops/ops-math/math/expint/op_kernel/
	@@ -120,6 +119,7 @@ math@ops-math:
120	- ops/ops-math/math/grouped_bias_add_grad/op_api/	119	- ops/ops-math/math/grouped_bias_add_grad/op_api/
121	- ops/ops-math/math/grouped_bias_add_grad/op_host/arch32/	120	- ops/ops-math/math/grouped_bias_add_grad/op_host/arch32/
122	- ops/ops-math/math/grouped_bias_add_grad/op_kernel/arch32/	121	- ops/ops-math/math/grouped_bias_add_grad/op_kernel/arch32/
		122	- ops/ops-math/math/histogram_v2/op_api/
123	- ops/ops-math/math/histogram_v2/op_kernel/	123	- ops/ops-math/math/histogram_v2/op_kernel/
124	- ops/ops-math/math/invert/op_api/	124	- ops/ops-math/math/invert/op_api/
125	- ops/ops-math/math/is_close/op_api/	125	- ops/ops-math/math/is_close/op_api/
	@@ -138,7 +138,7 @@ math@ops-math:
138	- ops/ops-math/math/less/op_api/	138	- ops/ops-math/math/less/op_api/
139	- ops/ops-math/math/less_equal/op_api/	139	- ops/ops-math/math/less_equal/op_api/
140	- ops/ops-math/math/lin_space/op_host/	140	- ops/ops-math/math/lin_space/op_host/
141	- ops/ops-math/math/lin_space/op_host/op_api/	141	- ops/ops-math/math/lin_space/op_api/
142	- ops/ops-math/math/lin_space/op_kernel/	142	- ops/ops-math/math/lin_space/op_kernel/
143	- ops/ops-math/math/log/op_api/	143	- ops/ops-math/math/log/op_api/
144	- ops/ops-math/math/log_add_exp/op_api/	144	- ops/ops-math/math/log_add_exp/op_api/
	@@ -158,19 +158,19 @@ math@ops-math:
158	- ops/ops-math/math/nan_to_num/op_api/	158	- ops/ops-math/math/nan_to_num/op_api/
159	- ops/ops-math/math/neg/op_api/	159	- ops/ops-math/math/neg/op_api/
160	- ops/ops-math/math/non_finite_check/op_host/	160	- ops/ops-math/math/non_finite_check/op_host/
161	- ops/ops-math/math/non_finite_check/op_host/op_api/	161	- ops/ops-math/math/non_finite_check/op_api/
162	- ops/ops-math/math/non_finite_check/op_kernel/	162	- ops/ops-math/math/non_finite_check/op_kernel/
163	- ops/ops-math/math/not_equal/op_api/	163	- ops/ops-math/math/not_equal/op_api/
164	- ops/ops-math/math/one_hot/op_api/	164	- ops/ops-math/math/one_hot/op_api/
165	- ops/ops-math/math/ones_like/op_api/	165	- ops/ops-math/math/ones_like/op_api/
166	- ops/ops-math/math/ones_like/op_kernel/	166	- ops/ops-math/math/ones_like/op_kernel/
167	- ops/ops-math/math/pdist/op_host/op_api/	167	- ops/ops-math/math/pdist/op_api/
168	- ops/ops-math/math/polar/op_api/	168	- ops/ops-math/math/polar/op_api/
169	- ops/ops-math/math/polar/op_host/arch35/	169	- ops/ops-math/math/polar/op_host/arch35/
170	- ops/ops-math/math/polar/op_kernel/	170	- ops/ops-math/math/polar/op_kernel/
171	- ops/ops-math/math/pow/op_api/	171	- ops/ops-math/math/pow/op_api/
172	- ops/ops-math/math/pows/op_host/	172	- ops/ops-math/math/pows/op_host/
173	- ops/ops-math/math/pows/op_host/op_api/	173	- ops/ops-math/math/pows/op_api/
174	- ops/ops-math/math/pows/op_kernel/	174	- ops/ops-math/math/pows/op_kernel/
175	- ops/ops-math/math/radix_top_k/	175	- ops/ops-math/math/radix_top_k/
176	- ops/ops-math/math/range/op_api/	176	- ops/ops-math/math/range/op_api/
	@@ -185,19 +185,19 @@ math@ops-math:
185	- ops/ops-math/math/reduce_max/op_api/	185	- ops/ops-math/math/reduce_max/op_api/
186	- ops/ops-math/math/reduce_mean/op_api/	186	- ops/ops-math/math/reduce_mean/op_api/
187	- ops/ops-math/math/reduce_mean_with_count/op_host/arch35/	187	- ops/ops-math/math/reduce_mean_with_count/op_host/arch35/
188	- ops/ops-math/math/reduce_mean_with_count/op_host/op_api/	188	- ops/ops-math/math/reduce_mean_with_count/op_api/
189	- ops/ops-math/math/reduce_mean_with_count/op_kernel/	189	- ops/ops-math/math/reduce_mean_with_count/op_kernel/
190	- ops/ops-math/math/reduce_min/op_api/	190	- ops/ops-math/math/reduce_min/op_api/
191	- ops/ops-math/math/reduce_nansum/op_api/	191	- ops/ops-math/math/reduce_nansum/op_api/
192	- ops/ops-math/math/reduce_nansum/op_host/arch35/	192	- ops/ops-math/math/reduce_nansum/op_host/arch35/
193	- ops/ops-math/math/reduce_prod/op_api/	193	- ops/ops-math/math/reduce_prod/op_api/
194	- ops/ops-math/math/reduce_std_v2/op_api/	194	- ops/ops-math/math/reduce_std_v2/op_api/
195	- ops/ops-math/math/reduce_std_v2_update/op_host/op_api/	195	- ops/ops-math/math/reduce_std_v2_update/op_api/
196	- ops/ops-math/math/reduce_std_with_mean/op_host/op_api/	196	- ops/ops-math/math/reduce_std_with_mean/op_api/
197	- ops/ops-math/math/reduce_sum/op_api/	197	- ops/ops-math/math/reduce_sum/op_api/
198	- ops/ops-math/math/reduce_var/op_api/	198	- ops/ops-math/math/reduce_var/op_api/
199	- ops/ops-math/math/rfft1_d/op_host/	199	- ops/ops-math/math/rfft1_d/op_host/
200	- ops/ops-math/math/rfft1_d/op_host/op_api/	200	- ops/ops-math/math/rfft1_d/op_api/
201	- ops/ops-math/math/rfft1_d/op_kernel/	201	- ops/ops-math/math/rfft1_d/op_kernel/
202	- ops/ops-math/math/right_shift/op_api/	202	- ops/ops-math/math/right_shift/op_api/
203	- ops/ops-math/math/round/op_api/	203	- ops/ops-math/math/round/op_api/
	@@ -208,14 +208,14 @@ math@ops-math:
208	- ops/ops-math/math/shape/op_host/	208	- ops/ops-math/math/shape/op_host/
209	- ops/ops-math/math/sign/op_api/	209	- ops/ops-math/math/sign/op_api/
210	- ops/ops-math/math/sign/op_kernel/	210	- ops/ops-math/math/sign/op_kernel/
211	- ops/ops-math/math/sign_bits_pack/op_host/op_api/	211	- ops/ops-math/math/sign_bits_pack/op_api/
212	- ops/ops-math/math/sign_bits_unpack/op_host/op_api/	212	- ops/ops-math/math/sign_bits_unpack/op_api/
213	- ops/ops-math/math/signbit/op_api/	213	- ops/ops-math/math/signbit/op_api/
214	- ops/ops-math/math/sin/op_api/	214	- ops/ops-math/math/sin/op_api/
215	- ops/ops-math/math/sinc/op_api/	215	- ops/ops-math/math/sinc/op_api/
216	- ops/ops-math/math/sinh/op_api/	216	- ops/ops-math/math/sinh/op_api/
217	- ops/ops-math/math/sinkhorn/op_host/	217	- ops/ops-math/math/sinkhorn/op_host/
218	- ops/ops-math/math/sinkhorn/op_host/op_api/	218	- ops/ops-math/math/sinkhorn/op_api/
219	- ops/ops-math/math/sinkhorn/op_kernel/	219	- ops/ops-math/math/sinkhorn/op_kernel/
220	- ops/ops-math/math/sort/op_api/	220	- ops/ops-math/math/sort/op_api/
221	- ops/ops-math/math/sqrt/op_api/	221	- ops/ops-math/math/sqrt/op_api/
	@@ -227,7 +227,7 @@ math@ops-math:
227	- ops/ops-math/math/tanh_grad/op_api/	227	- ops/ops-math/math/tanh_grad/op_api/
228	- ops/ops-math/math/tensor_equal/op_api/	228	- ops/ops-math/math/tensor_equal/op_api/
229	- ops/ops-math/math/tensor_equal/op_host/op_api/	229	- ops/ops-math/math/tensor_equal/op_host/op_api/
230	- ops/ops-math/math/topk/op_host/op_api/	230	- ops/ops-math/math/topk/op_api/
231	- ops/ops-math/math/trunc/op_api/	231	- ops/ops-math/math/trunc/op_api/
232	- ops/ops-math/math/truncate_div/op_api/	232	- ops/ops-math/math/truncate_div/op_api/
233	- ops/ops-math/math/xlogy/op_api/	233	- ops/ops-math/math/xlogy/op_api/
	@@ -467,8 +467,8 @@ HPTG5@ops-math:
467	- ops/ops-math/math/histogram_v2/op_host/histogram_v2_op_tiling.cpp	467	- ops/ops-math/math/histogram_v2/op_host/histogram_v2_op_tiling.cpp
468	- ops/ops-math/math/histogram_v2/op_host/histogram_v2_simt_tiling.cpp	468	- ops/ops-math/math/histogram_v2/op_host/histogram_v2_simt_tiling.cpp
469	- ops/ops-math/math/histogram_v2/op_host/histogram_v2_tiling.h	469	- ops/ops-math/math/histogram_v2/op_host/histogram_v2_tiling.h
470	- ops/ops-math/math/histogram_v2/op_host/op_api/aclnn_histc.cpp	470	- ops/ops-math/math/histogram_v2/op_api/aclnn_histc.cpp
471	- ops/ops-math/math/histogram_v2/op_host/op_api/histogram.cpp	471	- ops/ops-math/math/histogram_v2/op_api/histogram.cpp
472	opensource_style: null	472	opensource_style: null
473	kernel_style: null	473	kernel_style: null
474	unrelease:	474	unrelease: