Huawei_Technology
/
mindspore
Not watched
1
0
Fork 0
Code
Releases 13 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: db80643ee2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'db80643ee2'
${ noResults }
mindspore/tests/ut/cpp/optimizer/lib_test.cc

634 lines
30 kB
Raw Blame History 

  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. #include <iostream>

  17. #include <memory>

  18. 

  19. #include "common/common_test.h"

  20. 

  21. #include "common/py_func_graph_fetcher.h"

  22. #include "ir/anf.h"

  23. #include "ir/func_graph.h"

  24. #include "ir/func_graph_cloner.h"

  25. #include "ir/manager.h"

  26. #include "ir/value.h"

  27. #include "ir/visitor.h"

  28. #include "frontend/operator/ops.h"

  29. #include "frontend/optimizer/irpass.h"

  30. #include "pipeline/jit/resource.h"

  31. #include "debug/draw.h"

  32. #include "pipeline/jit/parse/data_converter.h"

  33. 

  34. namespace mindspore {

  35. namespace opt {

  36. using abstract::AnalysisResult;

  37. 

  38. class TestOptLib : public UT::Common {

  39.  public:

  40.   TestOptLib() : getPyFun("gtest_input.optimizer.opt_test", true), irpass() {}

  41.   void SetUp() {

  42.     UT::InitPythonPath();

  43.     parse::data_converter::ClearObjectCache();

  44.   }

  45.   FuncGraphPtr RunTransform(FuncGraphPtr gbefore, const SubstitutionList &transform) {

  46.     equiv_node.clear();

  47.     equiv_graph.clear();

  48. 

  49.     FuncGraphPtr gbefore_clone = BasicClone(gbefore);

  50.     OptimizerPtr optimizer = std::make_shared<Optimizer>("ut_test", std::make_shared<pipeline::Resource>());

  51.     transform(gbefore_clone, optimizer);

  52.     return gbefore_clone;

  53.   }

  54.   FuncGraphPtr RunSubs(FuncGraphPtr before, std::vector<SubstitutionPtr> opts = {}) {

  55.     SubstitutionList eq(opts);

  56.     return RunTransform(before, eq);

  57.   }

  58.   bool CheckTransform(FuncGraphPtr gbefore, FuncGraphPtr gafter, const SubstitutionList &transform,

  59.                       bool save_graphs = false) {

  60.     equiv_node.clear();

  61.     equiv_graph.clear();

  62. 

  63.     FuncGraphPtr gbefore_clone = BasicClone(gbefore);

  64.     OptimizerPtr optimizer = std::make_shared<Optimizer>("ut_test", std::make_shared<pipeline::Resource>());

  65.     transform(gbefore_clone, optimizer);

  66.     if (save_graphs) {

  67.       draw::Draw("before.dot", gbefore);

  68.       draw::Draw("after.dot", gbefore_clone);

  69.       draw::Draw("expected.dot", gafter);

  70.     }

  71.     return Isomorphic(gbefore_clone, gafter, &equiv_graph, &equiv_node);

  72.   }

  73.   bool CheckOpt(FuncGraphPtr before, FuncGraphPtr after, std::vector<SubstitutionPtr> opts = {},

  74.                 bool save_graphs = false) {

  75.     if (nullptr == before || nullptr == after) {

  76.       return false;

  77.     }

  78.     SubstitutionList eq(opts);

  79.     return CheckTransform(before, after, eq, save_graphs);

  80.   }

  81. 

  82.  public:

  83.   UT::PyFuncGraphFetcher getPyFun;

  84.   FuncGraphPairMapEquiv equiv_graph;

  85.   NodeMapEquiv equiv_node;

  86.   irpass::OptimizeIRPassLib irpass;

  87. };

  88. 

  89. TEST_F(TestOptLib, test_expendJ) {

  90.   FuncGraphPtr before = getPyFun("test_expendJ");

  91. 

  92.   ASSERT_TRUE(nullptr != before);

  93. 

  94.   FuncGraphPtr after = RunSubs(before, std::vector<SubstitutionPtr>({irpass.expand_jprim_}));

  95. }

  96. 

  97. TEST_F(TestOptLib, test_simplify_always_true_false) {

  98.   FuncGraphPtr before1 = getPyFun.CallAndParseRet("test_simplify_always_true_false", "before_1");

  99.   FuncGraphPtr before2 = getPyFun.CallAndParseRet("test_simplify_always_true_false", "before_2");

  100.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_simplify_always_true_false", "after");

  101.   auto patterns = std::vector<SubstitutionPtr>({irpass.switch_simplify_});

  102.   ASSERT_TRUE(CheckOpt(before1, after, patterns));

  103.   ASSERT_TRUE(CheckOpt(before2, after, patterns));

  104. }

  105. 

  106. TEST_F(TestOptLib, test_inline) {

  107.   FuncGraphPtr before1 = getPyFun.CallAndParseRet("test_inline", "before");

  108.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_inline", "after");

  109.   // add infer and renormalize

  110.   std::shared_ptr<mindspore::pipeline::Resource> res = std::make_shared<mindspore::pipeline::Resource>();

  111.   AbstractBasePtrList args_spec_list;

  112.   AbstractBasePtr abstract_v1 = abstract::FromValue(1, true);

  113.   AbstractBasePtr abstract_v2 = abstract::FromValue(2, true);

  114.   args_spec_list.push_back(abstract_v1);

  115.   args_spec_list.push_back(abstract_v2);

  116.   AnalysisResult result = pipeline::AbstractAnalyze(res, before1, args_spec_list);

  117.   FuncGraphPtr new_graph = pipeline::ProgramSpecialize(res, before1, result.context);

  118.   auto patterns = std::vector<SubstitutionPtr>({irpass.arithmetic_simplify_, irpass.switch_simplify_, irpass.inline_});

  119.   ASSERT_TRUE(CheckOpt(new_graph, after, patterns));

  120. }

  121. 

  122. TEST_F(TestOptLib, test_inline_successively) {

  123.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_inline_successively", "before");

  124.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_inline_successively", "after");

  125.   auto patterns = std::vector<SubstitutionPtr>({irpass.inline_});

  126.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  127. }

  128. 

  129. TEST_F(TestOptLib, test_inline_closure) {

  130.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_inline_closure", "before");

  131.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_inline_closure", "after");

  132.   auto patterns = std::vector<SubstitutionPtr>({irpass.inline_});

  133.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  134. }

  135. 

  136. TEST_F(TestOptLib, test_inline_deep_closure) {

  137.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_inline_deep_closure", "before");

  138.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_inline_deep_closure", "after");

  139.   auto patterns = std::vector<SubstitutionPtr>({irpass.inline_});

  140.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  141. }

  142. 

  143. TEST_F(TestOptLib, test_inline_new_closure) {

  144.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_inline_new_closure", "before");

  145.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_inline_new_closure", "after");

  146.   auto patterns = std::vector<SubstitutionPtr>({irpass.inline_});

  147.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  148. }

  149. 

  150. TEST_F(TestOptLib, test_inline_while) {

  151.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_inline_while", "before");

  152.   auto patterns = std::vector<SubstitutionPtr>({irpass.inline_});

  153.   FuncGraphPtr after = RunSubs(before, patterns);

  154.   ASSERT_TRUE(CheckOpt(before, after, patterns, true));

  155. }

  156. 

  157. TEST_F(TestOptLib, test_arithmetic) {

  158.   FuncGraphPtr b1_0 = getPyFun.CallAndParseRet("test_arithmetic", "multiply_by_zero_l");

  159.   FuncGraphPtr b2_0 = getPyFun.CallAndParseRet("test_arithmetic", "multiply_by_zero_r");

  160.   FuncGraphPtr b1 = getPyFun.CallAndParseRet("test_arithmetic", "multiply_by_one_l");

  161.   FuncGraphPtr b2 = getPyFun.CallAndParseRet("test_arithmetic", "multiply_by_one_r");

  162.   FuncGraphPtr b3 = getPyFun.CallAndParseRet("test_arithmetic", "add_zero_l");

  163.   FuncGraphPtr b4 = getPyFun.CallAndParseRet("test_arithmetic", "add_zero_r");

  164.   FuncGraphPtr b5 = getPyFun.CallAndParseRet("test_arithmetic", "elim_identity");

  165.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_arithmetic", "after");

  166.   FuncGraphPtr after_0 = getPyFun.CallAndParseRet("test_arithmetic", "after_0");

  167. 

  168.   auto patterns = std::vector<SubstitutionPtr>({irpass.arithmetic_simplify_});

  169. 

  170.   ASSERT_TRUE(CheckOpt(b1_0, after_0, patterns));

  171.   ASSERT_TRUE(CheckOpt(b2_0, after_0, patterns));

  172.   ASSERT_TRUE(CheckOpt(b1, after, patterns));

  173.   ASSERT_TRUE(CheckOpt(b2, after, patterns));

  174.   ASSERT_TRUE(CheckOpt(b3, after, patterns));

  175.   ASSERT_TRUE(CheckOpt(b4, after, patterns));

  176.   ASSERT_TRUE(CheckOpt(b5, after, patterns));

  177. }

  178. 

  179. TEST_F(TestOptLib, test_elim_cast_same_dtype) {

  180.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_elim_cast_same_dtype", "fp32_cast_fp32");

  181.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_elim_cast_same_dtype", "after");

  182.   // construct such case that cast srcT equal dstT

  183.   auto &inputs = before->output()->cast<CNodePtr>()->inputs();

  184.   if (inputs.size() > 2) {

  185.     auto cast_node = inputs[0];

  186.     auto cast_py = cast_node->cast<ValueNodePtr>()->value()->cast<PrimitivePyPtr>();

  187.     cast_py->set_attr("SrcT", TypeIdToType(kNumberTypeFloat32));

  188.     cast_py->set_attr("DstT", TypeIdToType(kNumberTypeFloat32));

  189. 

  190.     auto x_node = inputs[1];

  191.     std::vector<int> shp = {2, 3};

  192.     tensor::TensorPtr x_tensor = std::make_shared<tensor::Tensor>(kFloat32->type_id(), shp);

  193.     auto x_abstract = x_tensor->ToAbstract();

  194.     x_node->set_abstract(x_abstract);

  195. 

  196.     TypePtr t = std::make_shared<TensorType>(std::make_shared<Float>(32));

  197.     ValueNodePtr val = std::make_shared<ValueNode>(t);

  198.     auto t_abstract = t->ToAbstract();

  199.     val->set_abstract(t_abstract);

  200.     before->output()->cast<CNodePtr>()->set_input(2, val);

  201.   }

  202.   FuncGraphPtr gbefore_clone = BasicClone(before);

  203.   auto patterns = std::vector<SubstitutionPtr>({irpass.cast_eliminate_});

  204.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  205. 

  206.   TypePtr t = std::make_shared<Float>(32);

  207.   ValueNodePtr val = std::make_shared<ValueNode>(t);

  208.   auto t_abstract = t->ToAbstract();

  209.   val->set_abstract(t_abstract);

  210.   gbefore_clone->output()->cast<CNodePtr>()->set_input(2, val);

  211.   ASSERT_TRUE(CheckOpt(gbefore_clone, after, patterns));

  212. }

  213. 

  214. TEST_F(TestOptLib, test_elim_reshape_same_shape) {

  215.   FuncGraphPtr before = getPyFun.CallAndParseRet("elim_reshape_same_shape", "reshape_to_2_3");

  216.   FuncGraphPtr after = getPyFun.CallAndParseRet("elim_reshape_same_shape", "after");

  217.   // construct such case that shape is equal to reshape target

  218.   auto &inputs = before->output()->cast<CNodePtr>()->inputs();

  219.   if (inputs.size() > 1) {

  220.     auto x_node = inputs[1];

  221.     std::vector<int> shp = {2, 3};

  222.     tensor::TensorPtr x_tensor = std::make_shared<tensor::Tensor>(kFloat32->type_id(), shp);

  223.     auto x_abstract = x_tensor->ToAbstract();

  224.     x_node->set_abstract(x_abstract);

  225.     before->output()->set_abstract(x_abstract);

  226.   }

  227.   auto patterns = std::vector<SubstitutionPtr>({irpass.reshape_eliminate_});

  228.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  229.   if (inputs.size() > 1) {

  230.     auto x_node = inputs[1];

  231.     std::vector<int> shp = {3, 2};

  232.     tensor::TensorPtr x_tensor = std::make_shared<tensor::Tensor>(kFloat32->type_id(), shp);

  233.     auto x_abstract = x_tensor->ToAbstract();

  234.     x_node->set_abstract(x_abstract);

  235.   }

  236.   ASSERT_FALSE(CheckOpt(before, after, patterns));

  237. }

  238. 

  239. TEST_F(TestOptLib, elim_two_reshape) {

  240.   FuncGraphPtr before = getPyFun.CallAndParseRet("elim_two_reshape", "before");

  241.   FuncGraphPtr after = getPyFun.CallAndParseRet("elim_two_reshape", "after");

  242. 

  243.   auto patterns = std::vector<SubstitutionPtr>({irpass.reshape_eliminate_});

  244.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  245. }

  246. 

  247. TEST_F(TestOptLib, elim_two_cast) {

  248.   FuncGraphPtr before = getPyFun.CallAndParseRet("elim_two_cast", "before");

  249.   FuncGraphPtr after = getPyFun.CallAndParseRet("elim_two_cast", "after");

  250. 

  251.   auto patterns = std::vector<SubstitutionPtr>({irpass.cast_eliminate_});

  252.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  253. }

  254. 

  255. TEST_F(TestOptLib, test_elim_transpose) {

  256.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_elim_transpose", "before");

  257.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_elim_transpose", "after");

  258. 

  259.   auto patterns = std::vector<SubstitutionPtr>({irpass.transpose_eliminate_});

  260.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  261. }

  262. 

  263. TEST_F(TestOptLib, test_elim_depend_value) {

  264.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_elim_depend_value", "before");

  265.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_elim_depend_value", "after");

  266. 

  267.   auto patterns = std::vector<SubstitutionPtr>({irpass.depend_value_elim_});

  268.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  269. }

  270. 

  271. TEST_F(TestOptLib, test_elim_tile_multiply_one) {

  272.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_elim_tile_multiply_one", "before");

  273.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_elim_tile_multiply_one", "after");

  274. 

  275.   auto patterns = std::vector<SubstitutionPtr>({irpass.tile_eliminate_});

  276.   ASSERT_TRUE(CheckOpt(before, after, patterns, true));

  277. }

  278. 

  279. TEST_F(TestOptLib, test_elim_reduce_mean_shape_one) {

  280.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_elim_reduce_mean_shape_one", "before");

  281.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_elim_reduce_mean_shape_one", "after");

  282. 

  283.   // construct such case that input x shape is (1), keepdims is true

  284.   auto inputs = before->output()->cast<CNodePtr>()->inputs();

  285.   if (inputs.size() > 2) {

  286.     auto x_node = inputs[1];

  287.     std::vector<int> shp = {1};

  288.     tensor::TensorPtr x_tensor = std::make_shared<tensor::Tensor>(kFloat32->type_id(), shp);

  289.     auto x_abstract = x_tensor->ToAbstract();

  290.     x_node->set_abstract(x_abstract);

  291. 

  292.     auto reduce_node = inputs[0];

  293.     auto reduce = reduce_node->cast<ValueNodePtr>()->value()->cast<PrimitivePtr>();

  294.     reduce->set_attr("keep_dims", std::make_shared<BoolImm>(true));

  295.   }

  296. 

  297.   auto patterns = std::vector<SubstitutionPtr>({irpass.reduce_eliminate_});

  298.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  299. }

  300. 

  301. TEST_F(TestOptLib, test_elim_all_shape_one) {

  302.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_elim_all_shape_one", "before");

  303.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_elim_all_shape_one", "after");

  304. 

  305.   // construct such case that input x shape is (1) keep_dims is true

  306.   auto inputs = before->output()->cast<CNodePtr>()->inputs();

  307.   if (inputs.size() > 2) {

  308.     auto x_node = inputs[1];

  309.     std::vector<int> shp = {1};

  310.     tensor::TensorPtr x_tensor = std::make_shared<tensor::Tensor>(kFloat32->type_id(), shp);

  311.     auto x_abstract = x_tensor->ToAbstract();

  312.     x_node->set_abstract(x_abstract);

  313. 

  314.     auto reduce_node = inputs[0];

  315.     auto reduce = reduce_node->cast<ValueNodePtr>()->value()->cast<PrimitivePtr>();

  316.     reduce->set_attr("keep_dims", std::make_shared<BoolImm>(true));

  317.   }

  318.   auto patterns = std::vector<SubstitutionPtr>({irpass.reduce_eliminate_});

  319.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  320. }

  321. 

  322. TEST_F(TestOptLib, test_elim_sum_shape_one) {

  323.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_elim_sum_shape_one", "before");

  324.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_elim_sum_shape_one", "after");

  325. 

  326.   // construct such case that input x shape is (1) keepdims is true

  327.   auto inputs = before->output()->cast<CNodePtr>()->inputs();

  328.   if (inputs.size() > 2) {

  329.     auto x_node = inputs[1];

  330.     std::vector<int> shp = {1};

  331.     tensor::TensorPtr x_tensor = std::make_shared<tensor::Tensor>(kFloat32->type_id(), shp);

  332.     auto x_abstract = x_tensor->ToAbstract();

  333.     x_node->set_abstract(x_abstract);

  334. 

  335.     auto reduce_node = inputs[0];

  336.     auto reduce = reduce_node->cast<ValueNodePtr>()->value()->cast<PrimitivePtr>();

  337.     reduce->set_attr("keep_dims", std::make_shared<BoolImm>(true));

  338.   }

  339.   auto patterns = std::vector<SubstitutionPtr>({irpass.reduce_eliminate_});

  340.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  341. }

  342. 

  343. TEST_F(TestOptLib, test_tuple_getitem) {

  344.   FuncGraphPtr make_get_0 = getPyFun.CallAndParseRet("test_tuple_getitem", "make_get_0");

  345.   FuncGraphPtr make_get_1 = getPyFun.CallAndParseRet("test_tuple_getitem", "make_get_1");

  346.   FuncGraphPtr after_0 = getPyFun.CallAndParseRet("test_tuple_getitem", "after_0");

  347.   FuncGraphPtr after_1 = getPyFun.CallAndParseRet("test_tuple_getitem", "after_1");

  348. 

  349.   FuncGraphPtr make_get_const = std::make_shared<FuncGraph>();

  350.   auto value_node_1 = NewValueNode(1);

  351.   auto value_node_2 = NewValueNode(2);

  352.   std::vector<int> vec{1, 2};

  353.   auto value_node_tuple = NewValueNode(MakeValue(vec));

  354.   std::vector<AnfNodePtr> node_list{

  355.     NewValueNode(prim::kPrimTupleGetItem),

  356.     value_node_tuple,

  357.     value_node_1

  358.   };

  359.   auto get_item = make_get_const->NewCNode(node_list);

  360.   make_get_const->set_output(get_item);

  361. 

  362.   FuncGraphPtr after_2 = std::make_shared<FuncGraph>();

  363.   after_2->set_output(value_node_2);

  364. 

  365.   auto patterns = std::vector<SubstitutionPtr>({irpass.item_tuple_eliminate_});

  366.   ASSERT_TRUE(CheckOpt(make_get_0, after_0, patterns));

  367.   ASSERT_TRUE(CheckOpt(make_get_1, after_1, patterns));

  368.   ASSERT_TRUE(CheckOpt(make_get_const, after_2, patterns));

  369. }

  370. 

  371. TEST_F(TestOptLib, test_tuple_setitem) {

  372.   FuncGraphPtr before_0 = getPyFun.CallAndParseRet("test_tuple_setitem", "before_0");

  373.   FuncGraphPtr before_1 = getPyFun.CallAndParseRet("test_tuple_setitem", "before_1");

  374.   FuncGraphPtr after_0 = getPyFun.CallAndParseRet("test_tuple_setitem", "after_0");

  375.   FuncGraphPtr after_1 = getPyFun.CallAndParseRet("test_tuple_setitem", "after_1");

  376. 

  377.   auto patterns = std::vector<SubstitutionPtr>({irpass.item_tuple_eliminate_});

  378. 

  379.   ASSERT_TRUE(CheckOpt(before_0, after_0, patterns));

  380.   ASSERT_TRUE(CheckOpt(before_1, after_1, patterns));

  381. }

  382. 

  383. TEST_F(TestOptLib, test_tuple_get_set_item) {

  384.   FuncGraphPtr before_0 = getPyFun.CallAndParseRet("test_tuple_get_set_item", "before_0");

  385.   FuncGraphPtr after_0 = getPyFun.CallAndParseRet("test_tuple_get_set_item", "after_0");

  386.   FuncGraphPtr before_1 = getPyFun.CallAndParseRet("test_tuple_get_set_item", "before_0");

  387.   FuncGraphPtr after_1 = getPyFun.CallAndParseRet("test_tuple_get_set_item", "after_0");

  388. 

  389.   auto patterns = std::vector<SubstitutionPtr>({irpass.item_tuple_eliminate_});

  390. 

  391.   ASSERT_TRUE(CheckOpt(before_0, after_0, patterns));

  392.   ASSERT_TRUE(CheckOpt(before_1, after_1, patterns));

  393. }

  394. 

  395. TEST_F(TestOptLib, test_partial) {

  396.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_partial", "before");

  397.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_partial", "after");

  398. 

  399.   auto patterns = std::vector<SubstitutionPtr>({irpass.partial_eliminate_});

  400. 

  401.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  402. }

  403. 

  404. TEST_F(TestOptLib, test_replace_applicator) {

  405.   FuncGraphPtr before1 = getPyFun.CallAndParseRet("test_replace_applicator", "before1");

  406.   FuncGraphPtr before2 = getPyFun.CallAndParseRet("test_replace_applicator", "before2");

  407.   FuncGraphPtr before3 = getPyFun.CallAndParseRet("test_replace_applicator", "before3");

  408.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_replace_applicator", "after");

  409. 

  410.   auto patterns = std::vector<SubstitutionPtr>({irpass.replace_applicator_});

  411. 

  412.   ASSERT_TRUE(CheckOpt(before1, after, patterns));

  413.   ASSERT_TRUE(CheckOpt(before2, after, patterns));

  414.   ASSERT_TRUE(CheckOpt(before3, before3, patterns));

  415. }

  416. 

  417. TEST_F(TestOptLib, test_specialize_on_graph_arguments) {

  418.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_specialize_on_graph_arguments", "before");

  419.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_specialize_on_graph_arguments", "after");

  420. 

  421.   auto patterns = std::vector<SubstitutionPtr>({irpass.specialize_transform_});

  422. 

  423.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  424. }

  425. 

  426. TEST_F(TestOptLib, test_incorporate_getitem) {

  427.   FuncGraphPtr before1 = getPyFun.CallAndParseRet("test_incorporate_getitem", "before1");

  428.   FuncGraphPtr before2 = getPyFun.CallAndParseRet("test_incorporate_getitem", "before2");

  429.   FuncGraphPtr after1 = getPyFun.CallAndParseRet("test_incorporate_getitem", "after1");

  430.   FuncGraphPtr after2 = getPyFun.CallAndParseRet("test_incorporate_getitem", "after2");

  431. 

  432.   auto patterns = std::vector<SubstitutionPtr>({irpass.incorporate_getitem_set_});

  433. 

  434.   ASSERT_TRUE(CheckOpt(before1, after1, patterns));

  435.   ASSERT_TRUE(CheckOpt(before2, after2, patterns));

  436. }

  437. 

  438. TEST_F(TestOptLib, test_incorporate_getitem_through_switch) {

  439.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_incorporate_getitem_through_switch", "before");

  440.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_incorporate_getitem_through_switch", "after");

  441. 

  442.   auto patterns = std::vector<SubstitutionPtr>({irpass.incorporate_getitem_set_});

  443.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  444. }

  445. 

  446. TEST_F(TestOptLib, test_incorporate_call) {

  447.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_incorporate_call", "before");

  448.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_incorporate_call", "after");

  449. 

  450.   auto patterns = std::vector<SubstitutionPtr>({irpass.incorporate_call_});

  451.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  452. }

  453. 

  454. TEST_F(TestOptLib, test_incorporate_call_through_switch) {

  455.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_incorporate_call_through_switch", "before");

  456.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_incorporate_call_through_switch", "after");

  457.   auto patterns = std::vector<SubstitutionPtr>({

  458.     irpass.incorporate_call_switch_,

  459.     irpass.incorporate_call_,

  460.     irpass.arithmetic_simplify_,

  461.   });

  462.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  463. }

  464. 

  465. TEST_F(TestOptLib, test_float_tuple_getitem_through_switch) {

  466.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_float_tuple_getitem_through_switch", "before");

  467.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_float_tuple_getitem_through_switch", "after");

  468. 

  469.   auto patterns = std::vector<SubstitutionPtr>({irpass.float_tuple_getitem_switch_});

  470.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  471. }

  472. 

  473. TEST_F(TestOptLib, test_merge_addn) {

  474.   FuncGraphPtr before = getPyFun.CallAndParseRet("test_merge_addn", "before");

  475.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_merge_addn", "after");

  476. 

  477.   auto patterns = std::vector<SubstitutionPtr>({irpass.merge_addn_});

  478.   ASSERT_TRUE(CheckOpt(before, after, patterns));

  479. }

  480. 

  481. TEST_F(TestOptLib, test_filter_addn_zero) {

  482.   FuncGraphPtr before1 = getPyFun.CallAndParseRet("test_addn_zero", "before_1");

  483.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_addn_zero", "after");

  484.   FuncGraphPtr before2 = getPyFun.CallAndParseRet("test_addn_zero", "before_2");

  485.   FuncGraphPtr before3 = getPyFun.CallAndParseRet("test_addn_zero", "before_3");

  486.   FuncGraphPtr before4 = getPyFun.CallAndParseRet("test_addn_zero", "before_4");

  487.   auto patterns = std::vector<SubstitutionPtr>({irpass.addn_zero_filter_});

  488.   ASSERT_TRUE(CheckOpt(before1, after, patterns));

  489.   ASSERT_TRUE(CheckOpt(before2, after, patterns));

  490.   ASSERT_TRUE(CheckOpt(before3, after, patterns));

  491.   ASSERT_TRUE(CheckOpt(before4, before4, patterns));

  492. }

  493. 

  494. TEST_F(TestOptLib, test_minmax_grad) {

  495.   FuncGraphPtr before11 = getPyFun.CallAndParseRet("test_minmax_grad", "before_11");

  496.   FuncGraphPtr before12 = getPyFun.CallAndParseRet("test_minmax_grad", "before_12");

  497.   FuncGraphPtr before2 = getPyFun.CallAndParseRet("test_minmax_grad", "before_2");

  498.   FuncGraphPtr before31 = getPyFun.CallAndParseRet("test_minmax_grad", "before_31");

  499.   FuncGraphPtr before32 = getPyFun.CallAndParseRet("test_minmax_grad", "before_32");

  500.   FuncGraphPtr before4 = getPyFun.CallAndParseRet("test_minmax_grad", "before_4");

  501.   auto patterns = std::vector<SubstitutionPtr>({irpass.minmaximum_grad_});

  502.   ASSERT_TRUE(CheckOpt(before11, before11, patterns));

  503.   ASSERT_TRUE(CheckOpt(before12, before12, patterns));

  504.   ASSERT_TRUE(CheckOpt(before2, before2, patterns));

  505.   ASSERT_TRUE(CheckOpt(before31, before31, patterns));

  506.   ASSERT_TRUE(CheckOpt(before32, before32, patterns));

  507.   ASSERT_TRUE(CheckOpt(before4, before4, patterns));

  508. }

  509. 

  510. TEST_F(TestOptLib, test_reducesum_one) {

  511.   FuncGraphPtr before1 = getPyFun.CallAndParseRet("test_reducesum_one", "before_1");

  512.   FuncGraphPtr before2 = getPyFun.CallAndParseRet("test_reducesum_one", "before_2");

  513.   FuncGraphPtr before3 = getPyFun.CallAndParseRet("test_reducesum_one", "before_3");

  514.   FuncGraphPtr before4 = getPyFun.CallAndParseRet("test_reducesum_one", "before_4");

  515.   FuncGraphPtr after1 = getPyFun.CallAndParseRet("test_reducesum_one", "after_1");

  516.   FuncGraphPtr after2 = getPyFun.CallAndParseRet("test_reducesum_one", "after_2");

  517.   FuncGraphPtr after3 = getPyFun.CallAndParseRet("test_reducesum_one", "after_3");

  518.   auto patterns = std::vector<SubstitutionPtr>({irpass.reduce_eliminate_});

  519. 

  520.   std::vector<int> shp = {3, 2, 2, 1};

  521.   tensor::TensorPtr x_tensor = std::make_shared<tensor::Tensor>(kFloat32->type_id(), shp);

  522.   auto x_abstract = x_tensor->ToAbstract();

  523. 

  524.   std::vector<int> shp2 = {3, 2, 1, 1};

  525.   tensor::TensorPtr x_tensor2 = std::make_shared<tensor::Tensor>(kFloat32->type_id(), shp2);

  526.   auto x_abstract2 = x_tensor2->ToAbstract();

  527. 

  528.   auto inputs = before1->output()->cast<CNodePtr>()->inputs();

  529.   if (inputs.size() > 1) {

  530.     auto x_node = inputs[1];

  531.     x_node->set_abstract(x_abstract);

  532.   }

  533.   ASSERT_TRUE(CheckOpt(before1, after1, patterns));

  534. 

  535.   auto inputs2 = before2->output()->cast<CNodePtr>()->inputs();

  536.   if (inputs2.size() > 1) {

  537.     auto x_node2 = inputs2[1];

  538.     x_node2->set_abstract(x_abstract2);

  539.   }

  540.   ASSERT_TRUE(CheckOpt(before2, after1, patterns));

  541. 

  542.   auto inputs3 = before2->output()->cast<CNodePtr>()->inputs();

  543.   if (inputs3.size() > 1) {

  544.     auto x_node3 = inputs3[1];

  545.     x_node3->set_abstract(x_abstract);

  546.   }

  547.   ASSERT_TRUE(CheckOpt(before2, before2, patterns));

  548. 

  549.   auto inputs4 = before3->output()->cast<CNodePtr>()->inputs();

  550.   if (inputs4.size() > 1) {

  551.     auto x_node4 = inputs4[1];

  552.     x_node4->set_abstract(x_abstract);

  553.   }

  554.   ASSERT_TRUE(CheckOpt(before3, after2, patterns));

  555. 

  556.   auto inputs5 = before4->output()->cast<CNodePtr>()->inputs();

  557.   if (inputs5.size() > 1) {

  558.     auto x_node5 = inputs5[1];

  559.     x_node5->set_abstract(x_abstract2);

  560.   }

  561.   ASSERT_TRUE(CheckOpt(before4, after3, patterns));

  562. }

  563. 

  564. TEST_F(TestOptLib, test_print_tuple_wrapper) {

  565.   FuncGraphPtr before1 = getPyFun.CallAndParseRet("test_print_tuple_wrapper", "before1");

  566.   FuncGraphPtr before2 = getPyFun.CallAndParseRet("test_print_tuple_wrapper", "before2");

  567.   FuncGraphPtr before3 = getPyFun.CallAndParseRet("test_print_tuple_wrapper", "before3");

  568.   FuncGraphPtr after1 = getPyFun.CallAndParseRet("test_print_tuple_wrapper", "after1");

  569.   FuncGraphPtr after2 = getPyFun.CallAndParseRet("test_print_tuple_wrapper", "after2");

  570.   auto patterns = std::vector<SubstitutionPtr>({irpass.print_tuple_wrapper_});

  571.   ASSERT_TRUE(CheckOpt(before1, after1, patterns));

  572.   ASSERT_TRUE(CheckOpt(before2, after2, patterns));

  573.   ASSERT_TRUE(CheckOpt(before3, before3, patterns));

  574. }

  575. 

  576. TEST_F(TestOptLib, test_constant_duplicate_mul) {

  577.   FuncGraphPtr beforell = getPyFun.CallAndParseRet("test_constant_duplicate_mul", "beforell");

  578.   FuncGraphPtr beforelr = getPyFun.CallAndParseRet("test_constant_duplicate_mul", "beforelr");

  579.   FuncGraphPtr beforerl = getPyFun.CallAndParseRet("test_constant_duplicate_mul", "beforerl");

  580.   FuncGraphPtr beforerr = getPyFun.CallAndParseRet("test_constant_duplicate_mul", "beforerr");

  581.   FuncGraphPtr after = getPyFun.CallAndParseRet("test_constant_duplicate_mul", "after");

  582.   auto patterns = std::vector<SubstitutionPtr>({irpass.arithmetic_simplify_});

  583.   ASSERT_TRUE(CheckOpt(beforell, after, patterns));

  584.   ASSERT_TRUE(CheckOpt(beforelr, after, patterns));

  585.   ASSERT_TRUE(CheckOpt(beforerl, after, patterns));

  586.   ASSERT_TRUE(CheckOpt(beforerr, after, patterns));

  587. }

  588. 

  589. TEST_F(TestOptLib, test_adjust_allreduce_mul_add) {

  590.   FuncGraphPtr beforell = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "beforell");

  591.   FuncGraphPtr beforelr = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "beforelr");

  592.   FuncGraphPtr beforerl = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "beforerl");

  593.   FuncGraphPtr beforerr = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "beforerr");

  594.   FuncGraphPtr after1 = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "after1");

  595.   FuncGraphPtr before2r = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "before2r");

  596.   FuncGraphPtr before2l = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "before2l");

  597.   FuncGraphPtr after2 = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "after2");

  598.   auto patterns = std::vector<SubstitutionPtr>({irpass.adjust_all_reduce_mul_add_});

  599.   ASSERT_TRUE(CheckOpt(beforell, after1, patterns));

  600.   ASSERT_TRUE(CheckOpt(beforelr, after1, patterns));

  601.   ASSERT_TRUE(CheckOpt(beforerl, after1, patterns));

  602.   ASSERT_TRUE(CheckOpt(beforerr, after1, patterns));

  603.   ASSERT_TRUE(CheckOpt(before2l, after2, patterns));

  604.   ASSERT_TRUE(CheckOpt(before2r, after2, patterns));

  605. }

  606. 

  607. TEST_F(TestOptLib, test_indexed_slices) {

  608.   FuncGraphPtr before_get_indices = getPyFun.CallAndParseRet("test_indexed_slices", "before_get_indices");

  609.   FuncGraphPtr after_get_indices = getPyFun.CallAndParseRet("test_indexed_slices", "after_get_indices");

  610.   FuncGraphPtr before_get_values = getPyFun.CallAndParseRet("test_indexed_slices", "before_get_values");

  611.   FuncGraphPtr after_get_values = getPyFun.CallAndParseRet("test_indexed_slices", "after_get_values");

  612.   FuncGraphPtr before_get_dense_shape = getPyFun.CallAndParseRet("test_indexed_slices", "before_get_dense_shape");

  613.   FuncGraphPtr after_get_dense_shape = getPyFun.CallAndParseRet("test_indexed_slices", "after_get_dense_shape");

  614.   auto patterns = std::vector<SubstitutionPtr>({irpass.indexed_slices_eliminate_});

  615.   ASSERT_TRUE(CheckOpt(before_get_indices, after_get_indices, patterns));

  616.   ASSERT_TRUE(CheckOpt(before_get_values, after_get_values, patterns));

  617.   ASSERT_TRUE(CheckOpt(before_get_dense_shape, after_get_dense_shape, patterns));

  618. }

  619. 

  620. TEST_F(TestOptLib, test_sparse_tensor) {

  621.   FuncGraphPtr before_get_indices = getPyFun.CallAndParseRet("test_sparse_tensor", "before_get_indices");

  622.   FuncGraphPtr after_get_indices = getPyFun.CallAndParseRet("test_sparse_tensor", "after_get_indices");

  623.   FuncGraphPtr before_get_values = getPyFun.CallAndParseRet("test_sparse_tensor", "before_get_values");

  624.   FuncGraphPtr after_get_values = getPyFun.CallAndParseRet("test_sparse_tensor", "after_get_values");

  625.   FuncGraphPtr before_get_dense_shape = getPyFun.CallAndParseRet("test_sparse_tensor", "before_get_dense_shape");

  626.   FuncGraphPtr after_get_dense_shape = getPyFun.CallAndParseRet("test_sparse_tensor", "after_get_dense_shape");

  627.   auto patterns = std::vector<SubstitutionPtr>({irpass.sparse_tensor_eliminate_});

  628.   ASSERT_TRUE(CheckOpt(before_get_indices, after_get_indices, patterns));

  629.   ASSERT_TRUE(CheckOpt(before_get_values, after_get_values, patterns));

  630.   ASSERT_TRUE(CheckOpt(before_get_dense_shape, after_get_dense_shape, patterns));

  631. }

  632. }  // namespace opt

  633. }  // namespace mindspore