Star1733
1645
Code
Code
Issues499
Pull Requests562
Actions
Discussion
Wiki
Analysis
Star1733
1645
Closed
fix(op_host): FusedMulAdd/FusedMulAddAdd/MulNoNan 补齐 InferDataType 注册 #5263
zl_hwAdd on Aug 31Closed at Sep 1
fix(op_host): FusedMulAdd/FusedMulAddAdd/MulNoNan 补齐 InferDataType 注册 #5263
Closed
zl_hwAdd on Aug 31Closed at Sep 1
Merged fromzl_hw/ops-mathfix/infer-datatype-fused-mul-addintocann/ops-mathmaster
Total: 6 files changed+631-398
Mmath/fused_mul_add/op_host/fused_mul_add_infershape.cpp+12-1
@@ -18,11 +18,22 @@
18 18 
19using namespace ge;19using namespace ge;
20namespace ops {20namespace ops {
21+constexpr size_t FUSED_MUL_ADD_INPUT_X1_INDEX = 0;
22+constexpr size_t FUSED_MUL_ADD_OUTPUT_Y_INDEX = 0;
23+ 
21static ge::graphStatus InferShape4FusedMulAdd(gert::InferShapeContext* context)24static ge::graphStatus InferShape4FusedMulAdd(gert::InferShapeContext* context)
22{25{
23 OP_LOGD(context->GetNodeName(), "Begin to do InferShape4FusedMulAdd in ops-math");26 OP_LOGD(context->GetNodeName(), "Begin to do InferShape4FusedMulAdd in ops-math");
24 const size_t INPUT_NUM_THREE = 3;27 const size_t INPUT_NUM_THREE = 3;
25 return Ops::Base::InferShape4Broadcast(context, INPUT_NUM_THREE);28 return Ops::Base::InferShape4Broadcast(context, INPUT_NUM_THREE);
26}29}
27-IMPL_OP_INFERSHAPE(FusedMulAdd).InferShape(InferShape4FusedMulAdd);30+ 
31+static ge::graphStatus InferDataType4FusedMulAdd(gert::InferDataTypeContext* context)
32+{
33+ OP_LOGD(context->GetNodeName(), "Begin to do InferDataType4FusedMulAdd in ops-math");
34+ // Align with op_proto: output dtype is the same as input x1.
35+ context->SetOutputDataType(FUSED_MUL_ADD_OUTPUT_Y_INDEX, context->GetInputDataType(FUSED_MUL_ADD_INPUT_X1_INDEX));
36+ return ge::GRAPH_SUCCESS;
37+}
38+IMPL_OP_INFERSHAPE(FusedMulAdd).InferShape(InferShape4FusedMulAdd).InferDataType(InferDataType4FusedMulAdd);
28} // namespace ops39} // namespace ops
Mmath/fused_mul_add/tests/ut/op_host/test_fused_mul_add_infershape.cpp+187-128
@@ -12,35 +12,30 @@
12#include <iostream>12#include <iostream>
13#include "infershape_context_faker.h"13#include "infershape_context_faker.h"
14#include "infershape_case_executor.h"14#include "infershape_case_executor.h"
15+#include "op_infer_datatype_context_builder.h"
16+#include "base/registry/op_impl_space_registry_v2.h"
15 17 
16using namespace ge;18using namespace ge;
17 19 
18class FusedMulAddInfershape : public testing::Test {20class FusedMulAddInfershape : public testing::Test {
19protected:21protected:
20- static void SetUpTestCase()22+ static void SetUpTestCase() { std::cout << "FusedMulAddInfershape SetUp" << std::endl; }
21- {
22- std::cout << "FusedMulAddInfershape SetUp" << std::endl;
23- }
24 23 
25- static void TearDownTestCase()24+ static void TearDownTestCase() { std::cout << "FusedMulAddInfershape TearDown" << std::endl; }
26- {
27- std::cout << "FusedMulAddInfershape TearDown" << std::endl;
28- }
29};25};
30 26 
31// Case 1: three inputs share the same shape, fp16.27// Case 1: three inputs share the same shape, fp16.
32TEST_F(FusedMulAddInfershape, same_shape_fp16)28TEST_F(FusedMulAddInfershape, same_shape_fp16)
33{29{
34- gert::InfershapeContextPara para(30+ gert::InfershapeContextPara para("FusedMulAdd",
35- "FusedMulAdd",31+ {
36- {32+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},
37- {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},33+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},
38- {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},34+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},
39- {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},35+ },
40- },36+ {
41- {37+ {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},
42- {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},38+ });
43- });
44 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};39 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};
45 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);40 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
46}41}
@@ -48,16 +43,15 @@ TEST_F(FusedMulAddInfershape, same_shape_fp16)
48// Case 2: x3 is a scalar [1].43// Case 2: x3 is a scalar [1].
49TEST_F(FusedMulAddInfershape, x3_scalar)44TEST_F(FusedMulAddInfershape, x3_scalar)
50{45{
51- gert::InfershapeContextPara para(46+ gert::InfershapeContextPara para("FusedMulAdd",
52- "FusedMulAdd",47+ {
53- {48+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},
54- {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},49+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},
55- {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},50+ {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
56- {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},51+ },
57- },52+ {
58- {53+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
59- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},54+ });
60- });
61 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};55 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};
62 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);56 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
63}57}
@@ -65,16 +59,15 @@ TEST_F(FusedMulAddInfershape, x3_scalar)
65// Case 3: per-axis broadcast x1=[16,1], x2=[1,16], x3=[16,16] -> [16,16].59// Case 3: per-axis broadcast x1=[16,1], x2=[1,16], x3=[16,16] -> [16,16].
66TEST_F(FusedMulAddInfershape, axis_broadcast_fp32)60TEST_F(FusedMulAddInfershape, axis_broadcast_fp32)
67{61{
68- gert::InfershapeContextPara para(62+ gert::InfershapeContextPara para("FusedMulAdd",
69- "FusedMulAdd",63+ {
70- {64+ {{{16, 1}, {16, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},
71- {{{16, 1}, {16, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},65+ {{{1, 16}, {1, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},
72- {{{1, 16}, {1, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},66+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},
73- {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},67+ },
74- },68+ {
75- {69+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
76- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},70+ });
77- });
78 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};71 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};
79 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);72 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
80}73}
@@ -82,16 +75,15 @@ TEST_F(FusedMulAddInfershape, axis_broadcast_fp32)
82// Case 4: cross-rank broadcast x1=[3,4,5], x2=[4,5], x3=[5] -> [3,4,5].75// Case 4: cross-rank broadcast x1=[3,4,5], x2=[4,5], x3=[5] -> [3,4,5].
83TEST_F(FusedMulAddInfershape, cross_rank_broadcast_fp32)76TEST_F(FusedMulAddInfershape, cross_rank_broadcast_fp32)
84{77{
85- gert::InfershapeContextPara para(78+ gert::InfershapeContextPara para("FusedMulAdd",
86- "FusedMulAdd",79+ {
87- {80+ {{{3, 4, 5}, {3, 4, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},
88- {{{3, 4, 5}, {3, 4, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},81+ {{{4, 5}, {4, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},
89- {{{4, 5}, {4, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},82+ {{{5}, {5}}, ge::DT_FLOAT, ge::FORMAT_ND},
90- {{{5}, {5}}, ge::DT_FLOAT, ge::FORMAT_ND},83+ },
91- },84+ {
92- {85+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
93- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},86+ });
94- });
95 std::vector<std::vector<int64_t>> expectOutputShape = {{3, 4, 5}};87 std::vector<std::vector<int64_t>> expectOutputShape = {{3, 4, 5}};
96 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);88 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
97}89}
@@ -99,16 +91,15 @@ TEST_F(FusedMulAddInfershape, cross_rank_broadcast_fp32)
99// Case 5: dynamic shape -1.91// Case 5: dynamic shape -1.
100TEST_F(FusedMulAddInfershape, dynamic_shape_fp16)92TEST_F(FusedMulAddInfershape, dynamic_shape_fp16)
101{93{
102- gert::InfershapeContextPara para(94+ gert::InfershapeContextPara para("FusedMulAdd",
103- "FusedMulAdd",95+ {
104- {96+ {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},
105- {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},97+ {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},
106- {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},98+ {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},
107- {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},99+ },
108- },100+ {
109- {101+ {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},
110- {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},102+ });
111- });
112 std::vector<std::vector<int64_t>> expectOutputShape = {{-1, -1}};103 std::vector<std::vector<int64_t>> expectOutputShape = {{-1, -1}};
113 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);104 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
114}105}
@@ -116,16 +107,15 @@ TEST_F(FusedMulAddInfershape, dynamic_shape_fp16)
116// Case 6: dynamic rank -2.107// Case 6: dynamic rank -2.
117TEST_F(FusedMulAddInfershape, dynamic_rank)108TEST_F(FusedMulAddInfershape, dynamic_rank)
118{109{
119- gert::InfershapeContextPara para(110+ gert::InfershapeContextPara para("FusedMulAdd",
120- "FusedMulAdd",111+ {
121- {112+ {{{-2}, {-2}}, ge::DT_FLOAT, ge::FORMAT_ND},
122- {{{-2}, {-2}}, ge::DT_FLOAT, ge::FORMAT_ND},113+ {{{-1}, {-1}}, ge::DT_FLOAT, ge::FORMAT_ND},
123- {{{-1}, {-1}}, ge::DT_FLOAT, ge::FORMAT_ND},114+ {{{-1}, {-1}}, ge::DT_FLOAT, ge::FORMAT_ND},
124- {{{-1}, {-1}}, ge::DT_FLOAT, ge::FORMAT_ND},115+ },
125- },116+ {
126- {117+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
127- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},118+ });
128- });
129 std::vector<std::vector<int64_t>> expectOutputShape = {{-2}};119 std::vector<std::vector<int64_t>> expectOutputShape = {{-2}};
130 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);120 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
131}121}
@@ -133,16 +123,15 @@ TEST_F(FusedMulAddInfershape, dynamic_rank)
133// Case 7: 1D scalar-like inputs, fp32.123// Case 7: 1D scalar-like inputs, fp32.
134TEST_F(FusedMulAddInfershape, vector_1d_fp32)124TEST_F(FusedMulAddInfershape, vector_1d_fp32)
135{125{
136- gert::InfershapeContextPara para(126+ gert::InfershapeContextPara para("FusedMulAdd",
137- "FusedMulAdd",127+ {
138- {128+ {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},
139- {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},129+ {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},
140- {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},130+ {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},
141- {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},131+ },
142- },132+ {
143- {133+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
144- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},134+ });
145- });
146 std::vector<std::vector<int64_t>> expectOutputShape = {{8}};135 std::vector<std::vector<int64_t>> expectOutputShape = {{8}};
147 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);136 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
148}137}
@@ -150,16 +139,15 @@ TEST_F(FusedMulAddInfershape, vector_1d_fp32)
150// Case 8: int32 vector path.139// Case 8: int32 vector path.
151TEST_F(FusedMulAddInfershape, vector_1d_int32)140TEST_F(FusedMulAddInfershape, vector_1d_int32)
152{141{
153- gert::InfershapeContextPara para(142+ gert::InfershapeContextPara para("FusedMulAdd",
154- "FusedMulAdd",143+ {
155- {144+ {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},
156- {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},145+ {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},
157- {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},146+ {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},
158- {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},147+ },
159- },148+ {
160- {149+ {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},
161- {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},150+ });
162- });
163 std::vector<std::vector<int64_t>> expectOutputShape = {{8}};151 std::vector<std::vector<int64_t>> expectOutputShape = {{8}};
164 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);152 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
165}153}
@@ -167,16 +155,15 @@ TEST_F(FusedMulAddInfershape, vector_1d_int32)
167// Case 9: x1/x2 are scalars, x3 carries the full shape -> output takes x3's shape.155// Case 9: x1/x2 are scalars, x3 carries the full shape -> output takes x3's shape.
168TEST_F(FusedMulAddInfershape, scalar_mul_full_add_fp32)156TEST_F(FusedMulAddInfershape, scalar_mul_full_add_fp32)
169{157{
170- gert::InfershapeContextPara para(158+ gert::InfershapeContextPara para("FusedMulAdd",
171- "FusedMulAdd",159+ {
172- {160+ {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
173- {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},161+ {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
174- {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},162+ {{{3, 4}, {3, 4}}, ge::DT_FLOAT, ge::FORMAT_ND},
175- {{{3, 4}, {3, 4}}, ge::DT_FLOAT, ge::FORMAT_ND},163+ },
176- },164+ {
177- {165+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
178- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},166+ });
179- });
180 std::vector<std::vector<int64_t>> expectOutputShape = {{3, 4}};167 std::vector<std::vector<int64_t>> expectOutputShape = {{3, 4}};
181 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);168 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
182}169}
@@ -184,16 +171,15 @@ TEST_F(FusedMulAddInfershape, scalar_mul_full_add_fp32)
184// Case 10: row x column mutual broadcast x1=[1,5], x2=[5,1], x3=[1] -> [5,5], fp32.171// Case 10: row x column mutual broadcast x1=[1,5], x2=[5,1], x3=[1] -> [5,5], fp32.
185TEST_F(FusedMulAddInfershape, row_col_broadcast_fp32)172TEST_F(FusedMulAddInfershape, row_col_broadcast_fp32)
186{173{
187- gert::InfershapeContextPara para(174+ gert::InfershapeContextPara para("FusedMulAdd",
188- "FusedMulAdd",175+ {
189- {176+ {{{1, 5}, {1, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},
190- {{{1, 5}, {1, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},177+ {{{5, 1}, {5, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},
191- {{{5, 1}, {5, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},178+ {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
192- {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},179+ },
193- },180+ {
194- {181+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
195- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},182+ });
196- });
197 std::vector<std::vector<int64_t>> expectOutputShape = {{5, 5}};183 std::vector<std::vector<int64_t>> expectOutputShape = {{5, 5}};
198 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);184 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
199}185}
@@ -201,16 +187,15 @@ TEST_F(FusedMulAddInfershape, row_col_broadcast_fp32)
201// Case 11: 3-D mutual broadcast x1=[2,1,4], x2=[1,3,4], x3=[4] -> [2,3,4], fp16.187// Case 11: 3-D mutual broadcast x1=[2,1,4], x2=[1,3,4], x3=[4] -> [2,3,4], fp16.
202TEST_F(FusedMulAddInfershape, mutual_3d_broadcast_fp16)188TEST_F(FusedMulAddInfershape, mutual_3d_broadcast_fp16)
203{189{
204- gert::InfershapeContextPara para(190+ gert::InfershapeContextPara para("FusedMulAdd",
205- "FusedMulAdd",191+ {
206- {192+ {{{2, 1, 4}, {2, 1, 4}}, ge::DT_FLOAT16, ge::FORMAT_ND},
207- {{{2, 1, 4}, {2, 1, 4}}, ge::DT_FLOAT16, ge::FORMAT_ND},193+ {{{1, 3, 4}, {1, 3, 4}}, ge::DT_FLOAT16, ge::FORMAT_ND},
208- {{{1, 3, 4}, {1, 3, 4}}, ge::DT_FLOAT16, ge::FORMAT_ND},194+ {{{4}, {4}}, ge::DT_FLOAT16, ge::FORMAT_ND},
209- {{{4}, {4}}, ge::DT_FLOAT16, ge::FORMAT_ND},195+ },
210- },196+ {
211- {197+ {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},
212- {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},198+ });
213- });
214 std::vector<std::vector<int64_t>> expectOutputShape = {{2, 3, 4}};199 std::vector<std::vector<int64_t>> expectOutputShape = {{2, 3, 4}};
215 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);200 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
216}201}
@@ -219,16 +204,90 @@ TEST_F(FusedMulAddInfershape, mutual_3d_broadcast_fp16)
219// x1=[4,1,1], x2=[1,3,1], x3=[1,1,5] -> [4,3,5], int32.204// x1=[4,1,1], x2=[1,3,1], x3=[1,1,5] -> [4,3,5], int32.
220TEST_F(FusedMulAddInfershape, all_three_broadcast_int32)205TEST_F(FusedMulAddInfershape, all_three_broadcast_int32)
221{206{
222- gert::InfershapeContextPara para(207+ gert::InfershapeContextPara para("FusedMulAdd",
223- "FusedMulAdd",208+ {
224- {209+ {{{4, 1, 1}, {4, 1, 1}}, ge::DT_INT32, ge::FORMAT_ND},
225- {{{4, 1, 1}, {4, 1, 1}}, ge::DT_INT32, ge::FORMAT_ND},210+ {{{1, 3, 1}, {1, 3, 1}}, ge::DT_INT32, ge::FORMAT_ND},
226- {{{1, 3, 1}, {1, 3, 1}}, ge::DT_INT32, ge::FORMAT_ND},211+ {{{1, 1, 5}, {1, 1, 5}}, ge::DT_INT32, ge::FORMAT_ND},
227- {{{1, 1, 5}, {1, 1, 5}}, ge::DT_INT32, ge::FORMAT_ND},212+ },
228- },213+ {
229- {214+ {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},
230- {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},215+ });
231- });
232 std::vector<std::vector<int64_t>> expectOutputShape = {{4, 3, 5}};216 std::vector<std::vector<int64_t>> expectOutputShape = {{4, 3, 5}};
233 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);217 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
234}218}
219+ 
220+// InferDataType: output dtype follows x1 (fp16).
221+TEST_F(FusedMulAddInfershape, infer_datatype_fp16)
222+{
223+ auto spaceRegistry = gert::DefaultOpImplSpaceRegistryV2::GetInstance().GetSpaceRegistry();
224+ ASSERT_NE(spaceRegistry, nullptr);
225+ auto opImpl = spaceRegistry->GetOpImpl("FusedMulAdd");
226+ ASSERT_NE(opImpl, nullptr);
227+ ASSERT_NE(opImpl->infer_datatype, nullptr);
228+ 
229+ gert::OpInferDataTypeContextBuilder builder;
230+ builder.OpType("FusedMulAdd").OpName("FusedMulAdd");
231+ builder.IONum(3, 1);
232+ builder.InputTensorDesc(0, ge::DT_FLOAT16, ge::FORMAT_ND, ge::FORMAT_ND);
233+ builder.InputTensorDesc(1, ge::DT_FLOAT16, ge::FORMAT_ND, ge::FORMAT_ND);
234+ builder.InputTensorDesc(2, ge::DT_FLOAT16, ge::FORMAT_ND, ge::FORMAT_ND);
235+ builder.OutputTensorDesc(0, ge::FORMAT_ND, ge::FORMAT_ND);
236+ auto contextHolder = builder.Build();
237+ auto* context = contextHolder.GetContext();
238+ ASSERT_NE(context, nullptr);
239+ 
240+ auto ret = opImpl->infer_datatype(context);
241+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
242+ EXPECT_EQ(context->GetOutputDataType(0), ge::DT_FLOAT16);
243+}
244+ 
245+// InferDataType: output dtype follows x1 (fp32).
246+TEST_F(FusedMulAddInfershape, infer_datatype_fp32)
247+{
248+ auto spaceRegistry = gert::DefaultOpImplSpaceRegistryV2::GetInstance().GetSpaceRegistry();
249+ ASSERT_NE(spaceRegistry, nullptr);
250+ auto opImpl = spaceRegistry->GetOpImpl("FusedMulAdd");
251+ ASSERT_NE(opImpl, nullptr);
252+ ASSERT_NE(opImpl->infer_datatype, nullptr);
253+ 
254+ gert::OpInferDataTypeContextBuilder builder;
255+ builder.OpType("FusedMulAdd").OpName("FusedMulAdd");
256+ builder.IONum(3, 1);
257+ builder.InputTensorDesc(0, ge::DT_FLOAT, ge::FORMAT_ND, ge::FORMAT_ND);
258+ builder.InputTensorDesc(1, ge::DT_FLOAT, ge::FORMAT_ND, ge::FORMAT_ND);
259+ builder.InputTensorDesc(2, ge::DT_FLOAT, ge::FORMAT_ND, ge::FORMAT_ND);
260+ builder.OutputTensorDesc(0, ge::FORMAT_ND, ge::FORMAT_ND);
261+ auto contextHolder = builder.Build();
262+ auto* context = contextHolder.GetContext();
263+ ASSERT_NE(context, nullptr);
264+ 
265+ auto ret = opImpl->infer_datatype(context);
266+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
267+ EXPECT_EQ(context->GetOutputDataType(0), ge::DT_FLOAT);
268+}
269+ 
270+// InferDataType: output dtype follows x1 (int32).
271+TEST_F(FusedMulAddInfershape, infer_datatype_int32)
272+{
273+ auto spaceRegistry = gert::DefaultOpImplSpaceRegistryV2::GetInstance().GetSpaceRegistry();
274+ ASSERT_NE(spaceRegistry, nullptr);
275+ auto opImpl = spaceRegistry->GetOpImpl("FusedMulAdd");
276+ ASSERT_NE(opImpl, nullptr);
277+ ASSERT_NE(opImpl->infer_datatype, nullptr);
278+ 
279+ gert::OpInferDataTypeContextBuilder builder;
280+ builder.OpType("FusedMulAdd").OpName("FusedMulAdd");
281+ builder.IONum(3, 1);
282+ builder.InputTensorDesc(0, ge::DT_INT32, ge::FORMAT_ND, ge::FORMAT_ND);
283+ builder.InputTensorDesc(1, ge::DT_INT32, ge::FORMAT_ND, ge::FORMAT_ND);
284+ builder.InputTensorDesc(2, ge::DT_INT32, ge::FORMAT_ND, ge::FORMAT_ND);
285+ builder.OutputTensorDesc(0, ge::FORMAT_ND, ge::FORMAT_ND);
286+ auto contextHolder = builder.Build();
287+ auto* context = contextHolder.GetContext();
288+ ASSERT_NE(context, nullptr);
289+ 
290+ auto ret = opImpl->infer_datatype(context);
291+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
292+ EXPECT_EQ(context->GetOutputDataType(0), ge::DT_INT32);
293+}
Mmath/fused_mul_add_add/op_host/fused_mul_add_add_infershape.cpp+13-1
@@ -18,6 +18,9 @@
18 18 
19using namespace ge;19using namespace ge;
20namespace ops {20namespace ops {
21+constexpr size_t FUSED_MUL_ADD_ADD_INPUT_X1_INDEX = 0;
22+constexpr size_t FUSED_MUL_ADD_ADD_OUTPUT_Y_INDEX = 0;
23+ 
21static ge::graphStatus InferShape4FusedMulAddAdd(gert::InferShapeContext* context)24static ge::graphStatus InferShape4FusedMulAddAdd(gert::InferShapeContext* context)
22{25{
23 OP_LOGD(context->GetNodeName(), "Begin to do InferShape4FusedMulAddAdd in ops-math");26 OP_LOGD(context->GetNodeName(), "Begin to do InferShape4FusedMulAddAdd in ops-math");
@@ -45,5 +48,14 @@ static ge::graphStatus InferShape4FusedMulAddAdd(gert::InferShapeContext* contex
45 *yShape = *x1Shape;48 *yShape = *x1Shape;
46 return ge::GRAPH_SUCCESS;49 return ge::GRAPH_SUCCESS;
47}50}
48-IMPL_OP_INFERSHAPE(FusedMulAddAdd).InferShape(InferShape4FusedMulAddAdd);51+ 
52+static ge::graphStatus InferDataType4FusedMulAddAdd(gert::InferDataTypeContext* context)
53+{
54+ OP_LOGD(context->GetNodeName(), "Begin to do InferDataType4FusedMulAddAdd in ops-math");
55+ // Align with op_proto: output dtype is the same as input x1.
56+ context->SetOutputDataType(FUSED_MUL_ADD_ADD_OUTPUT_Y_INDEX,
57+ context->GetInputDataType(FUSED_MUL_ADD_ADD_INPUT_X1_INDEX));
58+ return ge::GRAPH_SUCCESS;
59+}
60+IMPL_OP_INFERSHAPE(FusedMulAddAdd).InferShape(InferShape4FusedMulAddAdd).InferDataType(InferDataType4FusedMulAddAdd);
49} // namespace ops61} // namespace ops
Mmath/fused_mul_add_add/tests/ut/op_host/test_fused_mul_add_add_infershape.cpp+212-151
@@ -12,36 +12,31 @@
12#include <iostream>12#include <iostream>
13#include "infershape_context_faker.h"13#include "infershape_context_faker.h"
14#include "infershape_case_executor.h"14#include "infershape_case_executor.h"
15+#include "op_infer_datatype_context_builder.h"
16+#include "base/registry/op_impl_space_registry_v2.h"
15 17 
16using namespace ge;18using namespace ge;
17 19 
18class FusedMulAddAddInfershape : public testing::Test {20class FusedMulAddAddInfershape : public testing::Test {
19protected:21protected:
20- static void SetUpTestCase()22+ static void SetUpTestCase() { std::cout << "FusedMulAddAddInfershape SetUp" << std::endl; }
21- {
22- std::cout << "FusedMulAddAddInfershape SetUp" << std::endl;
23- }
24 23 
25- static void TearDownTestCase()24+ static void TearDownTestCase() { std::cout << "FusedMulAddAddInfershape TearDown" << std::endl; }
26- {
27- std::cout << "FusedMulAddAddInfershape TearDown" << std::endl;
28- }
29};25};
30 26 
31// Case 1: four inputs share the same shape, fp16.27// Case 1: four inputs share the same shape, fp16.
32TEST_F(FusedMulAddAddInfershape, same_shape_fp16)28TEST_F(FusedMulAddAddInfershape, same_shape_fp16)
33{29{
34- gert::InfershapeContextPara para(30+ gert::InfershapeContextPara para("FusedMulAddAdd",
35- "FusedMulAddAdd",31+ {
36- {32+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},
37- {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},33+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},
38- {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},34+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},
39- {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},35+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},
40- {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},36+ },
41- },37+ {
42- {38+ {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},
43- {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},39+ });
44- });
45 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};40 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};
46 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);41 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
47}42}
@@ -49,17 +44,16 @@ TEST_F(FusedMulAddAddInfershape, same_shape_fp16)
49// Case 2: x4 is a scalar [1] (residual scalar), fp32.44// Case 2: x4 is a scalar [1] (residual scalar), fp32.
50TEST_F(FusedMulAddAddInfershape, x4_scalar_fp32)45TEST_F(FusedMulAddAddInfershape, x4_scalar_fp32)
51{46{
52- gert::InfershapeContextPara para(47+ gert::InfershapeContextPara para("FusedMulAddAdd",
53- "FusedMulAddAdd",48+ {
54- {49+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},
55- {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},50+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},
56- {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},51+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},
57- {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},52+ {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
58- {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},53+ },
59- },54+ {
60- {55+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
61- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},56+ });
62- });
63 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};57 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};
64 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);58 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
65}59}
@@ -67,17 +61,16 @@ TEST_F(FusedMulAddAddInfershape, x4_scalar_fp32)
67// Case 3: output equals x1's shape (no broadcast): x1=[16,1] -> [16,1].61// Case 3: output equals x1's shape (no broadcast): x1=[16,1] -> [16,1].
68TEST_F(FusedMulAddAddInfershape, axis_broadcast_fp32)62TEST_F(FusedMulAddAddInfershape, axis_broadcast_fp32)
69{63{
70- gert::InfershapeContextPara para(64+ gert::InfershapeContextPara para("FusedMulAddAdd",
71- "FusedMulAddAdd",65+ {
72- {66+ {{{16, 1}, {16, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},
73- {{{16, 1}, {16, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},67+ {{{1, 16}, {1, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},
74- {{{1, 16}, {1, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},68+ {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
75- {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},69+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},
76- {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},70+ },
77- },71+ {
78- {72+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
79- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},73+ });
80- });
81 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 1}};74 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 1}};
82 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);75 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
83}76}
@@ -85,17 +78,16 @@ TEST_F(FusedMulAddAddInfershape, axis_broadcast_fp32)
85// Case 4: cross-rank broadcast: x1=[3,4,5], x2=[4,5], x3=[5], x4=[1] -> [3,4,5].78// Case 4: cross-rank broadcast: x1=[3,4,5], x2=[4,5], x3=[5], x4=[1] -> [3,4,5].
86TEST_F(FusedMulAddAddInfershape, cross_rank_broadcast_int32)79TEST_F(FusedMulAddAddInfershape, cross_rank_broadcast_int32)
87{80{
88- gert::InfershapeContextPara para(81+ gert::InfershapeContextPara para("FusedMulAddAdd",
89- "FusedMulAddAdd",82+ {
90- {83+ {{{3, 4, 5}, {3, 4, 5}}, ge::DT_INT32, ge::FORMAT_ND},
91- {{{3, 4, 5}, {3, 4, 5}}, ge::DT_INT32, ge::FORMAT_ND},84+ {{{4, 5}, {4, 5}}, ge::DT_INT32, ge::FORMAT_ND},
92- {{{4, 5}, {4, 5}}, ge::DT_INT32, ge::FORMAT_ND},85+ {{{5}, {5}}, ge::DT_INT32, ge::FORMAT_ND},
93- {{{5}, {5}}, ge::DT_INT32, ge::FORMAT_ND},86+ {{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},
94- {{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},87+ },
95- },88+ {
96- {89+ {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},
97- {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},90+ });
98- });
99 std::vector<std::vector<int64_t>> expectOutputShape = {{3, 4, 5}};91 std::vector<std::vector<int64_t>> expectOutputShape = {{3, 4, 5}};
100 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);92 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
101}93}
@@ -103,17 +95,16 @@ TEST_F(FusedMulAddAddInfershape, cross_rank_broadcast_int32)
103// Case 5: dynamic shape -1 is not supported -> GRAPH_FAILED.95// Case 5: dynamic shape -1 is not supported -> GRAPH_FAILED.
104TEST_F(FusedMulAddAddInfershape, dynamic_shape_fp16)96TEST_F(FusedMulAddAddInfershape, dynamic_shape_fp16)
105{97{
106- gert::InfershapeContextPara para(98+ gert::InfershapeContextPara para("FusedMulAddAdd",
107- "FusedMulAddAdd",99+ {
108- {100+ {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},
109- {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},101+ {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},
110- {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},102+ {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},
111- {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},103+ {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},
112- {{{-1, -1}, {-1, -1}}, ge::DT_FLOAT16, ge::FORMAT_ND},104+ },
113- },105+ {
114- {106+ {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},
115- {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},107+ });
116- });
117 std::vector<std::vector<int64_t>> expectOutputShape = {};108 std::vector<std::vector<int64_t>> expectOutputShape = {};
118 ExecuteTestCase(para, ge::GRAPH_FAILED, expectOutputShape);109 ExecuteTestCase(para, ge::GRAPH_FAILED, expectOutputShape);
119}110}
@@ -121,17 +112,16 @@ TEST_F(FusedMulAddAddInfershape, dynamic_shape_fp16)
121// Case 6: dynamic rank -2 is not supported -> GRAPH_FAILED.112// Case 6: dynamic rank -2 is not supported -> GRAPH_FAILED.
122TEST_F(FusedMulAddAddInfershape, dynamic_rank)113TEST_F(FusedMulAddAddInfershape, dynamic_rank)
123{114{
124- gert::InfershapeContextPara para(115+ gert::InfershapeContextPara para("FusedMulAddAdd",
125- "FusedMulAddAdd",116+ {
126- {117+ {{{-2}, {-2}}, ge::DT_FLOAT, ge::FORMAT_ND},
127- {{{-2}, {-2}}, ge::DT_FLOAT, ge::FORMAT_ND},118+ {{{-1}, {-1}}, ge::DT_FLOAT, ge::FORMAT_ND},
128- {{{-1}, {-1}}, ge::DT_FLOAT, ge::FORMAT_ND},119+ {{{-1}, {-1}}, ge::DT_FLOAT, ge::FORMAT_ND},
129- {{{-1}, {-1}}, ge::DT_FLOAT, ge::FORMAT_ND},120+ {{{-1}, {-1}}, ge::DT_FLOAT, ge::FORMAT_ND},
130- {{{-1}, {-1}}, ge::DT_FLOAT, ge::FORMAT_ND},121+ },
131- },122+ {
132- {123+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
133- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},124+ });
134- });
135 std::vector<std::vector<int64_t>> expectOutputShape = {};125 std::vector<std::vector<int64_t>> expectOutputShape = {};
136 ExecuteTestCase(para, ge::GRAPH_FAILED, expectOutputShape);126 ExecuteTestCase(para, ge::GRAPH_FAILED, expectOutputShape);
137}127}
@@ -139,17 +129,16 @@ TEST_F(FusedMulAddAddInfershape, dynamic_rank)
139// Case 7: 1D vectors, fp32.129// Case 7: 1D vectors, fp32.
140TEST_F(FusedMulAddAddInfershape, vector_1d_fp32)130TEST_F(FusedMulAddAddInfershape, vector_1d_fp32)
141{131{
142- gert::InfershapeContextPara para(132+ gert::InfershapeContextPara para("FusedMulAddAdd",
143- "FusedMulAddAdd",133+ {
144- {134+ {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},
145- {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},135+ {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},
146- {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},136+ {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},
147- {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},137+ {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},
148- {{{8}, {8}}, ge::DT_FLOAT, ge::FORMAT_ND},138+ },
149- },139+ {
150- {140+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
151- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},141+ });
152- });
153 std::vector<std::vector<int64_t>> expectOutputShape = {{8}};142 std::vector<std::vector<int64_t>> expectOutputShape = {{8}};
154 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);143 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
155}144}
@@ -157,17 +146,16 @@ TEST_F(FusedMulAddAddInfershape, vector_1d_fp32)
157// Case 8: int32 vector path.146// Case 8: int32 vector path.
158TEST_F(FusedMulAddAddInfershape, vector_1d_int32)147TEST_F(FusedMulAddAddInfershape, vector_1d_int32)
159{148{
160- gert::InfershapeContextPara para(149+ gert::InfershapeContextPara para("FusedMulAddAdd",
161- "FusedMulAddAdd",150+ {
162- {151+ {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},
163- {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},152+ {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},
164- {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},153+ {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},
165- {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},154+ {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},
166- {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},155+ },
167- },156+ {
168- {157+ {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},
169- {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},158+ });
170- });
171 std::vector<std::vector<int64_t>> expectOutputShape = {{8}};159 std::vector<std::vector<int64_t>> expectOutputShape = {{8}};
172 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);160 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
173}161}
@@ -175,17 +163,16 @@ TEST_F(FusedMulAddAddInfershape, vector_1d_int32)
175// Case 9: output equals x1's shape (no broadcast): x1=[1] -> [1].163// Case 9: output equals x1's shape (no broadcast): x1=[1] -> [1].
176TEST_F(FusedMulAddAddInfershape, scalar_mul_full_add_fp32)164TEST_F(FusedMulAddAddInfershape, scalar_mul_full_add_fp32)
177{165{
178- gert::InfershapeContextPara para(166+ gert::InfershapeContextPara para("FusedMulAddAdd",
179- "FusedMulAddAdd",167+ {
180- {168+ {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
181- {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},169+ {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
182- {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},170+ {{{3, 4}, {3, 4}}, ge::DT_FLOAT, ge::FORMAT_ND},
183- {{{3, 4}, {3, 4}}, ge::DT_FLOAT, ge::FORMAT_ND},171+ {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
184- {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},172+ },
185- },173+ {
186- {174+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
187- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},175+ });
188- });
189 std::vector<std::vector<int64_t>> expectOutputShape = {{1}};176 std::vector<std::vector<int64_t>> expectOutputShape = {{1}};
190 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);177 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
191}178}
@@ -193,17 +180,16 @@ TEST_F(FusedMulAddAddInfershape, scalar_mul_full_add_fp32)
193// Case 10: output equals x1's shape (no broadcast): x1=[1,5] -> [1,5].180// Case 10: output equals x1's shape (no broadcast): x1=[1,5] -> [1,5].
194TEST_F(FusedMulAddAddInfershape, row_col_broadcast_fp32)181TEST_F(FusedMulAddAddInfershape, row_col_broadcast_fp32)
195{182{
196- gert::InfershapeContextPara para(183+ gert::InfershapeContextPara para("FusedMulAddAdd",
197- "FusedMulAddAdd",184+ {
198- {185+ {{{1, 5}, {1, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},
199- {{{1, 5}, {1, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},186+ {{{5, 1}, {5, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},
200- {{{5, 1}, {5, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},187+ {{{5, 5}, {5, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},
201- {{{5, 5}, {5, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},188+ {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
202- {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},189+ },
203- },190+ {
204- {191+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
205- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},192+ });
206- });
207 std::vector<std::vector<int64_t>> expectOutputShape = {{1, 5}};193 std::vector<std::vector<int64_t>> expectOutputShape = {{1, 5}};
208 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);194 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
209}195}
@@ -211,17 +197,16 @@ TEST_F(FusedMulAddAddInfershape, row_col_broadcast_fp32)
211// Case 11: output equals x1's shape (no broadcast): x1=[2,1,4] -> [2,1,4], fp16.197// Case 11: output equals x1's shape (no broadcast): x1=[2,1,4] -> [2,1,4], fp16.
212TEST_F(FusedMulAddAddInfershape, mutual_3d_broadcast_fp16)198TEST_F(FusedMulAddAddInfershape, mutual_3d_broadcast_fp16)
213{199{
214- gert::InfershapeContextPara para(200+ gert::InfershapeContextPara para("FusedMulAddAdd",
215- "FusedMulAddAdd",201+ {
216- {202+ {{{2, 1, 4}, {2, 1, 4}}, ge::DT_FLOAT16, ge::FORMAT_ND},
217- {{{2, 1, 4}, {2, 1, 4}}, ge::DT_FLOAT16, ge::FORMAT_ND},203+ {{{1, 3, 4}, {1, 3, 4}}, ge::DT_FLOAT16, ge::FORMAT_ND},
218- {{{1, 3, 4}, {1, 3, 4}}, ge::DT_FLOAT16, ge::FORMAT_ND},204+ {{{4}, {4}}, ge::DT_FLOAT16, ge::FORMAT_ND},
219- {{{4}, {4}}, ge::DT_FLOAT16, ge::FORMAT_ND},205+ {{{1}, {1}}, ge::DT_FLOAT16, ge::FORMAT_ND},
220- {{{1}, {1}}, ge::DT_FLOAT16, ge::FORMAT_ND},206+ },
221- },207+ {
222- {208+ {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},
223- {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},209+ });
224- });
225 std::vector<std::vector<int64_t>> expectOutputShape = {{2, 1, 4}};210 std::vector<std::vector<int64_t>> expectOutputShape = {{2, 1, 4}};
226 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);211 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
227}212}
@@ -229,17 +214,16 @@ TEST_F(FusedMulAddAddInfershape, mutual_3d_broadcast_fp16)
229// Case 12: output equals x1's shape (no broadcast): x1=[4,1,1] -> [4,1,1], int32.214// Case 12: output equals x1's shape (no broadcast): x1=[4,1,1] -> [4,1,1], int32.
230TEST_F(FusedMulAddAddInfershape, all_four_broadcast_int32)215TEST_F(FusedMulAddAddInfershape, all_four_broadcast_int32)
231{216{
232- gert::InfershapeContextPara para(217+ gert::InfershapeContextPara para("FusedMulAddAdd",
233- "FusedMulAddAdd",218+ {
234- {219+ {{{4, 1, 1}, {4, 1, 1}}, ge::DT_INT32, ge::FORMAT_ND},
235- {{{4, 1, 1}, {4, 1, 1}}, ge::DT_INT32, ge::FORMAT_ND},220+ {{{1, 3, 1}, {1, 3, 1}}, ge::DT_INT32, ge::FORMAT_ND},
236- {{{1, 3, 1}, {1, 3, 1}}, ge::DT_INT32, ge::FORMAT_ND},221+ {{{1, 1, 5}, {1, 1, 5}}, ge::DT_INT32, ge::FORMAT_ND},
237- {{{1, 1, 5}, {1, 1, 5}}, ge::DT_INT32, ge::FORMAT_ND},222+ {{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},
238- {{{1}, {1}}, ge::DT_INT32, ge::FORMAT_ND},223+ },
239- },224+ {
240- {225+ {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},
241- {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},226+ });
242- });
243 std::vector<std::vector<int64_t>> expectOutputShape = {{4, 1, 1}};227 std::vector<std::vector<int64_t>> expectOutputShape = {{4, 1, 1}};
244 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);228 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
245}229}
@@ -247,17 +231,94 @@ TEST_F(FusedMulAddAddInfershape, all_four_broadcast_int32)
247// Case 13: output equals x1's shape (no broadcast): x1=[4,1] -> [4,1], fp32.231// Case 13: output equals x1's shape (no broadcast): x1=[4,1] -> [4,1], fp32.
248TEST_F(FusedMulAddAddInfershape, col_vector_broadcast_fp32)232TEST_F(FusedMulAddAddInfershape, col_vector_broadcast_fp32)
249{233{
250- gert::InfershapeContextPara para(234+ gert::InfershapeContextPara para("FusedMulAddAdd",
251- "FusedMulAddAdd",235+ {
252- {236+ {{{4, 1}, {4, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},
253- {{{4, 1}, {4, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},237+ {{{4, 6}, {4, 6}}, ge::DT_FLOAT, ge::FORMAT_ND},
254- {{{4, 6}, {4, 6}}, ge::DT_FLOAT, ge::FORMAT_ND},238+ {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
255- {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},239+ {{{6}, {6}}, ge::DT_FLOAT, ge::FORMAT_ND},
256- {{{6}, {6}}, ge::DT_FLOAT, ge::FORMAT_ND},240+ },
257- },241+ {
258- {242+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
259- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},243+ });
260- });
261 std::vector<std::vector<int64_t>> expectOutputShape = {{4, 1}};244 std::vector<std::vector<int64_t>> expectOutputShape = {{4, 1}};
262 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);245 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
263}246}
247+ 
248+// InferDataType: output dtype follows x1 (fp16).
249+TEST_F(FusedMulAddAddInfershape, infer_datatype_fp16)
250+{
251+ auto spaceRegistry = gert::DefaultOpImplSpaceRegistryV2::GetInstance().GetSpaceRegistry();
252+ ASSERT_NE(spaceRegistry, nullptr);
253+ auto opImpl = spaceRegistry->GetOpImpl("FusedMulAddAdd");
254+ ASSERT_NE(opImpl, nullptr);
255+ ASSERT_NE(opImpl->infer_datatype, nullptr);
256+ 
257+ gert::OpInferDataTypeContextBuilder builder;
258+ builder.OpType("FusedMulAddAdd").OpName("FusedMulAddAdd");
259+ builder.IONum(4, 1);
260+ builder.InputTensorDesc(0, ge::DT_FLOAT16, ge::FORMAT_ND, ge::FORMAT_ND);
261+ builder.InputTensorDesc(1, ge::DT_FLOAT16, ge::FORMAT_ND, ge::FORMAT_ND);
262+ builder.InputTensorDesc(2, ge::DT_FLOAT16, ge::FORMAT_ND, ge::FORMAT_ND);
263+ builder.InputTensorDesc(3, ge::DT_FLOAT16, ge::FORMAT_ND, ge::FORMAT_ND);
264+ builder.OutputTensorDesc(0, ge::FORMAT_ND, ge::FORMAT_ND);
265+ auto contextHolder = builder.Build();
266+ auto* context = contextHolder.GetContext();
267+ ASSERT_NE(context, nullptr);
268+ 
269+ auto ret = opImpl->infer_datatype(context);
270+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
271+ EXPECT_EQ(context->GetOutputDataType(0), ge::DT_FLOAT16);
272+}
273+ 
274+// InferDataType: output dtype follows x1 (fp32).
275+TEST_F(FusedMulAddAddInfershape, infer_datatype_fp32)
276+{
277+ auto spaceRegistry = gert::DefaultOpImplSpaceRegistryV2::GetInstance().GetSpaceRegistry();
278+ ASSERT_NE(spaceRegistry, nullptr);
279+ auto opImpl = spaceRegistry->GetOpImpl("FusedMulAddAdd");
280+ ASSERT_NE(opImpl, nullptr);
281+ ASSERT_NE(opImpl->infer_datatype, nullptr);
282+ 
283+ gert::OpInferDataTypeContextBuilder builder;
284+ builder.OpType("FusedMulAddAdd").OpName("FusedMulAddAdd");
285+ builder.IONum(4, 1);
286+ builder.InputTensorDesc(0, ge::DT_FLOAT, ge::FORMAT_ND, ge::FORMAT_ND);
287+ builder.InputTensorDesc(1, ge::DT_FLOAT, ge::FORMAT_ND, ge::FORMAT_ND);
288+ builder.InputTensorDesc(2, ge::DT_FLOAT, ge::FORMAT_ND, ge::FORMAT_ND);
289+ builder.InputTensorDesc(3, ge::DT_FLOAT, ge::FORMAT_ND, ge::FORMAT_ND);
290+ builder.OutputTensorDesc(0, ge::FORMAT_ND, ge::FORMAT_ND);
291+ auto contextHolder = builder.Build();
292+ auto* context = contextHolder.GetContext();
293+ ASSERT_NE(context, nullptr);
294+ 
295+ auto ret = opImpl->infer_datatype(context);
296+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
297+ EXPECT_EQ(context->GetOutputDataType(0), ge::DT_FLOAT);
298+}
299+ 
300+// InferDataType: output dtype follows x1 (int32).
301+TEST_F(FusedMulAddAddInfershape, infer_datatype_int32)
302+{
303+ auto spaceRegistry = gert::DefaultOpImplSpaceRegistryV2::GetInstance().GetSpaceRegistry();
304+ ASSERT_NE(spaceRegistry, nullptr);
305+ auto opImpl = spaceRegistry->GetOpImpl("FusedMulAddAdd");
306+ ASSERT_NE(opImpl, nullptr);
307+ ASSERT_NE(opImpl->infer_datatype, nullptr);
308+ 
309+ gert::OpInferDataTypeContextBuilder builder;
310+ builder.OpType("FusedMulAddAdd").OpName("FusedMulAddAdd");
311+ builder.IONum(4, 1);
312+ builder.InputTensorDesc(0, ge::DT_INT32, ge::FORMAT_ND, ge::FORMAT_ND);
313+ builder.InputTensorDesc(1, ge::DT_INT32, ge::FORMAT_ND, ge::FORMAT_ND);
314+ builder.InputTensorDesc(2, ge::DT_INT32, ge::FORMAT_ND, ge::FORMAT_ND);
315+ builder.InputTensorDesc(3, ge::DT_INT32, ge::FORMAT_ND, ge::FORMAT_ND);
316+ builder.OutputTensorDesc(0, ge::FORMAT_ND, ge::FORMAT_ND);
317+ auto contextHolder = builder.Build();
318+ auto* context = contextHolder.GetContext();
319+ ASSERT_NE(context, nullptr);
320+ 
321+ auto ret = opImpl->infer_datatype(context);
322+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
323+ EXPECT_EQ(context->GetOutputDataType(0), ge::DT_INT32);
324+}
Mmath/mul_no_nan/op_host/mul_no_nan_infershape.cpp+11-1
@@ -18,6 +18,8 @@
18 18 
19using namespace ge;19using namespace ge;
20namespace ops {20namespace ops {
21+constexpr size_t MUL_NO_NAN_INPUT_X1_INDEX = 0;
22+constexpr size_t MUL_NO_NAN_OUTPUT_Y_INDEX = 0;
21 23 
22static ge::graphStatus InferShape4MulNoNan(gert::InferShapeContext* context)24static ge::graphStatus InferShape4MulNoNan(gert::InferShapeContext* context)
23{25{
@@ -25,6 +27,14 @@ static ge::graphStatus InferShape4MulNoNan(gert::InferShapeContext* context)
25 return Ops::Base::InferShape4Broadcast(context);27 return Ops::Base::InferShape4Broadcast(context);
26}28}
27 29 
28-IMPL_OP_INFERSHAPE(MulNoNan).InferShape(InferShape4MulNoNan);30+static ge::graphStatus InferDataType4MulNoNan(gert::InferDataTypeContext* context)
31+{
32+ OP_LOGD(context->GetNodeName(), "Begin to do InferDataType4MulNoNan in ops-math");
33+ // Align with op_proto: output dtype is the same as input x1.
34+ context->SetOutputDataType(MUL_NO_NAN_OUTPUT_Y_INDEX, context->GetInputDataType(MUL_NO_NAN_INPUT_X1_INDEX));
35+ return ge::GRAPH_SUCCESS;
36+}
37+ 
38+IMPL_OP_INFERSHAPE(MulNoNan).InferShape(InferShape4MulNoNan).InferDataType(InferDataType4MulNoNan);
29 39 
30} // namespace ops40} // namespace ops
Mmath/mul_no_nan/tests/ut/op_host/test_mul_no_nan_infershape.cpp+196-116
@@ -12,34 +12,29 @@
12#include <iostream>12#include <iostream>
13#include "infershape_context_faker.h"13#include "infershape_context_faker.h"
14#include "infershape_case_executor.h"14#include "infershape_case_executor.h"
15+#include "op_infer_datatype_context_builder.h"
16+#include "base/registry/op_impl_space_registry_v2.h"
15 17 
16using namespace ge;18using namespace ge;
17 19 
18class MulNoNanInfershape : public testing::Test {20class MulNoNanInfershape : public testing::Test {
19protected:21protected:
20- static void SetUpTestCase()22+ static void SetUpTestCase() { std::cout << "MulNoNanInfershape SetUp" << std::endl; }
21- {
22- std::cout << "MulNoNanInfershape SetUp" << std::endl;
23- }
24 23 
25- static void TearDownTestCase()24+ static void TearDownTestCase() { std::cout << "MulNoNanInfershape TearDown" << std::endl; }
26- {
27- std::cout << "MulNoNanInfershape TearDown" << std::endl;
28- }
29};25};
30 26 
31// Case 1: two inputs share the same shape, fp16.27// Case 1: two inputs share the same shape, fp16.
32TEST_F(MulNoNanInfershape, same_shape_fp16)28TEST_F(MulNoNanInfershape, same_shape_fp16)
33{29{
34- gert::InfershapeContextPara para(30+ gert::InfershapeContextPara para("MulNoNan",
35- "MulNoNan",31+ {
36- {32+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},
37- {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},33+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},
38- {{{16, 16}, {16, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},34+ },
39- },35+ {
40- {36+ {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},
41- {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},37+ });
42- });
43 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};38 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};
44 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);39 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
45}40}
@@ -47,15 +42,14 @@ TEST_F(MulNoNanInfershape, same_shape_fp16)
47// Case 2: x2 is a scalar [1] -> output follows x1's shape.42// Case 2: x2 is a scalar [1] -> output follows x1's shape.
48TEST_F(MulNoNanInfershape, x2_scalar)43TEST_F(MulNoNanInfershape, x2_scalar)
49{44{
50- gert::InfershapeContextPara para(45+ gert::InfershapeContextPara para("MulNoNan",
51- "MulNoNan",46+ {
52- {47+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},
53- {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},48+ {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
54- {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},49+ },
55- },50+ {
56- {51+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
57- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},52+ });
58- });
59 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};53 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};
60 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);54 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
61}55}
@@ -63,15 +57,14 @@ TEST_F(MulNoNanInfershape, x2_scalar)
63// Case 3: x1 is a scalar [1] -> output follows x2's shape.57// Case 3: x1 is a scalar [1] -> output follows x2's shape.
64TEST_F(MulNoNanInfershape, x1_scalar)58TEST_F(MulNoNanInfershape, x1_scalar)
65{59{
66- gert::InfershapeContextPara para(60+ gert::InfershapeContextPara para("MulNoNan",
67- "MulNoNan",61+ {
68- {62+ {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},
69- {{{1}, {1}}, ge::DT_FLOAT, ge::FORMAT_ND},63+ {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},
70- {{{16, 16}, {16, 16}}, ge::DT_FLOAT, ge::FORMAT_ND},64+ },
71- },65+ {
72- {66+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
73- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},67+ });
74- });
75 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};68 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};
76 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);69 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
77}70}
@@ -79,15 +72,14 @@ TEST_F(MulNoNanInfershape, x1_scalar)
79// Case 4: per-axis broadcast x1=[16,1], x2=[1,16] -> [16,16], fp16.72// Case 4: per-axis broadcast x1=[16,1], x2=[1,16] -> [16,16], fp16.
80TEST_F(MulNoNanInfershape, axis_broadcast_fp16)73TEST_F(MulNoNanInfershape, axis_broadcast_fp16)
81{74{
82- gert::InfershapeContextPara para(75+ gert::InfershapeContextPara para("MulNoNan",
83- "MulNoNan",76+ {
84- {77+ {{{16, 1}, {16, 1}}, ge::DT_FLOAT16, ge::FORMAT_ND},
85- {{{16, 1}, {16, 1}}, ge::DT_FLOAT16, ge::FORMAT_ND},78+ {{{1, 16}, {1, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},
86- {{{1, 16}, {1, 16}}, ge::DT_FLOAT16, ge::FORMAT_ND},79+ },
87- },80+ {
88- {81+ {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},
89- {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},82+ });
90- });
91 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};83 std::vector<std::vector<int64_t>> expectOutputShape = {{16, 16}};
92 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);84 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
93}85}
@@ -95,15 +87,14 @@ TEST_F(MulNoNanInfershape, axis_broadcast_fp16)
95// Case 5: cross-rank broadcast x1=[3,4,5], x2=[4,5] -> [3,4,5].87// Case 5: cross-rank broadcast x1=[3,4,5], x2=[4,5] -> [3,4,5].
96TEST_F(MulNoNanInfershape, cross_rank_broadcast_fp32)88TEST_F(MulNoNanInfershape, cross_rank_broadcast_fp32)
97{89{
98- gert::InfershapeContextPara para(90+ gert::InfershapeContextPara para("MulNoNan",
99- "MulNoNan",91+ {
100- {92+ {{{3, 4, 5}, {3, 4, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},
101- {{{3, 4, 5}, {3, 4, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},93+ {{{4, 5}, {4, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},
102- {{{4, 5}, {4, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},94+ },
103- },95+ {
104- {96+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
105- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},97+ });
106- });
107 std::vector<std::vector<int64_t>> expectOutputShape = {{3, 4, 5}};98 std::vector<std::vector<int64_t>> expectOutputShape = {{3, 4, 5}};
108 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);99 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
109}100}
@@ -111,15 +102,14 @@ TEST_F(MulNoNanInfershape, cross_rank_broadcast_fp32)
111// Case 6: dynamic shape -1, bf16.102// Case 6: dynamic shape -1, bf16.
112TEST_F(MulNoNanInfershape, dynamic_shape_bf16)103TEST_F(MulNoNanInfershape, dynamic_shape_bf16)
113{104{
114- gert::InfershapeContextPara para(105+ gert::InfershapeContextPara para("MulNoNan",
115- "MulNoNan",106+ {
116- {107+ {{{-1, -1}, {-1, -1}}, ge::DT_BF16, ge::FORMAT_ND},
117- {{{-1, -1}, {-1, -1}}, ge::DT_BF16, ge::FORMAT_ND},108+ {{{-1, -1}, {-1, -1}}, ge::DT_BF16, ge::FORMAT_ND},
118- {{{-1, -1}, {-1, -1}}, ge::DT_BF16, ge::FORMAT_ND},109+ },
119- },110+ {
120- {111+ {{{}, {}}, ge::DT_BF16, ge::FORMAT_ND},
121- {{{}, {}}, ge::DT_BF16, ge::FORMAT_ND},112+ });
122- });
123 std::vector<std::vector<int64_t>> expectOutputShape = {{-1, -1}};113 std::vector<std::vector<int64_t>> expectOutputShape = {{-1, -1}};
124 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);114 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
125}115}
@@ -127,15 +117,14 @@ TEST_F(MulNoNanInfershape, dynamic_shape_bf16)
127// Case 7: dynamic rank -2.117// Case 7: dynamic rank -2.
128TEST_F(MulNoNanInfershape, dynamic_rank)118TEST_F(MulNoNanInfershape, dynamic_rank)
129{119{
130- gert::InfershapeContextPara para(120+ gert::InfershapeContextPara para("MulNoNan",
131- "MulNoNan",121+ {
132- {122+ {{{-2}, {-2}}, ge::DT_FLOAT, ge::FORMAT_ND},
133- {{{-2}, {-2}}, ge::DT_FLOAT, ge::FORMAT_ND},123+ {{{-1}, {-1}}, ge::DT_FLOAT, ge::FORMAT_ND},
134- {{{-1}, {-1}}, ge::DT_FLOAT, ge::FORMAT_ND},124+ },
135- },125+ {
136- {126+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
137- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},127+ });
138- });
139 std::vector<std::vector<int64_t>> expectOutputShape = {{-2}};128 std::vector<std::vector<int64_t>> expectOutputShape = {{-2}};
140 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);129 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
141}130}
@@ -143,15 +132,14 @@ TEST_F(MulNoNanInfershape, dynamic_rank)
143// Case 8: int32 vector path.132// Case 8: int32 vector path.
144TEST_F(MulNoNanInfershape, vector_1d_int32)133TEST_F(MulNoNanInfershape, vector_1d_int32)
145{134{
146- gert::InfershapeContextPara para(135+ gert::InfershapeContextPara para("MulNoNan",
147- "MulNoNan",136+ {
148- {137+ {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},
149- {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},138+ {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},
150- {{{8}, {8}}, ge::DT_INT32, ge::FORMAT_ND},139+ },
151- },140+ {
152- {141+ {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},
153- {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},142+ });
154- });
155 std::vector<std::vector<int64_t>> expectOutputShape = {{8}};143 std::vector<std::vector<int64_t>> expectOutputShape = {{8}};
156 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);144 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
157}145}
@@ -159,15 +147,14 @@ TEST_F(MulNoNanInfershape, vector_1d_int32)
159// Case 9: row x column mutual broadcast x1=[1,5], x2=[5,1] -> [5,5], fp32.147// Case 9: row x column mutual broadcast x1=[1,5], x2=[5,1] -> [5,5], fp32.
160TEST_F(MulNoNanInfershape, row_col_broadcast_fp32)148TEST_F(MulNoNanInfershape, row_col_broadcast_fp32)
161{149{
162- gert::InfershapeContextPara para(150+ gert::InfershapeContextPara para("MulNoNan",
163- "MulNoNan",151+ {
164- {152+ {{{1, 5}, {1, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},
165- {{{1, 5}, {1, 5}}, ge::DT_FLOAT, ge::FORMAT_ND},153+ {{{5, 1}, {5, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},
166- {{{5, 1}, {5, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},154+ },
167- },155+ {
168- {156+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
169- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},157+ });
170- });
171 std::vector<std::vector<int64_t>> expectOutputShape = {{5, 5}};158 std::vector<std::vector<int64_t>> expectOutputShape = {{5, 5}};
172 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);159 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
173}160}
@@ -175,15 +162,14 @@ TEST_F(MulNoNanInfershape, row_col_broadcast_fp32)
175// Case 10: trailing column-vector broadcast x1=[4,1], x2=[4,6] -> [4,6], fp32.162// Case 10: trailing column-vector broadcast x1=[4,1], x2=[4,6] -> [4,6], fp32.
176TEST_F(MulNoNanInfershape, col_vector_broadcast_fp32)163TEST_F(MulNoNanInfershape, col_vector_broadcast_fp32)
177{164{
178- gert::InfershapeContextPara para(165+ gert::InfershapeContextPara para("MulNoNan",
179- "MulNoNan",166+ {
180- {167+ {{{4, 1}, {4, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},
181- {{{4, 1}, {4, 1}}, ge::DT_FLOAT, ge::FORMAT_ND},168+ {{{4, 6}, {4, 6}}, ge::DT_FLOAT, ge::FORMAT_ND},
182- {{{4, 6}, {4, 6}}, ge::DT_FLOAT, ge::FORMAT_ND},169+ },
183- },170+ {
184- {171+ {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},
185- {{{}, {}}, ge::DT_FLOAT, ge::FORMAT_ND},172+ });
186- });
187 std::vector<std::vector<int64_t>> expectOutputShape = {{4, 6}};173 std::vector<std::vector<int64_t>> expectOutputShape = {{4, 6}};
188 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);174 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
189}175}
@@ -191,15 +177,14 @@ TEST_F(MulNoNanInfershape, col_vector_broadcast_fp32)
191// Case 11: 3-D mutual broadcast x1=[2,1,4], x2=[1,3,4] -> [2,3,4], fp16.177// Case 11: 3-D mutual broadcast x1=[2,1,4], x2=[1,3,4] -> [2,3,4], fp16.
192TEST_F(MulNoNanInfershape, mutual_3d_broadcast_fp16)178TEST_F(MulNoNanInfershape, mutual_3d_broadcast_fp16)
193{179{
194- gert::InfershapeContextPara para(180+ gert::InfershapeContextPara para("MulNoNan",
195- "MulNoNan",181+ {
196- {182+ {{{2, 1, 4}, {2, 1, 4}}, ge::DT_FLOAT16, ge::FORMAT_ND},
197- {{{2, 1, 4}, {2, 1, 4}}, ge::DT_FLOAT16, ge::FORMAT_ND},183+ {{{1, 3, 4}, {1, 3, 4}}, ge::DT_FLOAT16, ge::FORMAT_ND},
198- {{{1, 3, 4}, {1, 3, 4}}, ge::DT_FLOAT16, ge::FORMAT_ND},184+ },
199- },185+ {
200- {186+ {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},
201- {{{}, {}}, ge::DT_FLOAT16, ge::FORMAT_ND},187+ });
202- });
203 std::vector<std::vector<int64_t>> expectOutputShape = {{2, 3, 4}};188 std::vector<std::vector<int64_t>> expectOutputShape = {{2, 3, 4}};
204 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);189 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
205}190}
@@ -207,15 +192,110 @@ TEST_F(MulNoNanInfershape, mutual_3d_broadcast_fp16)
207// Case 12: cross-rank where x2 is the higher-rank input x1=[5], x2=[3,4,5] -> [3,4,5], int32.192// Case 12: cross-rank where x2 is the higher-rank input x1=[5], x2=[3,4,5] -> [3,4,5], int32.
208TEST_F(MulNoNanInfershape, cross_rank_x2_bigger_int32)193TEST_F(MulNoNanInfershape, cross_rank_x2_bigger_int32)
209{194{
210- gert::InfershapeContextPara para(195+ gert::InfershapeContextPara para("MulNoNan",
211- "MulNoNan",196+ {
212- {197+ {{{5}, {5}}, ge::DT_INT32, ge::FORMAT_ND},
213- {{{5}, {5}}, ge::DT_INT32, ge::FORMAT_ND},198+ {{{3, 4, 5}, {3, 4, 5}}, ge::DT_INT32, ge::FORMAT_ND},
214- {{{3, 4, 5}, {3, 4, 5}}, ge::DT_INT32, ge::FORMAT_ND},199+ },
215- },200+ {
216- {201+ {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},
217- {{{}, {}}, ge::DT_INT32, ge::FORMAT_ND},202+ });
218- });
219 std::vector<std::vector<int64_t>> expectOutputShape = {{3, 4, 5}};203 std::vector<std::vector<int64_t>> expectOutputShape = {{3, 4, 5}};
220 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);204 ExecuteTestCase(para, ge::GRAPH_SUCCESS, expectOutputShape);
221}205}
206+ 
207+// InferDataType: output dtype follows x1 (fp16).
208+TEST_F(MulNoNanInfershape, infer_datatype_fp16)
209+{
210+ auto spaceRegistry = gert::DefaultOpImplSpaceRegistryV2::GetInstance().GetSpaceRegistry();
211+ ASSERT_NE(spaceRegistry, nullptr);
212+ auto opImpl = spaceRegistry->GetOpImpl("MulNoNan");
213+ ASSERT_NE(opImpl, nullptr);
214+ ASSERT_NE(opImpl->infer_datatype, nullptr);
215+ 
216+ gert::OpInferDataTypeContextBuilder builder;
217+ builder.OpType("MulNoNan").OpName("MulNoNan");
218+ builder.IONum(2, 1);
219+ builder.InputTensorDesc(0, ge::DT_FLOAT16, ge::FORMAT_ND, ge::FORMAT_ND);
220+ builder.InputTensorDesc(1, ge::DT_FLOAT16, ge::FORMAT_ND, ge::FORMAT_ND);
221+ builder.OutputTensorDesc(0, ge::FORMAT_ND, ge::FORMAT_ND);
222+ auto contextHolder = builder.Build();
223+ auto* context = contextHolder.GetContext();
224+ ASSERT_NE(context, nullptr);
225+ 
226+ auto ret = opImpl->infer_datatype(context);
227+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
228+ EXPECT_EQ(context->GetOutputDataType(0), ge::DT_FLOAT16);
229+}
230+ 
231+// InferDataType: output dtype follows x1 (fp32).
232+TEST_F(MulNoNanInfershape, infer_datatype_fp32)
233+{
234+ auto spaceRegistry = gert::DefaultOpImplSpaceRegistryV2::GetInstance().GetSpaceRegistry();
235+ ASSERT_NE(spaceRegistry, nullptr);
236+ auto opImpl = spaceRegistry->GetOpImpl("MulNoNan");
237+ ASSERT_NE(opImpl, nullptr);
238+ ASSERT_NE(opImpl->infer_datatype, nullptr);
239+ 
240+ gert::OpInferDataTypeContextBuilder builder;
241+ builder.OpType("MulNoNan").OpName("MulNoNan");
242+ builder.IONum(2, 1);
243+ builder.InputTensorDesc(0, ge::DT_FLOAT, ge::FORMAT_ND, ge::FORMAT_ND);
244+ builder.InputTensorDesc(1, ge::DT_FLOAT, ge::FORMAT_ND, ge::FORMAT_ND);
245+ builder.OutputTensorDesc(0, ge::FORMAT_ND, ge::FORMAT_ND);
246+ auto contextHolder = builder.Build();
247+ auto* context = contextHolder.GetContext();
248+ ASSERT_NE(context, nullptr);
249+ 
250+ auto ret = opImpl->infer_datatype(context);
251+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
252+ EXPECT_EQ(context->GetOutputDataType(0), ge::DT_FLOAT);
253+}
254+ 
255+// InferDataType: output dtype follows x1 (bf16).
256+TEST_F(MulNoNanInfershape, infer_datatype_bf16)
257+{
258+ auto spaceRegistry = gert::DefaultOpImplSpaceRegistryV2::GetInstance().GetSpaceRegistry();
259+ ASSERT_NE(spaceRegistry, nullptr);
260+ auto opImpl = spaceRegistry->GetOpImpl("MulNoNan");
261+ ASSERT_NE(opImpl, nullptr);
262+ ASSERT_NE(opImpl->infer_datatype, nullptr);
263+ 
264+ gert::OpInferDataTypeContextBuilder builder;
265+ builder.OpType("MulNoNan").OpName("MulNoNan");
266+ builder.IONum(2, 1);
267+ builder.InputTensorDesc(0, ge::DT_BF16, ge::FORMAT_ND, ge::FORMAT_ND);
268+ builder.InputTensorDesc(1, ge::DT_BF16, ge::FORMAT_ND, ge::FORMAT_ND);
269+ builder.OutputTensorDesc(0, ge::FORMAT_ND, ge::FORMAT_ND);
270+ auto contextHolder = builder.Build();
271+ auto* context = contextHolder.GetContext();
272+ ASSERT_NE(context, nullptr);
273+ 
274+ auto ret = opImpl->infer_datatype(context);
275+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
276+ EXPECT_EQ(context->GetOutputDataType(0), ge::DT_BF16);
277+}
278+ 
279+// InferDataType: output dtype follows x1 (int32).
280+TEST_F(MulNoNanInfershape, infer_datatype_int32)
281+{
282+ auto spaceRegistry = gert::DefaultOpImplSpaceRegistryV2::GetInstance().GetSpaceRegistry();
283+ ASSERT_NE(spaceRegistry, nullptr);
284+ auto opImpl = spaceRegistry->GetOpImpl("MulNoNan");
285+ ASSERT_NE(opImpl, nullptr);
286+ ASSERT_NE(opImpl->infer_datatype, nullptr);
287+ 
288+ gert::OpInferDataTypeContextBuilder builder;
289+ builder.OpType("MulNoNan").OpName("MulNoNan");
290+ builder.IONum(2, 1);
291+ builder.InputTensorDesc(0, ge::DT_INT32, ge::FORMAT_ND, ge::FORMAT_ND);
292+ builder.InputTensorDesc(1, ge::DT_INT32, ge::FORMAT_ND, ge::FORMAT_ND);
293+ builder.OutputTensorDesc(0, ge::FORMAT_ND, ge::FORMAT_ND);
294+ auto contextHolder = builder.Build();
295+ auto* context = contextHolder.GetContext();
296+ ASSERT_NE(context, nullptr);
297+ 
298+ auto ret = opImpl->infer_datatype(context);
299+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
300+ EXPECT_EQ(context->GetOutputDataType(0), ge::DT_INT32);
301+}