Star889
1799
代码
代码
Issues260
Pull Requests295
Actions
项目讨论
Wiki
分析
Star889
1799
已合并
修复matmul ut 编译失败的问题 #8409
yang-di52创建于 24 天前
修复matmul ut 编译失败的问题 #8409
已合并
yang-di52创建于 24 天前
从yang-di52/ops-nnmaster合入到cann/ops-nnmaster
共 7 个文件变更+7-771
Mbuild.sh+2-2
@@ -1469,7 +1469,7 @@ build_ut() {
1469 else1469 else
1470 cmake ${CMAKE_ARGS} -DASCEND_OP_NAME=${ut_args[1]} -DASCEND_COMPILE_OPS=${ut_args[2]} -DASCEND_COMPUTE_UNIT=${ut_args[3]} ..1470 cmake ${CMAKE_ARGS} -DASCEND_OP_NAME=${ut_args[1]} -DASCEND_COMPILE_OPS=${ut_args[2]} -DASCEND_COMPUTE_UNIT=${ut_args[3]} ..
1471 fi1471 fi
1472- cmake --build . --target ${REPOSITORY_NAME}_${ut_args[0]} -- ${VERBOSE} -j $THREAD_NUM || ut_build_failed=11472+ cmake --build . --target ${REPOSITORY_NAME}_${ut_args[0]} -- ${VERBOSE} -k -j $THREAD_NUM || ut_build_failed=1
1473 else1473 else
1474 echo "Not need trigger Ut: ${ut_args[0]}"1474 echo "Not need trigger Ut: ${ut_args[0]}"
1475 fi1475 fi
@@ -1484,7 +1484,7 @@ build_ut() {
1484 cmake ${CMAKE_ARGS} ..1484 cmake ${CMAKE_ARGS} ..
1485 fi1485 fi
1486 fi1486 fi
1487- cmake --build . --target ${UT_TARGES[@]} -- ${VERBOSE} -j $THREAD_NUM || ut_build_failed=11487+ cmake --build . --target ${UT_TARGES[@]} -- ${VERBOSE} -k -j $THREAD_NUM || ut_build_failed=1
1488 fi1488 fi
1489 1489 
1490 if [[ "$ENABLE_COVERAGE" =~ "TRUE" && "$enable_cov" == "TRUE" ]]; then1490 if [[ "$ENABLE_COVERAGE" =~ "TRUE" && "$enable_cov" == "TRUE" ]]; then
Rmatmul/addmv/tests/ut/op_host/op_api/test_aclnn_addmv.cpp→matmul/addmv/tests/ut/op_api/test_aclnn_addmv.cpp+2-2
@@ -11,7 +11,7 @@
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_addmv.h"14+#include "../../../op_host/op_api/aclnn_addmv.h"
15#include "op_api/op_api_def.h"15#include "op_api/op_api_def.h"
16 16 
17#include "op_api_ut_common/op_api_ut.h"17#include "op_api_ut_common/op_api_ut.h"
@@ -318,4 +318,4 @@ TEST_F(l2_addmv_test, mat_empty_use_fp32_add)
318 318 
319 // SAMPLE: precision simulate319 // SAMPLE: precision simulate
320 ut.TestPrecision();320 ut.TestPrecision();
321-}321+}
Dmatmul/addmv/tests/ut/op_host/test_aclnn_addmv.cpp+0-229
@@ -1,229 +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
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-#include <array>
12-#include <vector>
13-#include "gtest/gtest.h"
14- 
15-#include "../../../op_host/op_api/aclnn_addmv.h"
16-#include "op_api/op_api_def.h"
17- 
18-#include "op_api_ut_common/op_api_ut.h"
19-#include "op_api_ut_common/scalar_desc.h"
20-#include "op_api_ut_common/tensor_desc.h"
21- 
22-using namespace std;
23-using namespace op;
24- 
25-class l2_addmv_test : public testing::Test {
26-protected:
27- static void SetUpTestCase() { cout << "addmv_test SetUp" << endl; }
28- 
29- static void TearDownTestCase() { cout << "addmv_test TearDown" << endl; }
30-};
31- 
32-// 输入nullptr
33-TEST_F(l2_addmv_test, input_nullptr)
34-{
35- auto input_tensor_desc = TensorDesc({10}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
36- auto mat_tensor_desc = TensorDesc({10, 5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
37- auto vec_tensor_desc = TensorDesc({5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
38- auto alpha_scalar_desc = ScalarDesc(5.9f);
39- auto beta_scalar_desc = ScalarDesc(4.9f);
40- 
41- auto out_tensor_desc = TensorDesc(input_tensor_desc).Precision(0.0001, 0.0001);
42- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
43- 
44- uint64_t workspace_size = 0;
45- 
46- auto ut = OP_API_UT(aclnnAddmv,
47- INPUT(nullptr, mat_tensor_desc, vec_tensor_desc, alpha_scalar_desc, beta_scalar_desc),
48- OUTPUT(out_tensor_desc), cubeMathType);
49- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
50- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
51- 
52- auto ut1 = OP_API_UT(aclnnAddmv,
53- INPUT(input_tensor_desc, nullptr, vec_tensor_desc, alpha_scalar_desc, beta_scalar_desc),
54- OUTPUT(out_tensor_desc), cubeMathType);
55- aclRet = ut1.TestGetWorkspaceSize(&workspace_size);
56- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
57- 
58- auto ut2 = OP_API_UT(aclnnAddmv,
59- INPUT(input_tensor_desc, mat_tensor_desc, nullptr, alpha_scalar_desc, beta_scalar_desc),
60- OUTPUT(out_tensor_desc), cubeMathType);
61- aclRet = ut2.TestGetWorkspaceSize(&workspace_size);
62- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
63- 
64- auto ut3 = OP_API_UT(aclnnAddmv,
65- INPUT(input_tensor_desc, mat_tensor_desc, vec_tensor_desc, nullptr, beta_scalar_desc),
66- OUTPUT(out_tensor_desc), cubeMathType);
67- aclRet = ut3.TestGetWorkspaceSize(&workspace_size);
68- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
69- 
70- auto ut4 = OP_API_UT(aclnnAddmv,
71- INPUT(input_tensor_desc, mat_tensor_desc, vec_tensor_desc, alpha_scalar_desc, nullptr),
72- OUTPUT(out_tensor_desc), cubeMathType);
73- aclRet = ut4.TestGetWorkspaceSize(&workspace_size);
74- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
75- 
76- auto ut5 = OP_API_UT(
77- aclnnAddmv, INPUT(input_tensor_desc, mat_tensor_desc, vec_tensor_desc, alpha_scalar_desc, beta_scalar_desc),
78- OUTPUT(nullptr), cubeMathType);
79- aclRet = ut5.TestGetWorkspaceSize(&workspace_size);
80- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
81-}
82- 
83-// 输入shape校验
84-TEST_F(l2_addmv_test, input_shape_check)
85-{
86- auto input_tensor_desc = TensorDesc({10, 10}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
87- auto mat_tensor_desc = TensorDesc({10, 5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
88- auto vec_tensor_desc = TensorDesc({5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
89- auto alpha_scalar_desc = ScalarDesc(5.9f);
90- auto beta_scalar_desc = ScalarDesc(4.9f);
91- 
92- auto out_tensor_desc = TensorDesc(input_tensor_desc).Precision(0.0001, 0.0001);
93- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
94- uint64_t workspace_size = 0;
95- 
96- auto ut = OP_API_UT(aclnnAddmv,
97- INPUT(input_tensor_desc, mat_tensor_desc, vec_tensor_desc, alpha_scalar_desc, beta_scalar_desc),
98- OUTPUT(out_tensor_desc), cubeMathType);
99- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
100- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
101- 
102- input_tensor_desc = TensorDesc({10}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
103- mat_tensor_desc = TensorDesc({8, 5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-2, 2);
104- auto ut1 = OP_API_UT(
105- aclnnAddmv, INPUT(input_tensor_desc, mat_tensor_desc, vec_tensor_desc, alpha_scalar_desc, beta_scalar_desc),
106- OUTPUT(out_tensor_desc), cubeMathType);
107- aclRet = ut1.TestGetWorkspaceSize(&workspace_size);
108- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
109-}
110- 
111-TEST_F(l2_addmv_test, alpha_0_beta_0)
112-{
113- auto input_tensor_desc = TensorDesc({10}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
114- auto mat_tensor_desc = TensorDesc({10, 5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
115- auto vec_tensor_desc = TensorDesc({5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
116- auto alpha_scalar_desc = ScalarDesc(0);
117- auto beta_scalar_desc = ScalarDesc(0);
118- 
119- auto out_tensor_desc = TensorDesc(input_tensor_desc).Precision(0.005, 0.005);
120- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
121- 
122- auto ut = OP_API_UT(aclnnAddmv,
123- INPUT(input_tensor_desc, mat_tensor_desc, vec_tensor_desc, alpha_scalar_desc, beta_scalar_desc),
124- OUTPUT(out_tensor_desc), cubeMathType);
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- // SAMPLE: precision simulate
132- ut.TestPrecision();
133-}
134- 
135-TEST_F(l2_addmv_test, input_empty)
136-{
137- auto input_tensor_desc = TensorDesc({0}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
138- auto mat_tensor_desc = TensorDesc({0, 5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
139- auto vec_tensor_desc = TensorDesc({5}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
140- auto alpha_scalar_desc = ScalarDesc(1.0f);
141- auto beta_scalar_desc = ScalarDesc(1.0f);
142- 
143- auto out_tensor_desc = TensorDesc(input_tensor_desc).Precision(0.005, 0.005);
144- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
145- 
146- auto ut = OP_API_UT(aclnnAddmv,
147- INPUT(input_tensor_desc, mat_tensor_desc, vec_tensor_desc, alpha_scalar_desc, beta_scalar_desc),
148- OUTPUT(out_tensor_desc), cubeMathType);
149- 
150- // SAMPLE: only test GetWorkspaceSize
151- uint64_t workspace_size = 0;
152- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
153- EXPECT_EQ(aclRet, ACL_SUCCESS);
154- 
155- // SAMPLE: precision simulate
156- ut.TestPrecision();
157-}
158- 
159-TEST_F(l2_addmv_test, mat_empty)
160-{
161- auto input_tensor_desc = TensorDesc({10}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
162- auto mat_tensor_desc = TensorDesc({10, 0}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
163- auto vec_tensor_desc = TensorDesc({0}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
164- auto alpha_scalar_desc = ScalarDesc(1.0f);
165- auto beta_scalar_desc = ScalarDesc(1.0f);
166- 
167- auto out_tensor_desc = TensorDesc(input_tensor_desc).Precision(0.005, 0.005);
168- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
169- 
170- auto ut = OP_API_UT(aclnnAddmv,
171- INPUT(input_tensor_desc, mat_tensor_desc, vec_tensor_desc, alpha_scalar_desc, beta_scalar_desc),
172- OUTPUT(out_tensor_desc), cubeMathType);
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- // SAMPLE: precision simulate
180- ut.TestPrecision();
181-}
182- 
183-TEST_F(l2_addmv_test, mat_empty_keep_dtype)
184-{
185- auto input_tensor_desc = TensorDesc({10}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
186- auto mat_tensor_desc = TensorDesc({10, 0}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
187- auto vec_tensor_desc = TensorDesc({0}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
188- auto alpha_scalar_desc = ScalarDesc(1.0f);
189- auto beta_scalar_desc = ScalarDesc(1.0f);
190- 
191- auto out_tensor_desc = TensorDesc(input_tensor_desc).Precision(0.005, 0.005);
192- int8_t cubeMathType = KEEP_DTYPE;
193- 
194- auto ut = OP_API_UT(aclnnAddmv,
195- INPUT(input_tensor_desc, mat_tensor_desc, vec_tensor_desc, alpha_scalar_desc, beta_scalar_desc),
196- OUTPUT(out_tensor_desc), cubeMathType);
197- 
198- // SAMPLE: only test GetWorkspaceSize
199- uint64_t workspace_size = 0;
200- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
201- EXPECT_EQ(aclRet, ACL_SUCCESS);
202- 
203- // SAMPLE: precision simulate
204- ut.TestPrecision();
205-}
206- 
207-TEST_F(l2_addmv_test, mat_empty_use_fp32_add)
208-{
209- auto input_tensor_desc = TensorDesc({10}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
210- auto mat_tensor_desc = TensorDesc({10, 0}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
211- auto vec_tensor_desc = TensorDesc({0}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
212- auto alpha_scalar_desc = ScalarDesc(1.0f);
213- auto beta_scalar_desc = ScalarDesc(1.0f);
214- 
215- auto out_tensor_desc = TensorDesc(input_tensor_desc).Precision(0.005, 0.005);
216- int8_t cubeMathType = USE_FP32_ADD;
217- 
218- auto ut = OP_API_UT(aclnnAddmv,
219- INPUT(input_tensor_desc, mat_tensor_desc, vec_tensor_desc, alpha_scalar_desc, beta_scalar_desc),
220- OUTPUT(out_tensor_desc), cubeMathType);
221- 
222- // SAMPLE: only test GetWorkspaceSize
223- uint64_t workspace_size = 0;
224- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
225- EXPECT_EQ(aclRet, ACL_SUCCESS);
226- 
227- // SAMPLE: precision simulate
228- ut.TestPrecision();
229-}
Rmatmul/gemm/tests/ut/op_host/op_api/test_aclnn_gemm.cpp→matmul/gemm/tests/ut/op_api/test_aclnn_gemm.cpp+1-1
@@ -12,7 +12,7 @@
12#include <float.h>12#include <float.h>
13#include "gtest/gtest.h"13#include "gtest/gtest.h"
14 14 
15-#include "../../../../op_host/op_api/aclnn_gemm.h"15+#include "../../../op_host/op_api/aclnn_gemm.h"
16#include "op_api/op_api_def.h"16#include "op_api/op_api_def.h"
17 17 
18#include "op_api_ut_common/tensor_desc.h"18#include "op_api_ut_common/tensor_desc.h"
Dmatmul/gemm/tests/ut/op_host/test_aclnn_gemm.cpp+0-362
@@ -1,362 +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 <vector>
11-#include <array>
12-#include <float.h>
13-#include "gtest/gtest.h"
14- 
15-#include "../../../op_host/op_api/aclnn_gemm.h"
16-#include "op_api/op_api_def.h"
17- 
18-#include "op_api_ut_common/tensor_desc.h"
19-#include "op_api_ut_common/scalar_desc.h"
20-#include "op_api_ut_common/op_api_ut.h"
21- 
22-using namespace std;
23-using namespace op;
24- 
25-class l2_gemm_test : public testing::Test {
26-protected:
27- static void SetUpTestCase() { cout << "gemm_test SetUp" << endl; }
28- 
29- static void TearDownTestCase() { cout << "gemm_test TearDown" << endl; }
30- 
31- void test_run(vector<int64_t> ADims, aclDataType ADtype, aclFormat AFormat, vector<int64_t> ARange,
32- vector<int64_t> BDims, aclDataType BDtype, aclFormat BFormat, vector<int64_t> BRange,
33- vector<int64_t> CDims, aclDataType CDtype, aclFormat CFormat, vector<int64_t> CRange,
34- vector<int64_t> outDims, aclDataType outDtype, aclFormat outFormat, float alpha, float beta,
35- int64_t transA, int64_t transB, int8_t cubeMathType)
36- {
37- auto A = TensorDesc(ADims, ADtype, AFormat).ValueRange(ARange[0], ARange[1]);
38- auto B = TensorDesc(BDims, BDtype, BFormat).ValueRange(BRange[0], BRange[1]);
39- auto C = TensorDesc(CDims, CDtype, CFormat).ValueRange(CRange[0], CRange[1]);
40- auto out = TensorDesc(outDims, outDtype, outFormat).Precision(0.00001, 0.00001);
41- 
42- auto ut = OP_API_UT(aclnnGemm, INPUT(A, B, C, alpha, beta, transA, transB), OUTPUT(out), cubeMathType);
43- uint64_t workspaceSize = 0;
44- aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
45- EXPECT_EQ(getWorkspaceResult, ACL_SUCCESS);
46- }
47- 
48- void test_run_inval(vector<int64_t> ADims, aclDataType ADtype, aclFormat AFormat, vector<int64_t> ARange,
49- vector<int64_t> BDims, aclDataType BDtype, aclFormat BFormat, vector<int64_t> BRange,
50- vector<int64_t> CDims, aclDataType CDtype, aclFormat CFormat, vector<int64_t> CRange,
51- vector<int64_t> outDims, aclDataType outDtype, aclFormat outFormat, float alpha, float beta,
52- int64_t transA, int64_t transB, int8_t cubeMathType)
53- {
54- auto A = TensorDesc(ADims, ADtype, AFormat).ValueRange(ARange[0], ARange[1]);
55- auto B = TensorDesc(BDims, BDtype, BFormat).ValueRange(BRange[0], BRange[1]);
56- auto C = TensorDesc(CDims, CDtype, CFormat).ValueRange(CRange[0], CRange[1]);
57- auto out = TensorDesc(outDims, outDtype, outFormat).Precision(0.00001, 0.00001);
58- 
59- auto ut = OP_API_UT(aclnnGemm, INPUT(A, B, C, alpha, beta, transA, transB), OUTPUT(out), cubeMathType);
60- uint64_t workspaceSize = 0;
61- aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
62- EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
63- }
64-};
65- 
66-// 异常流程，不支持的数据类型
67-TEST_F(l2_gemm_test, case_various_dtype_invalid)
68-{
69- float alpha = 2.0;
70- float beta = 2.0;
71- int64_t transA = 0;
72- int64_t transB = 0;
73- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
74- test_run_inval({16, 16}, ACL_INT16, ACL_FORMAT_ND, {0, 2}, {16, 16}, ACL_INT16, ACL_FORMAT_ND, {0, 2}, {16, 16},
75- ACL_INT16, ACL_FORMAT_ND, {0, 2}, {16, 16}, ACL_INT16, ACL_FORMAT_ND, alpha, beta, transA, transB,
76- cubeMathType);
77- test_run_inval({16, 16}, ACL_UINT16, ACL_FORMAT_ND, {0, 2}, {16, 16}, ACL_UINT16, ACL_FORMAT_ND, {0, 2}, {16, 16},
78- ACL_UINT16, ACL_FORMAT_ND, {0, 2}, {16, 16}, ACL_UINT16, ACL_FORMAT_ND, alpha, beta, transA, transB,
79- cubeMathType);
80-}
81- 
82-// C 空指针
83-TEST_F(l2_gemm_test, case_empty_tensor_input_1)
84-{
85- auto A = TensorDesc({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
86- auto B = TensorDesc({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
87- auto out = TensorDesc({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND).Precision(0.001, 0.001);
88- float alpha = 1.0;
89- float beta = 1.0;
90- int64_t transA = 0;
91- int64_t transB = 0;
92- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
93- 
94- auto ut = OP_API_UT(aclnnGemm, INPUT(A, B, nullptr, alpha, beta, transA, transB), OUTPUT(out), cubeMathType);
95- 
96- uint64_t workspace_size = 0;
97- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
98- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
99-}
100- 
101-// A空指针
102-TEST_F(l2_gemm_test, case_empty_tensor_input_2)
103-{
104- auto B = TensorDesc({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
105- auto C = TensorDesc({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
106- auto out = TensorDesc({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND).Precision(0.001, 0.001);
107- float alpha = 1.0;
108- float beta = 1.0;
109- int64_t transA = 0;
110- int64_t transB = 0;
111- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
112- 
113- auto ut = OP_API_UT(aclnnGemm, INPUT(nullptr, B, C, alpha, beta, transA, transB), OUTPUT(out), cubeMathType);
114- 
115- uint64_t workspace_size = 0;
116- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
117- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
118-}
119- 
120-// B空指针
121-TEST_F(l2_gemm_test, case_empty_tensor_input_3)
122-{
123- auto A = TensorDesc({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
124- auto C = TensorDesc({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
125- auto out = TensorDesc({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND).Precision(0.001, 0.001);
126- float alpha = 1.0;
127- float beta = 1.0;
128- int64_t transA = 0;
129- int64_t transB = 0;
130- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
131- 
132- auto ut = OP_API_UT(aclnnGemm, INPUT(A, nullptr, C, alpha, beta, transA, transB), OUTPUT(out), cubeMathType);
133- 
134- uint64_t workspace_size = 0;
135- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
136- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
137-}
138- 
139-// out空指针
140-TEST_F(l2_gemm_test, case_empty_tensor_out)
141-{
142- auto A = TensorDesc({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
143- auto B = TensorDesc({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
144- auto C = TensorDesc({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(0, 2);
145- auto out = TensorDesc({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND).Precision(0.001, 0.001);
146- float alpha = 1.0;
147- float beta = 1.0;
148- int64_t transA = 0;
149- int64_t transB = 0;
150- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
151- 
152- auto ut = OP_API_UT(aclnnGemm, INPUT(A, B, C, alpha, beta, transA, transB), OUTPUT(nullptr), cubeMathType);
153- 
154- uint64_t workspace_size = 0;
155- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
156- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_NULLPTR);
157-}
158- 
159-// A不是2维
160-TEST_F(l2_gemm_test, case_A_dim_not_2)
161-{
162- auto A = TensorDesc({16, 16, 16}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
163- auto B = TensorDesc({16, 16}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
164- auto C = TensorDesc({16, 16}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
165- auto out = TensorDesc({16, 16}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
166- float alpha = 1.0;
167- float beta = 1.0;
168- int64_t transA = 0;
169- int64_t transB = 0;
170- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
171- 
172- auto ut = OP_API_UT(aclnnGemm, INPUT(A, B, C, alpha, beta, transA, transB), OUTPUT(out), cubeMathType);
173- 
174- // SAMPLE: only test GetWorkspaceSize
175- uint64_t workspace_size = 0;
176- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
177- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
178-}
179- 
180-// A, B不满足相乘条件
181-TEST_F(l2_gemm_test, case_cannot_matmul)
182-{
183- auto A = TensorDesc({16, 17}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
184- auto B = TensorDesc({16, 16}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
185- auto C = TensorDesc({16, 16}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
186- auto out = TensorDesc({16, 16}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
187- float alpha = 1.0;
188- float beta = 1.0;
189- int64_t transA = 0;
190- int64_t transB = 0;
191- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
192- 
193- auto ut = OP_API_UT(aclnnGemm, INPUT(A, B, C, alpha, beta, transA, transB), OUTPUT(out), cubeMathType);
194- 
195- // SAMPLE: only test GetWorkspaceSize
196- uint64_t workspace_size = 0;
197- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
198- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
199-}
200- 
201-// C 和 A@B无法broadcast
202-TEST_F(l2_gemm_test, case_cannot_axpy)
203-{
204- auto A = TensorDesc({16, 16}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
205- auto B = TensorDesc({16, 16}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
206- auto C = TensorDesc({17, 17}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
207- auto out = TensorDesc({16, 16}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
208- float alpha = 1.0;
209- float beta = 1.0;
210- int64_t transA = 0;
211- int64_t transB = 0;
212- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
213- 
214- auto ut = OP_API_UT(aclnnGemm, INPUT(A, B, C, alpha, beta, transA, transB), OUTPUT(out), cubeMathType);
215- 
216- // SAMPLE: only test GetWorkspaceSize
217- uint64_t workspace_size = 0;
218- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
219- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
220-}
221- 
222-// C 和 A@B无法broadcast
223-TEST_F(l2_gemm_test, case_cannot_axpy2)
224-{
225- auto A = TensorDesc({14, 13}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
226- auto B = TensorDesc({15, 14}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
227- auto C = TensorDesc({17, 17}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
228- auto out = TensorDesc({16, 16}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
229- float alpha = 1.0;
230- float beta = 1.0;
231- int64_t transA = 1;
232- int64_t transB = 1;
233- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
234- 
235- auto ut = OP_API_UT(aclnnGemm, INPUT(A, B, C, alpha, beta, transA, transB), OUTPUT(out), cubeMathType);
236- 
237- // SAMPLE: only test GetWorkspaceSize
238- uint64_t workspace_size = 0;
239- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
240- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
241-}
242- 
243-// 空tensor1
244-TEST_F(l2_gemm_test, case_empty_tensor_1)
245-{
246- auto A = TensorDesc({4, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
247- auto B = TensorDesc({0, 4}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
248- auto C = TensorDesc({4, 4}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
249- auto out = TensorDesc({4, 4}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
250- float alpha = 1.0;
251- float beta = 1.0;
252- int64_t transA = 0;
253- int64_t transB = 0;
254- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
255- 
256- auto ut = OP_API_UT(aclnnGemm, INPUT(A, B, C, alpha, beta, transA, transB), OUTPUT(out), cubeMathType);
257- 
258- uint64_t workspace_size = 0;
259- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
260- EXPECT_EQ(aclRet, ACL_SUCCESS);
261-}
262- 
263-// 空tensor2
264-TEST_F(l2_gemm_test, case_empty_tensor_2)
265-{
266- auto A = TensorDesc({3, 1}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
267- auto B = TensorDesc({1, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
268- auto C = TensorDesc({3, 0}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
269- auto out = TensorDesc({3, 0}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
270- float alpha = 1.0;
271- float beta = 1.0;
272- int64_t transA = 0;
273- int64_t transB = 0;
274- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
275- 
276- auto ut = OP_API_UT(aclnnGemm, INPUT(A, B, C, alpha, beta, transA, transB), OUTPUT(out), cubeMathType);
277- 
278- uint64_t workspace_size = 0;
279- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
280- EXPECT_EQ(aclRet, ACL_SUCCESS);
281-}
282- 
283-TEST_F(l2_gemm_test, test_hf32_trans)
284-{
285- auto A = TensorDesc({14, 13}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
286- auto B = TensorDesc({15, 14}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
287- auto C = TensorDesc({13, 15}, ACL_FLOAT, ACL_FORMAT_ND).ValueRange(0, 2);
288- auto out = TensorDesc({15, 15}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.001, 0.001);
289- float alpha = 1.0;
290- float beta = 1.0;
291- int64_t transA = 1;
292- int64_t transB = 1;
293- int8_t cubeMathType = 3;
294- 
295- auto ut = OP_API_UT(aclnnGemm, INPUT(A, B, C, alpha, beta, transA, transB), OUTPUT(out), cubeMathType);
296- 
297- // SAMPLE: only test GetWorkspaceSize
298- uint64_t workspace_size = 0;
299- aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspace_size);
300- EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
301-}
302- 
303-// 空tensor混合场景
304-TEST_F(l2_gemm_test, case_empty_tensor_3)
305-{
306- float alpha = 2.0;
307- float beta = 2.0;
308- int64_t transA = 0;
309- int64_t transB = 0;
310- int8_t cubeMathType = ALLOW_FP32_DOWN_PRECISION;
311- 
312- // C: 2 x 2, A: 2 x 0, B: 0 x 2, out: 2 x 2
313- test_run({2, 0}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {0, 2}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {2, 2}, ACL_FLOAT,
314- ACL_FORMAT_ND, {-5, 5}, {2, 2}, ACL_FLOAT, ACL_FORMAT_ND, alpha, beta, transA, transB, cubeMathType);
315- 
316- // C: 1 / 1 x 1, A: 2 x 0, B: 0 x 2, out: 2 x 2
317- test_run({2, 0}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {0, 2}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {1}, ACL_FLOAT,
318- ACL_FORMAT_ND, {-5, 5}, {2, 2}, ACL_FLOAT, ACL_FORMAT_ND, alpha, beta, transA, transB, cubeMathType);
319- test_run({2, 0}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {0, 2}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {1, 1}, ACL_FLOAT,
320- ACL_FORMAT_ND, {-5, 5}, {2, 2}, ACL_FLOAT, ACL_FORMAT_ND, alpha, beta, transA, transB, cubeMathType);
321- 
322- // C: 0, A: 2 x 0, B: 0 x 2, out: 2 x 2 拦截报错
323- test_run_inval({2, 0}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {0, 2}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {0}, ACL_FLOAT,
324- ACL_FORMAT_ND, {-5, 5}, {2, 2}, ACL_FLOAT, ACL_FORMAT_ND, alpha, beta, transA, transB, cubeMathType);
325- 
326- // C: 2 x 0, A: 2 x 0, B: 0 x 0, out: 0 x 0
327- test_run({2, 0}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {0, 0}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {2, 0}, ACL_FLOAT,
328- ACL_FORMAT_ND, {-5, 5}, {0, 0}, ACL_FLOAT, ACL_FORMAT_ND, alpha, beta, transA, transB, cubeMathType);
329- // C: 0 / 1 / 1 x 1, A: 2 x 0, B: 0 x 0, out: 0 x 0
330- test_run({2, 0}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {0, 0}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {0}, ACL_FLOAT,
331- ACL_FORMAT_ND, {-5, 5}, {0, 0}, ACL_FLOAT, ACL_FORMAT_ND, alpha, beta, transA, transB, cubeMathType);
332- test_run({2, 0}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {0, 0}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {1}, ACL_FLOAT,
333- ACL_FORMAT_ND, {-5, 5}, {0, 0}, ACL_FLOAT, ACL_FORMAT_ND, alpha, beta, transA, transB, cubeMathType);
334- test_run({2, 0}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {0, 0}, ACL_FLOAT, ACL_FORMAT_ND, {-5, 5}, {1, 1}, ACL_FLOAT,
335- ACL_FORMAT_ND, {-5, 5}, {0, 0}, ACL_FLOAT, ACL_FORMAT_ND, alpha, beta, transA, transB, cubeMathType);
336-}
337- 
338-// cubeMathType = USE_FP32_ADD 测试用例
339-TEST_F(l2_gemm_test, case_cubeMathType_USE_FP32_ADD)
340-{
341- float alpha = 1.0;
342- float beta = 1.0;
343- int64_t transA = 0;
344- int64_t transB = 0;
345- int8_t cubeMathType = USE_FP32_ADD;
346- test_run({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND, {0, 2}, {16, 16}, ACL_FLOAT16, ACL_FORMAT_ND, {0, 2}, {16, 16},
347- ACL_FLOAT16, ACL_FORMAT_ND, {0, 2}, {16, 16}, ACL_FLOAT16, ACL_FORMAT_ND, alpha, beta, transA, transB,
348- cubeMathType);
349-}
350- 
351-// cubeMathType = KEEP_DTYPE 测试用例
352-TEST_F(l2_gemm_test, case_cubeMathType_KEEP_DTYPE)
353-{
354- float alpha = 1.0;
355- float beta = 1.0;
356- int64_t transA = 0;
357- int64_t transB = 0;
358- int8_t cubeMathType = KEEP_DTYPE;
359- test_run({16, 16}, ACL_FLOAT16, ACL_FORMAT_ND, {0, 2}, {16, 16}, ACL_FLOAT16, ACL_FORMAT_ND, {0, 2}, {16, 16},
360- ACL_FLOAT16, ACL_FORMAT_ND, {0, 2}, {16, 16}, ACL_FLOAT16, ACL_FORMAT_ND, alpha, beta, transA, transB,
361- cubeMathType);
362-}
Rmatmul/mv/tests/ut/op_host/op_api/test_aclnn_mv.cpp→matmul/mv/tests/ut/op_api/test_aclnn_mv.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_host/op_api/aclnn_mv.h"14+#include "../../../op_host/op_api/aclnn_mv.h"
15 15 
16#include "op_api_ut_common/tensor_desc.h"16#include "op_api_ut_common/tensor_desc.h"
17#include "op_api_ut_common/scalar_desc.h"17#include "op_api_ut_common/scalar_desc.h"
@@ -273,4 +273,4 @@ TEST_F(l2_mv_test, ascend910B_fp32_cubeMathType_all4)
273 ACL_FORMAT_ND, 4);273 ACL_FORMAT_ND, 4);
274 test_run({101, 301}, ACL_FLOAT, ACL_FORMAT_ND, {-10, 10}, {301}, ACL_FLOAT, ACL_FORMAT_ND, {-15, -10}, {101},274 test_run({101, 301}, ACL_FLOAT, ACL_FORMAT_ND, {-10, 10}, {301}, ACL_FLOAT, ACL_FORMAT_ND, {-15, -10}, {101},
275 ACL_FLOAT, ACL_FORMAT_ND, 4);275 ACL_FLOAT, ACL_FORMAT_ND, 4);
276-}276+}
Dmatmul/mv/tests/ut/op_host/test_aclnn_mv.cpp+0-173
@@ -1,173 +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 <vector>
11-#include <array>
12-#include "gtest/gtest.h"
13- 
14-#include "../../../op_host/op_api/aclnn_mv.h"
15- 
16-#include "op_api_ut_common/tensor_desc.h"
17-#include "op_api_ut_common/scalar_desc.h"
18-#include "op_api_ut_common/op_api_ut.h"
19-#include "opdev/platform.h"
20-#include "acl/acl.h"
21- 
22-using namespace op;
23-using namespace std;
24- 
25-class l2_mv_test : public testing::Test {
26-protected:
27- static void SetUpTestCase() { std::cout << "mv_test SetUp" << std::endl; }
28- 
29- static void TearDownTestCase() { std::cout << "mv_test TearDown" << std::endl; }
30- 
31- void test_run(vector<int64_t> selfDims, aclDataType selfDtype, aclFormat selfFormat, vector<int64_t> selfRange,
32- vector<int64_t> vecDims, aclDataType vecDtype, aclFormat vecFormat, vector<int64_t> vecRange,
33- vector<int64_t> outDims, aclDataType outDtype, aclFormat outFormat, int8_t cubeMathType)
34- {
35- auto self = TensorDesc(selfDims, selfDtype, selfFormat).ValueRange(selfRange[0], selfRange[1]);
36- auto vec = TensorDesc(vecDims, vecDtype, vecFormat).ValueRange(vecRange[0], vecRange[1]);
37- auto out = TensorDesc(outDims, outDtype, outFormat).Precision(0.00001, 0.00001);
38- 
39- auto ut = OP_API_UT(aclnnMv, INPUT(self, vec), OUTPUT(out), cubeMathType);
40- uint64_t workspaceSize = 0;
41- aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
42- EXPECT_EQ(getWorkspaceResult, ACL_SUCCESS);
43- // ut.TestPrecision();
44- }
45- 
46- void test_run_invalid(vector<int64_t> selfDims, aclDataType selfDtype, aclFormat selfFormat,
47- vector<int64_t> selfRange, vector<int64_t> vecDims, aclDataType vecDtype, aclFormat vecFormat,
48- vector<int64_t> vecRange, vector<int64_t> outDims, aclDataType outDtype, aclFormat outFormat,
49- int8_t cubeMathType)
50- {
51- auto self = TensorDesc(selfDims, selfDtype, selfFormat).ValueRange(selfRange[0], selfRange[1]);
52- auto vec = TensorDesc(vecDims, vecDtype, vecFormat).ValueRange(vecRange[0], vecRange[1]);
53- auto out = TensorDesc(outDims, outDtype, outFormat).Precision(0.00001, 0.00001);
54- 
55- auto ut = OP_API_UT(aclnnMv, INPUT(self, vec), OUTPUT(out), cubeMathType);
56- uint64_t workspaceSize = 0;
57- aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
58- EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_INVALID);
59- }
60-};
61- 
62-// // self + other + out: 不支持double、complex64、complex128 + bool、uint8、int8、int16、int32、int64、bfloat16、
63-TEST_F(l2_mv_test, l2_mv_test_03)
64-{
65- test_run_invalid({2, 3}, ACL_DOUBLE, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_DOUBLE, ACL_FORMAT_ND, {-15, -10}, {2},
66- ACL_DOUBLE, ACL_FORMAT_ND, 1);
67- test_run_invalid({2, 3}, ACL_COMPLEX64, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_COMPLEX64, ACL_FORMAT_ND, {-15, -10},
68- {2}, ACL_COMPLEX64, ACL_FORMAT_ND, 1);
69- test_run_invalid({2, 3}, ACL_COMPLEX128, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_COMPLEX128, ACL_FORMAT_ND, {-15, -10},
70- {2}, ACL_COMPLEX128, ACL_FORMAT_ND, 1);
71- 
72- test_run_invalid({2, 3}, ACL_BOOL, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_BOOL, ACL_FORMAT_ND, {-15, -10}, {2},
73- ACL_BOOL, ACL_FORMAT_ND, 1);
74- test_run_invalid({2, 3}, ACL_UINT8, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_UINT8, ACL_FORMAT_ND, {-15, -10}, {2},
75- ACL_UINT8, ACL_FORMAT_ND, 1);
76- test_run_invalid({2, 3}, ACL_INT8, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_INT8, ACL_FORMAT_ND, {-15, -10}, {2},
77- ACL_INT8, ACL_FORMAT_ND, 1);
78- test_run_invalid({2, 3}, ACL_INT16, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_INT16, ACL_FORMAT_ND, {-15, -10}, {2},
79- ACL_INT16, ACL_FORMAT_ND, 1);
80- test_run_invalid({2, 3}, ACL_INT32, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_INT32, ACL_FORMAT_ND, {-15, -10}, {2},
81- ACL_COMPLEX64, ACL_FORMAT_ND, 1);
82- test_run_invalid({2, 3}, ACL_INT64, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_INT64, ACL_FORMAT_ND, {-15, -10}, {2},
83- ACL_COMPLEX128, ACL_FORMAT_ND, 1);
84- test_run_invalid({2, 3}, ACL_BF16, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_BF16, ACL_FORMAT_ND, {-15, -10}, {2},
85- ACL_BF16, ACL_FORMAT_ND, 1);
86-}
87- 
88-// ///////////////////////////////////////
89-// ///// 检查空指针 /////
90-// ///////////////////////////////////////
91- 
92-TEST_F(l2_mv_test, l2_mv_test_05)
93-{
94- uint64_t workspaceSize = 0;
95- auto self = TensorDesc({2, 3}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(-10, 10);
96- auto vec = TensorDesc({3}, ACL_FLOAT16, ACL_FORMAT_ND).ValueRange(3, 10);
97- auto out = TensorDesc({2}, ACL_FLOAT16, ACL_FORMAT_ND).Precision(0.00001, 0.00001);
98- int8_t cubeMathType = 1;
99- 
100- auto ut = OP_API_UT(aclnnMv, INPUT(nullptr, vec), OUTPUT(out), cubeMathType);
101- aclnnStatus getWorkspaceResult = ut.TestGetWorkspaceSize(&workspaceSize);
102- EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_NULLPTR);
103- 
104- auto ut2 = OP_API_UT(aclnnMv, INPUT(self, nullptr), OUTPUT(out), cubeMathType);
105- getWorkspaceResult = ut2.TestGetWorkspaceSize(&workspaceSize);
106- EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_NULLPTR);
107- 
108- auto ut3 = OP_API_UT(aclnnMv, INPUT(self, vec), OUTPUT(nullptr), cubeMathType);
109- getWorkspaceResult = ut3.TestGetWorkspaceSize(&workspaceSize);
110- EXPECT_EQ(getWorkspaceResult, ACLNN_ERR_PARAM_NULLPTR);
111-}
112- 
113-///////////////////////////////////////
114-///// 支持空tensor /////
115-///////////////////////////////////////
116- 
117-// 支持空tensor
118-TEST_F(l2_mv_test, l2_mv_test_06)
119-{
120- // self n x 0, vec 0, out n n不为0
121- test_run({3, 0}, ACL_FLOAT16, ACL_FORMAT_ND, {-10, 10}, {0}, ACL_FLOAT16, ACL_FORMAT_ND, {-15, -10}, {3},
122- ACL_FLOAT16, ACL_FORMAT_ND, 1);
123- // self 0 x m, vec m, out 0 m不为0
124- test_run({0, 3}, ACL_FLOAT16, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_FLOAT16, ACL_FORMAT_ND, {-15, -10}, {0},
125- ACL_FLOAT16, ACL_FORMAT_ND, 1);
126- // self 0 x 0, vec 0, out 0 m, n都为0
127- test_run({0, 0}, ACL_FLOAT16, ACL_FORMAT_ND, {-10, 10}, {0}, ACL_FLOAT16, ACL_FORMAT_ND, {-15, -10}, {0},
128- ACL_FLOAT16, ACL_FORMAT_ND, 1);
129- 
130- // self为空tensor时，如果vec + out dtype一致，则支持运算
131- // 1. self可以和vec/out dtype不一致
132- test_run({3, 0}, ACL_FLOAT16, ACL_FORMAT_ND, {-10, 10}, {0}, ACL_FLOAT, ACL_FORMAT_ND, {-15, -10}, {3}, ACL_FLOAT,
133- ACL_FORMAT_ND, 1);
134- test_run_invalid({3, 0}, ACL_FLOAT16, ACL_FORMAT_ND, {-10, 10}, {0}, ACL_FLOAT16, ACL_FORMAT_ND, {-15, -10}, {3},
135- ACL_FLOAT, ACL_FORMAT_ND, 1);
136- // 2. 该场景下，out dtype为不支持的数据类型也行
137- test_run({3, 0}, ACL_FLOAT16, ACL_FORMAT_ND, {-10, 10}, {0}, ACL_BOOL, ACL_FORMAT_ND, {-15, -10}, {3}, ACL_BOOL,
138- ACL_FORMAT_ND, 1);
139- test_run_invalid({3, 0}, ACL_FLOAT16, ACL_FORMAT_ND, {-10, 10}, {0}, ACL_FLOAT16, ACL_FORMAT_ND, {-15, -10}, {3},
140- ACL_BOOL, ACL_FORMAT_ND, 1);
141-}
142- 
143-// self + other + out: fp32 910B支持FP32, cubeMathType为0/1/2/3正常运行, 4会路由到0
144-TEST_F(l2_mv_test, ascend910B_fp32_cubeMathType0_to_4)
145-{
146- op::SocVersionManager versionManager(op::SocVersion::ASCEND910B);
147- test_run({2, 3}, ACL_FLOAT, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_FLOAT, ACL_FORMAT_ND, {-15, -10}, {2}, ACL_FLOAT,
148- ACL_FORMAT_ND, 0);
149- test_run({2, 3}, ACL_FLOAT, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_FLOAT, ACL_FORMAT_ND, {-15, -10}, {2}, ACL_FLOAT,
150- ACL_FORMAT_ND, 1);
151- test_run({2, 3}, ACL_FLOAT, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_FLOAT, ACL_FORMAT_ND, {-15, -10}, {2}, ACL_FLOAT,
152- ACL_FORMAT_ND, 2);
153- test_run({2, 3}, ACL_FLOAT, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_FLOAT, ACL_FORMAT_ND, {-15, -10}, {2}, ACL_FLOAT,
154- ACL_FORMAT_ND, 3);
155- test_run({2, 3}, ACL_FLOAT, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_FLOAT, ACL_FORMAT_ND, {-15, -10}, {2}, ACL_FLOAT,
156- ACL_FORMAT_ND, 4);
157-}
158- 
159-// self + other + out: fp32 910B支持FP32, cubeMathType为4，全部会路由到0
160-TEST_F(l2_mv_test, ascend910B_fp32_cubeMathType_all4)
161-{
162- op::SocVersionManager versionManager(op::SocVersion::ASCEND910B);
163- test_run({3, 3}, ACL_FLOAT, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_FLOAT, ACL_FORMAT_ND, {-15, -10}, {3}, ACL_FLOAT,
164- ACL_FORMAT_ND, 4);
165- test_run({2, 5}, ACL_FLOAT, ACL_FORMAT_ND, {-10, 10}, {5}, ACL_FLOAT, ACL_FORMAT_ND, {-15, -10}, {2}, ACL_FLOAT,
166- ACL_FORMAT_ND, 4);
167- test_run({5, 3}, ACL_FLOAT, ACL_FORMAT_ND, {-10, 10}, {3}, ACL_FLOAT, ACL_FORMAT_ND, {-15, -10}, {5}, ACL_FLOAT,
168- ACL_FORMAT_ND, 4);
169- test_run({10, 10}, ACL_FLOAT, ACL_FORMAT_ND, {-10, 10}, {10}, ACL_FLOAT, ACL_FORMAT_ND, {-15, -10}, {10}, ACL_FLOAT,
170- ACL_FORMAT_ND, 4);
171- test_run({101, 301}, ACL_FLOAT, ACL_FORMAT_ND, {-10, 10}, {301}, ACL_FLOAT, ACL_FORMAT_ND, {-15, -10}, {101},
172- ACL_FLOAT, ACL_FORMAT_ND, 4);
173-}