hummingbird
/
graphengine
Not watched
2
0
Fork 0
Code
Releases 13 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
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: dfd18d3465
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dfd18d3465'
${ noResults }
graphengine/tests/ut/ge/graph/passes/parallel_group_pass_unittes...

305 lines
14 kB
Raw Blame History 

  1. /**

  2.  * Copyright 2019-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 <gtest/gtest.h>

  18. #include <cstdint>

  19. #include <string>

  20. 

  21. #define private public

  22. 

  23. #include "common/ge_inner_error_codes.h"

  24. #include "inc/pass_manager.h"

  25. #include "utils/graph_utils.h"

  26. #include "graph/passes/parallel_group_pass.h"

  27. #undef private

  28. 

  29. namespace ge {

  30. namespace {

  31. 

  32. class UtestGraphPassesParallelGgroupPass : public testing::Test {

  33.  protected:

  34.   UtestGraphPassesParallelGgroupPass() {

  35.     graph_ = std::make_shared<ComputeGraph>("test");

  36.     sub_graph_ = std::make_shared<ComputeGraph>("test_subgraph");

  37.     vector<int64_t> shape_vec{1, 1, 1, 1};

  38.     GeShape shape = GeShape(shape_vec);

  39.     default_tensor_desc_ = std::make_shared<GeTensorDesc>();

  40.     default_tensor_desc_->SetShape(shape);

  41.     default_tensor_desc_->SetFormat(FORMAT_NCHW);

  42.     default_tensor_desc_->SetDataType(DT_FLOAT);

  43.   }

  44. 

  45.   NodePtr NewNode(const std::string &name, const std::string &type,

  46.                   int input_cnt, int output_cnt, bool isSubgraph = false) {

  47.     OpDescPtr op_desc = std::make_shared<OpDesc>(name, type);

  48.     for (int i = 0; i < input_cnt; ++i) {

  49.       op_desc->AddInputDesc(default_tensor_desc_->Clone());

  50.     }

  51. 

  52.     for (int i = 0; i < output_cnt; ++i) {

  53.       op_desc->AddOutputDesc(default_tensor_desc_->Clone());

  54.     }

  55.     NodePtr node = nullptr;

  56.     if (isSubgraph) {

  57.       node = sub_graph_->AddNode(op_desc);

  58.       (void)node->SetOwnerComputeGraph(sub_graph_);

  59.     } else {

  60.       node = graph_->AddNode(op_desc);

  61.       (void)node->SetOwnerComputeGraph(graph_);

  62.     }

  63. 

  64.     return node;

  65.   }

  66. 

  67.   void BuildDefaultGraph() {

  68.     ///          input

  69.     ///            \

  70.     ///           sqrt pred

  71.     ///              \  /

  72.     ///              cast

  73.     ///              /  \

  74.     ///       switch_t  switch_f

  75.     ///              |  |

  76.     ///              F  T

  77.     ///              |  |

  78.     ///              Merge

  79.     ///               |

  80.     ///              relu

  81.     ///               |

  82.     ///              sqrt1

  83.     input_node_ = NewNode("input", RELU, 0, 1);

  84.     sqrt_node_ = NewNode("sqrt", SQRT, 1, 1);

  85.     pred_node_ = NewNode("pred", GREATER, 2, 1);

  86.     cast_node_ = NewNode("cast", CAST, 2, 2);

  87.     AttrUtils::SetStr(input_node_->GetOpDesc(), ATTR_NAME_PARALLEL_GROUP, "1");

  88. 

  89.     switch_node_t = NewNode("switch_t", STREAMSWITCH, 1, 1);

  90.     AttrUtils::SetBool(switch_node_t->GetOpDesc(), ATTR_NAME_SWITCH_TRUE_BRANCH_FLAG, true);

  91.     switch_node_f = NewNode("switch_f", STREAMSWITCH, 1, 1);

  92.     AttrUtils::SetBool(switch_node_f->GetOpDesc(), ATTR_NAME_SWITCH_TRUE_BRANCH_FLAG, false);

  93.     output_false_node_ = NewNode("false_output", RELU, 1, 1);

  94.     AttrUtils::SetStr(output_false_node_->GetOpDesc(), ATTR_NAME_PARALLEL_GROUP, "1");

  95.     output_true_node_ = NewNode("true_output", RELU, 1, 1);

  96.     AttrUtils::SetStr(output_true_node_->GetOpDesc(), ATTR_NAME_PARALLEL_GROUP, "1");

  97.     merge_node_ = NewNode("merge", STREAMMERGE, 2, 1);

  98.     relu_node_ = NewNode("relu", RELU, 1, 1);

  99.     sqrt_node1_ = NewNode("sqrt1", SQRT, 1, 1);

  100.     AttrUtils::SetStr(sqrt_node1_->GetOpDesc(), ATTR_NAME_PARALLEL_GROUP, "1");

  101. 

  102.     GraphUtils::AddEdge(input_node_->GetOutDataAnchor(0), sqrt_node_->GetInDataAnchor(0));

  103.     GraphUtils::AddEdge(pred_node_->GetOutDataAnchor(0), cast_node_->GetInDataAnchor(0));

  104.     GraphUtils::AddEdge(sqrt_node_->GetOutDataAnchor(0), cast_node_->GetInDataAnchor(1));

  105.     GraphUtils::AddEdge(cast_node_->GetOutDataAnchor(0), switch_node_t->GetInDataAnchor(0));

  106.     GraphUtils::AddEdge(cast_node_->GetOutDataAnchor(1), switch_node_f->GetInDataAnchor(0));

  107.     GraphUtils::AddEdge(switch_node_f->GetOutDataAnchor(0), output_false_node_->GetInDataAnchor(0));

  108.     GraphUtils::AddEdge(switch_node_t->GetOutDataAnchor(0), output_true_node_->GetInDataAnchor(0));

  109. 

  110.     GraphUtils::AddEdge(output_false_node_->GetOutDataAnchor(0), merge_node_->GetInDataAnchor(0));

  111.     GraphUtils::AddEdge(output_true_node_->GetOutDataAnchor(0), merge_node_->GetInDataAnchor(1));

  112.     GraphUtils::AddEdge(merge_node_->GetOutDataAnchor(0), relu_node_->GetInDataAnchor(0));

  113.     GraphUtils::AddEdge(relu_node_->GetOutDataAnchor(0), sqrt_node1_->GetInDataAnchor(0));

  114. 

  115.     output_false_node_->GetOpDesc()->SetIsInputConst({false});

  116.     output_true_node_->GetOpDesc()->SetIsInputConst({false});

  117.   }

  118. 

  119.   void BuildDefaultGraph1() {

  120.     ///          input

  121.     ///            \

  122.     ///           sqrt  pred

  123.     ///              \  /

  124.     ///             Switch

  125.     ///              |  |

  126.     ///          ----F  T----

  127.     ///          \   | /     \

  128.     ///           \  Merge1 Merge2

  129.     ///            \_________|

  130.     input_node_ = NewNode("input", RELU, 0, 1);

  131.     AttrUtils::SetStr(input_node_->GetOpDesc(), ATTR_NAME_PARALLEL_GROUP, "1");

  132.     pred_node_ = NewNode("pred", GREATER, 2, 1);

  133.     sqrt_node_ = NewNode("sqrt", SQRT, 1, 1);

  134.     cast_node_ = NewNode("cast", CAST, 2, 2);

  135. 

  136.     switch_node_t = NewNode("switch_t", STREAMSWITCH, 1, 1);

  137.     AttrUtils::SetBool(switch_node_t->GetOpDesc(), ATTR_NAME_SWITCH_TRUE_BRANCH_FLAG, true);

  138.     switch_node_f = NewNode("switch_f", STREAMSWITCH, 1, 1);

  139.     AttrUtils::SetBool(switch_node_f->GetOpDesc(), ATTR_NAME_SWITCH_TRUE_BRANCH_FLAG, false);

  140.     output_false_node_ = NewNode("false_output", RELU, 1, 2);

  141.     AttrUtils::SetStr(output_false_node_->GetOpDesc(), ATTR_NAME_PARALLEL_GROUP, "1");

  142.     output_true_node_ = NewNode("true_output", RELU, 1, 2);

  143.     AttrUtils::SetStr(output_true_node_->GetOpDesc(), ATTR_NAME_PARALLEL_GROUP, "1");

  144.     merge_node_ = NewNode("merge", STREAMMERGE, 2, 1);

  145.     merge_node1_ = NewNode("merge1", STREAMMERGE, 2, 1);

  146. 

  147.     GraphUtils::AddEdge(input_node_->GetOutDataAnchor(0), sqrt_node_->GetInDataAnchor(0));

  148.     GraphUtils::AddEdge(pred_node_->GetOutDataAnchor(0), cast_node_->GetInDataAnchor(0));

  149.     GraphUtils::AddEdge(sqrt_node_->GetOutDataAnchor(0), cast_node_->GetInDataAnchor(1));

  150.     GraphUtils::AddEdge(cast_node_->GetOutDataAnchor(0), switch_node_t->GetInDataAnchor(0));

  151.     GraphUtils::AddEdge(cast_node_->GetOutDataAnchor(1), switch_node_f->GetInDataAnchor(0));

  152.     GraphUtils::AddEdge(switch_node_f->GetOutDataAnchor(0), output_false_node_->GetInDataAnchor(0));

  153.     GraphUtils::AddEdge(switch_node_t->GetOutDataAnchor(0), output_true_node_->GetInDataAnchor(0));

  154. 

  155.     GraphUtils::AddEdge(output_false_node_->GetOutDataAnchor(0), merge_node_->GetInDataAnchor(0));

  156.     GraphUtils::AddEdge(output_true_node_->GetOutDataAnchor(0), merge_node_->GetInDataAnchor(1));

  157.     GraphUtils::AddEdge(output_false_node_->GetOutDataAnchor(1), merge_node1_->GetInDataAnchor(0));

  158.     GraphUtils::AddEdge(output_true_node_->GetOutDataAnchor(1), merge_node1_->GetInDataAnchor(1));

  159. 

  160.     output_false_node_->GetOpDesc()->SetIsInputConst({false});

  161.     output_true_node_->GetOpDesc()->SetIsInputConst({false});

  162.   }

  163. 

  164. 

  165.   void BuildDefaultGraph2() {

  166.     ///          input      input1

  167.     ///            \           \

  168.     ///           sqrt  pred sqrt1  pred1

  169.     ///              \  /       \  /

  170.     ///             Switch     Switch1

  171.     ///              |  |  _______|

  172.     ///              |  | /

  173.     ///          ____F  T____

  174.     ///          \   | /     \

  175.     ///           \  Merge1 Merge2

  176.     ///            \__________|

  177.     input_node_ = NewNode("input", RELU, 0, 2);

  178.     input_node1_ = NewNode("input_1", RELU, 0, 2);

  179.     sqrt_node_ = NewNode("sqrt", SQRT, 1, 1);

  180.     pred_node_ = NewNode("pred", GREATER, 2, 1);

  181.     sqrt_node1_ = NewNode("sqrt_1", SQRT, 1, 1);

  182.     pred_node1_ = NewNode("pred_1", LESS, 2, 1);

  183.     cast_node_ = NewNode("cast", CAST, 2, 2);

  184.     cast_node1_ = NewNode("cast_1", CAST, 2, 2);

  185.     AttrUtils::SetStr(input_node_->GetOpDesc(), ATTR_NAME_PARALLEL_GROUP, "1");

  186.     AttrUtils::SetStr(input_node1_->GetOpDesc(), ATTR_NAME_PARALLEL_GROUP, "2");

  187. 

  188.     switch_node_t = NewNode("switch_t", STREAMSWITCH, 1, 1);

  189.     AttrUtils::SetBool(switch_node_t->GetOpDesc(), ATTR_NAME_SWITCH_TRUE_BRANCH_FLAG, true);

  190.     switch_node_f = NewNode("switch_f", STREAMSWITCH, 1, 1);

  191.     AttrUtils::SetBool(switch_node_f->GetOpDesc(), ATTR_NAME_SWITCH_TRUE_BRANCH_FLAG, false);

  192.     switch_node1_t = NewNode("switch1_t", STREAMSWITCH, 1, 1);

  193.     AttrUtils::SetBool(switch_node1_t->GetOpDesc(), ATTR_NAME_SWITCH_TRUE_BRANCH_FLAG, true);

  194.     switch_node1_f = NewNode("switch1_f", STREAMSWITCH, 1, 1);

  195.     AttrUtils::SetBool(switch_node1_f->GetOpDesc(), ATTR_NAME_SWITCH_TRUE_BRANCH_FLAG, false);

  196.     output_false_node_ = NewNode("false_output", RELU, 2, 2);

  197.     AttrUtils::SetStr(output_false_node_->GetOpDesc(), ATTR_NAME_PARALLEL_GROUP, "1");

  198.     output_true_node_ = NewNode("true_output", RELU, 2, 2);

  199.     AttrUtils::SetStr(output_true_node_->GetOpDesc(), ATTR_NAME_PARALLEL_GROUP, "2");

  200.     merge_node_ = NewNode("merge", STREAMMERGE, 2, 1);

  201.     merge_node1_ = NewNode("merge1", STREAMMERGE, 2, 1);

  202. 

  203.     GraphUtils::AddEdge(input_node_->GetOutDataAnchor(0), sqrt_node_->GetInDataAnchor(0));

  204.     GraphUtils::AddEdge(pred_node_->GetOutDataAnchor(0), cast_node_->GetInDataAnchor(0));

  205.     GraphUtils::AddEdge(sqrt_node_->GetOutDataAnchor(0), cast_node_->GetInDataAnchor(1));

  206.     GraphUtils::AddEdge(cast_node_->GetOutDataAnchor(0), switch_node_t->GetInDataAnchor(0));

  207.     GraphUtils::AddEdge(cast_node_->GetOutDataAnchor(1), switch_node_f->GetInDataAnchor(0));

  208.     GraphUtils::AddEdge(switch_node_f->GetOutDataAnchor(0), output_false_node_->GetInDataAnchor(0));

  209.     GraphUtils::AddEdge(switch_node_t->GetOutDataAnchor(0), output_true_node_->GetInDataAnchor(0));

  210. 

  211.     GraphUtils::AddEdge(input_node1_->GetOutDataAnchor(0), sqrt_node1_->GetInDataAnchor(0));

  212.     GraphUtils::AddEdge(pred_node1_->GetOutDataAnchor(0), cast_node1_->GetInDataAnchor(0));

  213.     GraphUtils::AddEdge(sqrt_node1_->GetOutDataAnchor(0), cast_node1_->GetInDataAnchor(1));

  214.     GraphUtils::AddEdge(cast_node1_->GetOutDataAnchor(0), switch_node1_t->GetInDataAnchor(0));

  215.     GraphUtils::AddEdge(cast_node1_->GetOutDataAnchor(1), switch_node1_f->GetInDataAnchor(0));

  216.     GraphUtils::AddEdge(switch_node1_f->GetOutDataAnchor(0), output_false_node_->GetInDataAnchor(1));

  217.     GraphUtils::AddEdge(switch_node1_t->GetOutDataAnchor(0), output_true_node_->GetInDataAnchor(1));

  218. 

  219.     GraphUtils::AddEdge(output_false_node_->GetOutDataAnchor(0), merge_node_->GetInDataAnchor(0));

  220.     GraphUtils::AddEdge(output_true_node_->GetOutDataAnchor(0), merge_node_->GetInDataAnchor(1));

  221.     GraphUtils::AddEdge(output_false_node_->GetOutDataAnchor(1), merge_node1_->GetInDataAnchor(0));

  222.     GraphUtils::AddEdge(output_true_node_->GetOutDataAnchor(1), merge_node1_->GetInDataAnchor(1));

  223. 

  224.     output_false_node_->GetOpDesc()->SetIsInputConst({false});

  225.     output_true_node_->GetOpDesc()->SetIsInputConst({false});

  226.   }

  227. 

  228.   ComputeGraphPtr graph_;

  229.   ComputeGraphPtr sub_graph_;

  230.   GeTensorDescPtr default_tensor_desc_;

  231.   ParallelGroupPass pass_;

  232.   NodePtr pred_node_;

  233.   NodePtr pred_node1_;

  234.   NodePtr cast_node_;

  235.   NodePtr cast_node1_;

  236.   NodePtr sqrt_node_;

  237.   NodePtr sqrt_node1_;

  238.   NodePtr input_node_;

  239.   NodePtr input_node1_;

  240.   NodePtr switch_node_t;

  241.   NodePtr switch_node_f;

  242.   NodePtr switch_node1_t;

  243.   NodePtr switch_node1_f;

  244.   NodePtr output_false_node_;

  245.   NodePtr output_true_node_;

  246.   NodePtr merge_node_;

  247.   NodePtr merge_node1_;

  248.   NodePtr relu_node_;

  249. };

  250. 

  251. TEST_F(UtestGraphPassesParallelGgroupPass, null_graph) {

  252.   ComputeGraphPtr graph = nullptr;

  253.   auto ret = pass_.Run(graph);

  254.   EXPECT_EQ(ret, PARAM_INVALID);

  255. }

  256. 

  257. TEST_F(UtestGraphPassesParallelGgroupPass, normal_graph) {

  258.   BuildDefaultGraph();

  259.   auto ret = pass_.Run(graph_);

  260.   EXPECT_EQ(ret, GRAPH_SUCCESS);

  261.   EXPECT_EQ(true, input_node_->GetOutControlAnchor()->IsLinkedWith(cast_node_->GetInControlAnchor()));

  262.   EXPECT_EQ(true, merge_node_->GetOutControlAnchor()->IsLinkedWith(sqrt_node1_->GetInControlAnchor()));

  263.   EXPECT_EQ(false, output_false_node_->GetOutControlAnchor()->IsLinkedWith(output_true_node_->GetInControlAnchor()));

  264. }

  265. 

  266. TEST_F(UtestGraphPassesParallelGgroupPass, normal_graph1) {

  267.   BuildDefaultGraph1();

  268.   auto ret = pass_.Run(graph_);

  269.   EXPECT_EQ(ret, GRAPH_SUCCESS);

  270.   EXPECT_EQ(true, input_node_->GetOutControlAnchor()->IsLinkedWith(cast_node_->GetInControlAnchor()));

  271. }

  272. 

  273. TEST_F(UtestGraphPassesParallelGgroupPass, normal_graph2) {

  274.   BuildDefaultGraph2();

  275.   auto ret = pass_.Run(graph_);

  276.   EXPECT_EQ(ret, GRAPH_SUCCESS);

  277.   EXPECT_EQ(true, input_node_->GetOutControlAnchor()->IsLinkedWith(cast_node_->GetInControlAnchor()));

  278.   EXPECT_EQ(true, input_node1_->GetOutControlAnchor()->IsLinkedWith(cast_node1_->GetInControlAnchor()));

  279. }

  280. 

  281. TEST_F(UtestGraphPassesParallelGgroupPass, normal_subgraph) {

  282.   BuildDefaultGraph1();

  283.   NodePtr input_node1 = NewNode("input1", RELU, 0, 1, true);

  284.   NodePtr input_node2 = NewNode("input2", RELU, 0, 1, true);

  285.   NodePtr add = NewNode("add", ADD, 2, 1, true);

  286.   AttrUtils::SetStr(input_node1->GetOpDesc(), ATTR_NAME_PARALLEL_GROUP, "1");

  287.   AttrUtils::SetStr(input_node2->GetOpDesc(), ATTR_NAME_PARALLEL_GROUP, "1");

  288. 

  289.   sub_graph_->SetParentNode(input_node_);

  290.   sub_graph_->SetParentGraph(graph_);

  291.   auto ret = graph_->AddSubgraph(sub_graph_->GetName(), sub_graph_);

  292.   EXPECT_EQ(ret, GRAPH_SUCCESS);

  293.   ret = input_node_->GetOpDesc()->AddSubgraphName(sub_graph_->GetName());

  294.   EXPECT_EQ(ret, GRAPH_SUCCESS);

  295.   ret = input_node_->GetOpDesc()->SetSubgraphInstanceName(0, sub_graph_->GetName());

  296.   EXPECT_EQ(ret, GRAPH_SUCCESS);

  297.   ret = pass_.Run(sub_graph_);

  298.   EXPECT_EQ(ret, GRAPH_SUCCESS);

  299.   ret = pass_.Run(graph_);

  300.   EXPECT_EQ(ret, GRAPH_SUCCESS);

  301. }

  302. 

  303. }  // namespace

  304. }  // namespace ge