1 /**
2 * Copyright 2020 Huawei Technologies Co., Ltd
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "common/common_test.h"
18 #include "ir/param_info.h"
19 #include "frontend/operator/ops.h"
20 #include "backend/session/kernel_graph.h"
21 #include "backend/session/anf_runtime_algorithm.h"
22 #include "mindspore/ccsrc/runtime/device/kernel_info.h"
23 #include "utils/utils.h"
24
25 namespace mindspore {
26 namespace session {
27 using device::KernelInfo;
28 using KernelBuildInfoBuilder = kernel::KernelBuildInfo::KernelBuildInfoBuilder;
29
30 class KernelGraphTest : public UT::Common {
31 public:
32 KernelGraphTest() = default;
SetUp()33 void SetUp() override {}
TearDown()34 void TearDown() override {}
35 };
36
TEST_F(KernelGraphTest,NewValueNode)37 TEST_F(KernelGraphTest, NewValueNode) {
38 auto kernel_graph = std::make_shared<KernelGraph>();
39 auto add_value = NewValueNode(MakeValue(static_cast<int64_t>(0)));
40 MS_EXCEPTION_IF_NULL(add_value);
41 std::vector<int64_t> shape = {1};
42 auto x_abstract = std::make_shared<abstract::AbstractTensor>(kFloat32, shape);
43 add_value->set_abstract(x_abstract);
44 add_value->set_kernel_info(std::make_shared<KernelInfo>());
45 auto mutable_kernel_info = dynamic_cast<device::KernelInfo *>(add_value->kernel_info());
46 MS_EXCEPTION_IF_NULL(mutable_kernel_info);
47 std::shared_ptr<KernelBuildInfoBuilder> builder = std::make_shared<KernelBuildInfoBuilder>();
48 builder->SetOutputsFormat({kOpFormat_FRAC_Z});
49 builder->SetOutputsDeviceType({kFloat32->type_id()});
50 mutable_kernel_info->set_select_kernel_build_info(builder->Build());
51 auto new_value = kernel_graph->NewValueNode(add_value);
52 EXPECT_NE(new_value, nullptr);
53 EXPECT_EQ(AnfAlgo::GetOutputInferShape(new_value, 0)[0], 1);
54 EXPECT_EQ(AnfAlgo::GetOutputInferDataType(new_value, 0), kFloat32->type_id());
55 EXPECT_EQ(AnfAlgo::GetOutputFormat(new_value, 0), kOpFormat_DEFAULT);
56 EXPECT_EQ(AnfAlgo::GetOutputDeviceDataType(new_value, 0), kTypeUnknown);
57 }
58
TEST_F(KernelGraphTest,NewParameter)59 TEST_F(KernelGraphTest, NewParameter) {
60 auto anf_graph = std::make_shared<FuncGraph>();
61 auto kernel_graph = std::make_shared<KernelGraph>();
62 // test nullptr as input
63 auto new_paramter = kernel_graph->NewParameter();
64 EXPECT_NE(new_paramter, nullptr);
65 EXPECT_TRUE(new_paramter->isa<Parameter>());
66 EXPECT_EQ(AnfAlgo::GetOutputFormat(new_paramter, 0), kOpFormat_DEFAULT);
67 EXPECT_EQ(AnfAlgo::GetOutputDeviceDataType(new_paramter, 0), kMetaTypeNone);
68 // test non-weight parameter node as input
69 std::vector<int64_t> shape = {2, 32, 224, 224};
70 auto x_abstract = std::make_shared<abstract::AbstractTensor>(kFloat32, shape);
71 auto non_weight_parameter = anf_graph->add_parameter();
72 MS_EXCEPTION_IF_NULL(non_weight_parameter);
73 non_weight_parameter->set_abstract(x_abstract);
74 auto new_non_weight_parameter = kernel_graph->NewParameter(non_weight_parameter);
75 EXPECT_NE(new_non_weight_parameter, nullptr);
76 new_non_weight_parameter->set_name("non_weight_parameter");
77 EXPECT_EQ(AnfAlgo::GetOutputInferShape(new_non_weight_parameter, 0)[1], 32);
78 EXPECT_EQ(AnfAlgo::GetOutputInferDataType(new_non_weight_parameter, 0), kFloat32->type_id());
79 EXPECT_EQ(AnfAlgo::GetOutputFormat(new_non_weight_parameter, 0), kOpFormat_DEFAULT);
80 EXPECT_EQ(AnfAlgo::GetOutputDeviceDataType(new_non_weight_parameter, 0), kFloat32->type_id());
81 EXPECT_EQ(new_non_weight_parameter->name(), "non_weight_parameter");
82 // test weight parameter node as input
83 auto weight_parameter_node = anf_graph->add_parameter();
84 MS_EXCEPTION_IF_NULL(weight_parameter_node);
85 auto param_value_new = std::make_shared<tensor::Tensor>(kNumberTypeFloat32, shape);
86 weight_parameter_node->set_default_param(param_value_new);
87 weight_parameter_node->set_abstract(x_abstract);
88 auto new_weight_parameter_node = kernel_graph->NewParameter(weight_parameter_node);
89 EXPECT_NE(new_weight_parameter_node, nullptr);
90 EXPECT_TRUE(new_weight_parameter_node->has_default());
91 EXPECT_EQ(AnfAlgo::GetOutputInferShape(new_weight_parameter_node, 0)[2], 224);
92 EXPECT_EQ(AnfAlgo::GetOutputInferDataType(new_weight_parameter_node, 0), kFloat32->type_id());
93 EXPECT_EQ(AnfAlgo::GetOutputFormat(new_weight_parameter_node, 0), kOpFormat_DEFAULT);
94 EXPECT_EQ(AnfAlgo::GetOutputDeviceDataType(new_weight_parameter_node, 0), kTypeUnknown);
95 }
96
TEST_F(KernelGraphTest,NewCNode)97 TEST_F(KernelGraphTest, NewCNode) {
98 auto kernel_graph = std::make_shared<KernelGraph>();
99 auto add_value = NewValueNode(prim::kPrimAdd);
100 std::vector<AnfNodePtr> inputs = {add_value};
101 auto new_cnode = kernel_graph->NewCNode(inputs);
102 EXPECT_NE(new_cnode, nullptr);
103 EXPECT_EQ(AnfAlgo::GetCNodeName(new_cnode), prim::kPrimAdd->name());
104 EXPECT_TRUE(AnfAlgo::GetOutputInferShape(new_cnode, 0).empty());
105 EXPECT_EQ(AnfAlgo::GetOutputInferDataType(new_cnode, 0), kMetaTypeNone);
106 }
107
TEST_F(KernelGraphTest,MutableInputs)108 TEST_F(KernelGraphTest, MutableInputs) {
109 auto kernel_graph = std::make_shared<KernelGraph>();
110 auto x_parameter = kernel_graph->add_parameter();
111 MS_EXCEPTION_IF_NULL(x_parameter);
112 x_parameter->set_name("x_parameter");
113 auto y_parameter = kernel_graph->add_parameter();
114 MS_EXCEPTION_IF_NULL(y_parameter);
115 y_parameter->set_name("y_parameter");
116 std::vector<AnfNodePtr> inputs = {x_parameter, y_parameter};
117 auto mutable_inputs = kernel_graph->MutableInputs();
118 MS_EXCEPTION_IF_NULL(mutable_inputs);
119 *mutable_inputs = inputs;
120 auto first_input = kernel_graph->inputs()[0];
121 MS_EXCEPTION_IF_NULL(first_input);
122 auto first_parameter = first_input->cast<ParameterPtr>();
123 MS_EXCEPTION_IF_NULL(first_parameter);
124 EXPECT_EQ(first_parameter->name(), "x_parameter");
125 auto second_input = kernel_graph->inputs()[1];
126 MS_EXCEPTION_IF_NULL(second_input);
127 auto second_parameter = second_input->cast<ParameterPtr>();
128 MS_EXCEPTION_IF_NULL(second_parameter);
129 EXPECT_EQ(second_parameter->name(), "y_parameter");
130 }
131
TEST_F(KernelGraphTest,SetExecOrderByDefault)132 TEST_F(KernelGraphTest, SetExecOrderByDefault) {
133 /*
134 * define kernel graph:
135 * x ----- y
136 * add ----- z
137 * mul
138 * return
139 */
140 auto kernel_graph = std::make_shared<KernelGraph>();
141 std::vector<int64_t> shape = {2, 32, 224, 224};
142 auto abstract = std::make_shared<abstract::AbstractTensor>(kFloat32, shape);
143
144 auto x_parameter = kernel_graph->NewParameter();
145 MS_EXCEPTION_IF_NULL(x_parameter);
146 x_parameter->set_name("x_parameter");
147 x_parameter->set_abstract(abstract);
148 auto y_parameter = kernel_graph->NewParameter();
149 MS_EXCEPTION_IF_NULL(y_parameter);
150 y_parameter->set_name("y_parameter");
151 y_parameter->set_abstract(abstract);
152 std::vector<AnfNodePtr> add_inputs = {NewValueNode(prim::kPrimAdd), x_parameter, y_parameter};
153 auto add = kernel_graph->NewCNode(add_inputs);
154 MS_EXCEPTION_IF_NULL(add);
155 add->set_abstract(abstract);
156
157 auto z_parameter = kernel_graph->NewParameter();
158 MS_EXCEPTION_IF_NULL(z_parameter);
159 z_parameter->set_name("z_parameter");
160 z_parameter->set_abstract(abstract);
161 std::vector<AnfNodePtr> mul_inputs = {NewValueNode(prim::kPrimMul), add, z_parameter};
162 auto mul = kernel_graph->NewCNode(mul_inputs);
163 MS_EXCEPTION_IF_NULL(mul);
164 mul->set_abstract(abstract);
165
166 std::vector<AnfNodePtr> make_tuple_inputs = {NewValueNode(prim::kPrimMakeTuple), mul};
167 auto make_tuple = kernel_graph->NewCNode(make_tuple_inputs);
168 kernel_graph->set_output(make_tuple);
169 // test outputs() function
170 auto outputs = kernel_graph->outputs();
171 EXPECT_EQ(outputs.size(), 1);
172 EXPECT_EQ(AnfAlgo::GetCNodeName(outputs[0]), prim::kPrimMul->name());
173 // test SetExecOrderByDefault() function
174 kernel_graph->SetExecOrderByDefault();
175 auto execution_order = kernel_graph->execution_order();
176 EXPECT_EQ(execution_order.size(), 2);
177 EXPECT_EQ(AnfAlgo::GetCNodeName(execution_order[0]), prim::kPrimAdd->name());
178 EXPECT_EQ(AnfAlgo::GetCNodeName(execution_order[1]), prim::kPrimMul->name());
179 // test set_execution_order() function
180 kernel_graph->set_execution_order({add});
181 execution_order = kernel_graph->execution_order();
182 EXPECT_EQ(execution_order.size(), 1);
183 EXPECT_EQ(AnfAlgo::GetCNodeName(execution_order[0]), prim::kPrimAdd->name());
184 }
185
TEST_F(KernelGraphTest,SetGraphId)186 TEST_F(KernelGraphTest, SetGraphId) {
187 auto kernel_graph = std::make_shared<KernelGraph>();
188 kernel_graph->set_graph_id(1);
189 EXPECT_EQ(kernel_graph->graph_id(), 1);
190 }
191
192 } // namespace session
193 } // namespace mindspore
194