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: ff80316dab
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ff80316dab'
${ noResults }
graphengine/tests/ut/ge/graph/passes/switch_op_pass_unittest.cc

459 lines
21 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. 

  19. #include "omg/omg_inner_types.h"

  20. #define protected public

  21. #define private public

  22. #include "graph/passes/switch_op_pass.h"

  23. 

  24. #include "common/debug/log.h"

  25. #include "common/debug/memory_dumper.h"

  26. #include "common/op/attr_value_util.h"

  27. #include "common/types.h"

  28. #include "graph/debug/ge_attr_define.h"

  29. #include "graph/graph.h"

  30. #include "graph/passes/control_op_attr_pass.h"

  31. #include "inc/pass_manager.h"

  32. #undef protected

  33. #undef private

  34. 

  35. using namespace domi;

  36. using namespace testing;

  37. using namespace ge;

  38. 

  39. class UTEST_graph_passes_switch_op_pass : public testing::Test {

  40.  protected:

  41.   void SetUp() {}

  42. 

  43.   void TearDown() {}

  44. 

  45.  public:

  46.   void make_graph(ComputeGraphPtr graph, bool match = true) {

  47.     GeTensorDesc boolTensorDesc(GeShape(), ge::FORMAT_NCHW, ge::DT_BOOL);

  48.     GeTensorDesc intTensorDesc(GeShape(), ge::FORMAT_NCHW, ge::DT_INT32);

  49.     GeTensorDesc scalarTensorDesc(GeShape(), ge::FORMAT_NCHW, ge::DT_FLOAT);

  50. 

  51.     auto xOpDef = std::make_shared<OpDesc>("x", VARIABLEV2);

  52.     xOpDef->AddOutputDesc(scalarTensorDesc);

  53.     auto xNode = graph->AddNode(xOpDef);

  54. 

  55.     auto yOpDef = std::make_shared<OpDesc>("y", VARIABLEV2);

  56.     yOpDef->AddOutputDesc(scalarTensorDesc);

  57.     auto yNode = graph->AddNode(yOpDef);

  58. 

  59.     auto zOpDef = std::make_shared<OpDesc>("z", VARIABLEV2);

  60.     zOpDef->AddOutputDesc(scalarTensorDesc);

  61.     auto zNode = graph->AddNode(zOpDef);

  62. 

  63.     auto condOpDef = std::make_shared<OpDesc>("Less", "Less");

  64.     condOpDef->AddInputDesc(scalarTensorDesc);

  65.     condOpDef->AddInputDesc(scalarTensorDesc);

  66.     condOpDef->AddOutputDesc(boolTensorDesc);

  67.     auto condNode = graph->AddNode(condOpDef);

  68. 

  69.     auto switchOpDef1 = std::make_shared<OpDesc>("Add/Switch", SWITCH);

  70.     switchOpDef1->AddInputDesc(scalarTensorDesc);

  71.     switchOpDef1->AddInputDesc(boolTensorDesc);

  72.     switchOpDef1->AddOutputDesc(scalarTensorDesc);

  73.     switchOpDef1->AddOutputDesc(scalarTensorDesc);

  74.     auto switchNode1 = graph->AddNode(switchOpDef1);

  75. 

  76.     auto switchOpDef2 = std::make_shared<OpDesc>("Add/Switch_1", SWITCH);

  77.     switchOpDef2->AddInputDesc(scalarTensorDesc);

  78.     switchOpDef2->AddInputDesc(boolTensorDesc);

  79.     switchOpDef2->AddOutputDesc(scalarTensorDesc);

  80.     switchOpDef2->AddOutputDesc(scalarTensorDesc);

  81.     auto switchNode2 = graph->AddNode(switchOpDef2);

  82. 

  83.     auto switchOpDef3 = std::make_shared<OpDesc>("Square/Switch", SWITCH);

  84.     switchOpDef3->AddInputDesc(scalarTensorDesc);

  85.     switchOpDef3->AddInputDesc(boolTensorDesc);

  86.     switchOpDef3->AddOutputDesc(scalarTensorDesc);

  87.     switchOpDef3->AddOutputDesc(scalarTensorDesc);

  88.     auto switchNode3 = graph->AddNode(switchOpDef3);

  89. 

  90.     auto addOpDef = std::make_shared<OpDesc>("Add", "ADD");

  91.     addOpDef->AddInputDesc(scalarTensorDesc);

  92.     addOpDef->AddInputDesc(scalarTensorDesc);

  93.     addOpDef->AddOutputDesc(scalarTensorDesc);

  94.     auto addNode = graph->AddNode(addOpDef);

  95. 

  96.     auto mergeOpDef = std::make_shared<OpDesc>("Merge", "Merge");

  97.     mergeOpDef->AddInputDesc(scalarTensorDesc);

  98.     mergeOpDef->AddInputDesc(scalarTensorDesc);

  99.     mergeOpDef->AddOutputDesc(scalarTensorDesc);

  100.     mergeOpDef->AddOutputDesc(intTensorDesc);

  101.     auto mergeNode = graph->AddNode(mergeOpDef);

  102. 

  103.     auto outputOpDef = std::make_shared<OpDesc>("NetOutput", "NetOutput");

  104.     outputOpDef->AddInputDesc(scalarTensorDesc);

  105.     outputOpDef->AddOutputDesc(scalarTensorDesc);

  106.     auto outputNode = graph->AddNode(outputOpDef);

  107. 

  108.     (void)GraphUtils::AddEdge(xNode->GetOutDataAnchor(0), condNode->GetInDataAnchor(0));

  109.     (void)GraphUtils::AddEdge(yNode->GetOutDataAnchor(0), condNode->GetInDataAnchor(1));

  110. 

  111.     (void)GraphUtils::AddEdge(xNode->GetOutDataAnchor(0), switchNode1->GetInDataAnchor(0));

  112.     (void)GraphUtils::AddEdge(condNode->GetOutDataAnchor(0), switchNode1->GetInDataAnchor(1));

  113. 

  114.     (void)GraphUtils::AddEdge(yNode->GetOutDataAnchor(0), switchNode2->GetInDataAnchor(0));

  115.     (void)GraphUtils::AddEdge(condNode->GetOutDataAnchor(0), switchNode2->GetInDataAnchor(1));

  116. 

  117.     (void)GraphUtils::AddEdge(zNode->GetOutDataAnchor(0), switchNode3->GetInDataAnchor(0));

  118.     (void)GraphUtils::AddEdge(condNode->GetOutDataAnchor(0), switchNode3->GetInDataAnchor(1));

  119. 

  120.     (void)GraphUtils::AddEdge(switchNode1->GetOutDataAnchor(1), addNode->GetInDataAnchor(0));

  121.     (void)GraphUtils::AddEdge(switchNode2->GetOutDataAnchor(1), addNode->GetInDataAnchor(1));

  122. 

  123.     (void)GraphUtils::AddEdge(addNode->GetOutDataAnchor(0), mergeNode->GetInDataAnchor(1));

  124.     (void)GraphUtils::AddEdge(switchNode3->GetOutDataAnchor(0), mergeNode->GetInDataAnchor(0));

  125. 

  126.     (void)GraphUtils::AddEdge(mergeNode->GetOutDataAnchor(0), outputNode->GetInDataAnchor(0));

  127.   }

  128. 

  129.   void make_graph_const(ComputeGraphPtr graph, bool match = true) {

  130.     // resnet50 PolynomialDecay

  131.     GeTensorDesc scalarTensorDesc(GeShape({1, 1, 1, 1}));

  132.     GeTensorDesc boolTensorDesc(GeShape({1, 1, 1, 1}), ge::FORMAT_NCHW, ge::DT_BOOL);

  133.     GeTensorDesc intTensorDesc(GeShape({1, 1, 1, 1}), ge::FORMAT_NCHW, ge::DT_INT32);

  134. 

  135.     auto xOpDef = std::make_shared<OpDesc>("x", VARIABLEV2);

  136.     xOpDef->AddOutputDesc(scalarTensorDesc);

  137.     auto xNode = graph->AddNode(xOpDef);

  138. 

  139.     auto yOpDef = std::make_shared<OpDesc>("y", "Const");

  140.     yOpDef->AddOutputDesc(scalarTensorDesc);

  141.     auto yNode = graph->AddNode(yOpDef);

  142. 

  143.     auto zOpDef = std::make_shared<OpDesc>("z", VARIABLEV2);

  144.     zOpDef->AddOutputDesc(scalarTensorDesc);

  145.     auto zNode = graph->AddNode(zOpDef);

  146. 

  147.     auto constOpDef = std::make_shared<OpDesc>("Const", "Const");

  148.     constOpDef->AddOutputDesc(scalarTensorDesc);

  149.     auto constNode = graph->AddNode(constOpDef);

  150. 

  151.     auto condOpDef = std::make_shared<OpDesc>("Equal", "Equal");

  152.     condOpDef->AddInputDesc(scalarTensorDesc);

  153.     condOpDef->AddInputDesc(scalarTensorDesc);

  154.     condOpDef->AddOutputDesc(boolTensorDesc);

  155.     auto condNode = graph->AddNode(condOpDef);

  156. 

  157.     auto identityOpDef = std::make_shared<OpDesc>("identity", "Identity");

  158.     identityOpDef->AddInputDesc(boolTensorDesc);

  159.     identityOpDef->AddOutputDesc(boolTensorDesc);

  160.     auto identityNode = graph->AddNode(identityOpDef);

  161. 

  162.     auto switchOpDef1 = std::make_shared<OpDesc>("Switch", SWITCH);

  163.     switchOpDef1->AddInputDesc(boolTensorDesc);

  164.     switchOpDef1->AddInputDesc(boolTensorDesc);

  165.     switchOpDef1->AddOutputDesc(boolTensorDesc);

  166.     switchOpDef1->AddOutputDesc(boolTensorDesc);

  167.     auto switchNode1 = graph->AddNode(switchOpDef1);

  168. 

  169.     auto tIdentityOpDef = std::make_shared<OpDesc>("switch_t", "Identity");

  170.     tIdentityOpDef->AddInputDesc(scalarTensorDesc);

  171.     tIdentityOpDef->AddOutputDesc(scalarTensorDesc);

  172.     auto tIdentityNode = graph->AddNode(tIdentityOpDef);

  173. 

  174.     auto fIdentityOpDef = std::make_shared<OpDesc>("switch_f", "Identity");

  175.     fIdentityOpDef->AddInputDesc(scalarTensorDesc);

  176.     fIdentityOpDef->AddOutputDesc(scalarTensorDesc);

  177.     auto fIdentityNode = graph->AddNode(fIdentityOpDef);

  178. 

  179.     auto switchOpDef2 = std::make_shared<OpDesc>("Switch_1", SWITCH);

  180.     switchOpDef2->AddInputDesc(scalarTensorDesc);

  181.     switchOpDef2->AddInputDesc(boolTensorDesc);

  182.     switchOpDef2->AddOutputDesc(scalarTensorDesc);

  183.     switchOpDef2->AddOutputDesc(scalarTensorDesc);

  184.     auto switchNode2 = graph->AddNode(switchOpDef2);

  185. 

  186.     auto mulOpDef = std::make_shared<OpDesc>("truediv", "Mul");

  187.     mulOpDef->AddInputDesc(scalarTensorDesc);

  188.     mulOpDef->AddInputDesc(scalarTensorDesc);

  189.     mulOpDef->AddOutputDesc(scalarTensorDesc);

  190.     auto mulNode = graph->AddNode(mulOpDef);

  191. 

  192.     auto ceilOpDef = std::make_shared<OpDesc>("Ceil", "Ceil");

  193.     ceilOpDef->AddInputDesc(scalarTensorDesc);

  194.     ceilOpDef->AddOutputDesc(scalarTensorDesc);

  195.     auto ceilNode = graph->AddNode(ceilOpDef);

  196. 

  197.     auto mergeOpDef = std::make_shared<OpDesc>("Merge", "Merge");

  198.     mergeOpDef->AddInputDesc(scalarTensorDesc);

  199.     mergeOpDef->AddInputDesc(scalarTensorDesc);

  200.     mergeOpDef->AddOutputDesc(scalarTensorDesc);

  201.     mergeOpDef->AddOutputDesc(intTensorDesc);

  202.     auto mergeNode = graph->AddNode(mergeOpDef);

  203. 

  204.     auto outputOpDef = std::make_shared<OpDesc>("NetOutput", "NetOutput");

  205.     outputOpDef->AddInputDesc(scalarTensorDesc);

  206.     outputOpDef->AddOutputDesc(scalarTensorDesc);

  207.     auto outputNode = graph->AddNode(outputOpDef);

  208. 

  209.     (void)GraphUtils::AddEdge(xNode->GetOutDataAnchor(0), condNode->GetInDataAnchor(0));

  210.     (void)GraphUtils::AddEdge(yNode->GetOutDataAnchor(0), condNode->GetInDataAnchor(1));

  211. 

  212.     (void)GraphUtils::AddEdge(condNode->GetOutDataAnchor(0), identityNode->GetInDataAnchor(0));

  213.     (void)GraphUtils::AddEdge(identityNode->GetOutDataAnchor(0), switchNode1->GetInDataAnchor(0));

  214.     (void)GraphUtils::AddEdge(identityNode->GetOutDataAnchor(0), switchNode1->GetInDataAnchor(1));

  215. 

  216.     (void)GraphUtils::AddEdge(switchNode1->GetOutDataAnchor(0), fIdentityNode->GetInDataAnchor(0));

  217.     (void)GraphUtils::AddEdge(switchNode1->GetOutDataAnchor(1), tIdentityNode->GetInDataAnchor(0));

  218. 

  219.     (void)GraphUtils::AddEdge(fIdentityNode->GetOutControlAnchor(), zNode->GetInControlAnchor());

  220.     (void)GraphUtils::AddEdge(tIdentityNode->GetOutControlAnchor(), constNode->GetInControlAnchor());

  221. 

  222.     (void)GraphUtils::AddEdge(xNode->GetOutDataAnchor(0), switchNode2->GetInDataAnchor(0));

  223.     (void)GraphUtils::AddEdge(identityNode->GetOutDataAnchor(0), switchNode2->GetInDataAnchor(1));

  224. 

  225.     (void)GraphUtils::AddEdge(zNode->GetOutDataAnchor(0), mulNode->GetInDataAnchor(0));

  226.     (void)GraphUtils::AddEdge(switchNode2->GetOutDataAnchor(0), mulNode->GetInDataAnchor(1));

  227. 

  228.     (void)GraphUtils::AddEdge(mulNode->GetOutDataAnchor(0), ceilNode->GetInDataAnchor(0));

  229. 

  230.     (void)GraphUtils::AddEdge(constNode->GetOutDataAnchor(0), mergeNode->GetInDataAnchor(1));

  231.     (void)GraphUtils::AddEdge(ceilNode->GetOutDataAnchor(0), mergeNode->GetInDataAnchor(0));

  232. 

  233.     (void)GraphUtils::AddEdge(mergeNode->GetOutDataAnchor(0), outputNode->GetInDataAnchor(0));

  234.   }

  235. 

  236.   void make_graph_cyclic_dependence(ComputeGraphPtr graph, bool match = true) {

  237.     GeTensorDesc scalarTensorDesc(GeShape({1, 1, 1, 1}));

  238.     GeTensorDesc boolTensorDesc(GeShape({1, 1, 1, 1}), ge::FORMAT_NCHW, ge::DT_BOOL);

  239.     GeTensorDesc intTensorDesc(GeShape({1, 1, 1, 1}), ge::FORMAT_NCHW, ge::DT_INT32);

  240. 

  241.     auto xOpDef = std::make_shared<OpDesc>("x", VARIABLEV2);

  242.     xOpDef->AddOutputDesc(scalarTensorDesc);

  243.     auto xNode = graph->AddNode(xOpDef);

  244. 

  245.     auto yOpDef = std::make_shared<OpDesc>("y", VARIABLEV2);

  246.     yOpDef->AddOutputDesc(scalarTensorDesc);

  247.     auto yNode = graph->AddNode(yOpDef);

  248. 

  249.     auto zOpDef = std::make_shared<OpDesc>("z", VARIABLEV2);

  250.     zOpDef->AddOutputDesc(scalarTensorDesc);

  251.     auto zNode = graph->AddNode(zOpDef);

  252. 

  253.     auto condOpDef = std::make_shared<OpDesc>("Less", "Less");

  254.     condOpDef->AddInputDesc(scalarTensorDesc);

  255.     condOpDef->AddInputDesc(scalarTensorDesc);

  256.     condOpDef->AddOutputDesc(boolTensorDesc);

  257.     auto condNode = graph->AddNode(condOpDef);

  258. 

  259.     auto switchOpDef1 = std::make_shared<OpDesc>("Switch_f_1", SWITCH);

  260.     switchOpDef1->AddInputDesc(scalarTensorDesc);

  261.     switchOpDef1->AddInputDesc(boolTensorDesc);

  262.     switchOpDef1->AddOutputDesc(scalarTensorDesc);

  263.     switchOpDef1->AddOutputDesc(scalarTensorDesc);

  264.     auto switchNode1 = graph->AddNode(switchOpDef1);

  265. 

  266.     auto switchOpDef2 = std::make_shared<OpDesc>("Switch_t_1", SWITCH);

  267.     switchOpDef2->AddInputDesc(scalarTensorDesc);

  268.     switchOpDef2->AddInputDesc(boolTensorDesc);

  269.     switchOpDef2->AddOutputDesc(scalarTensorDesc);

  270.     switchOpDef2->AddOutputDesc(scalarTensorDesc);

  271.     auto switchNode2 = graph->AddNode(switchOpDef2);

  272. 

  273.     auto switchOpDef3 = std::make_shared<OpDesc>("Switch_f_2", SWITCH);

  274.     switchOpDef3->AddInputDesc(scalarTensorDesc);

  275.     switchOpDef3->AddInputDesc(boolTensorDesc);

  276.     switchOpDef3->AddOutputDesc(scalarTensorDesc);

  277.     switchOpDef3->AddOutputDesc(scalarTensorDesc);

  278.     auto switchNode3 = graph->AddNode(switchOpDef3);

  279. 

  280.     auto switchOpDef4 = std::make_shared<OpDesc>("Switch_t_2", SWITCH);

  281.     switchOpDef4->AddInputDesc(scalarTensorDesc);

  282.     switchOpDef4->AddInputDesc(boolTensorDesc);

  283.     switchOpDef4->AddOutputDesc(scalarTensorDesc);

  284.     switchOpDef4->AddOutputDesc(scalarTensorDesc);

  285.     auto switchNode4 = graph->AddNode(switchOpDef4);

  286. 

  287.     auto squareOpDef1 = std::make_shared<OpDesc>("Square1", "Square");

  288.     squareOpDef1->AddInputDesc(scalarTensorDesc);

  289.     squareOpDef1->AddOutputDesc(scalarTensorDesc);

  290.     auto squareNode1 = graph->AddNode(squareOpDef1);

  291. 

  292.     auto squareOpDef2 = std::make_shared<OpDesc>("Square2", "Square");

  293.     squareOpDef2->AddInputDesc(scalarTensorDesc);

  294.     squareOpDef2->AddOutputDesc(scalarTensorDesc);

  295.     auto squareNode2 = graph->AddNode(squareOpDef2);

  296. 

  297.     auto squareOpDef3 = std::make_shared<OpDesc>("Square3", "Square");

  298.     squareOpDef3->AddInputDesc(scalarTensorDesc);

  299.     squareOpDef3->AddOutputDesc(scalarTensorDesc);

  300.     auto squareNode3 = graph->AddNode(squareOpDef3);

  301. 

  302.     auto squareOpDef4 = std::make_shared<OpDesc>("Square4", "Square");

  303.     squareOpDef4->AddInputDesc(scalarTensorDesc);

  304.     squareOpDef4->AddOutputDesc(scalarTensorDesc);

  305.     auto squareNode4 = graph->AddNode(squareOpDef4);

  306. 

  307.     auto mergeOpDef1 = std::make_shared<OpDesc>("Merge1", "Merge");

  308.     mergeOpDef1->AddInputDesc(scalarTensorDesc);

  309.     mergeOpDef1->AddInputDesc(scalarTensorDesc);

  310.     mergeOpDef1->AddOutputDesc(scalarTensorDesc);

  311.     mergeOpDef1->AddOutputDesc(intTensorDesc);

  312.     auto mergeNode1 = graph->AddNode(mergeOpDef1);

  313. 

  314.     auto mergeOpDef2 = std::make_shared<OpDesc>("Merge2", "Merge");

  315.     mergeOpDef2->AddInputDesc(scalarTensorDesc);

  316.     mergeOpDef2->AddInputDesc(scalarTensorDesc);

  317.     mergeOpDef2->AddOutputDesc(scalarTensorDesc);

  318.     mergeOpDef2->AddOutputDesc(intTensorDesc);

  319.     auto mergeNode2 = graph->AddNode(mergeOpDef2);

  320. 

  321.     auto outputOpDef = std::make_shared<OpDesc>("NetOutput", "NetOutput");

  322.     outputOpDef->AddInputDesc(scalarTensorDesc);

  323.     outputOpDef->AddOutputDesc(scalarTensorDesc);

  324.     auto outputNode = graph->AddNode(outputOpDef);

  325. 

  326.     (void)GraphUtils::AddEdge(xNode->GetOutDataAnchor(0), condNode->GetInDataAnchor(0));

  327.     (void)GraphUtils::AddEdge(yNode->GetOutDataAnchor(0), condNode->GetInDataAnchor(1));

  328. 

  329.     (void)GraphUtils::AddEdge(zNode->GetOutDataAnchor(0), switchNode1->GetInDataAnchor(0));

  330.     (void)GraphUtils::AddEdge(condNode->GetOutDataAnchor(0), switchNode1->GetInDataAnchor(1));

  331. 

  332.     (void)GraphUtils::AddEdge(zNode->GetOutDataAnchor(0), switchNode2->GetInDataAnchor(0));

  333.     (void)GraphUtils::AddEdge(condNode->GetOutDataAnchor(0), switchNode2->GetInDataAnchor(1));

  334. 

  335.     (void)GraphUtils::AddEdge(switchNode1->GetOutDataAnchor(0), squareNode1->GetInDataAnchor(0));

  336.     (void)GraphUtils::AddEdge(switchNode2->GetOutDataAnchor(1), squareNode2->GetInDataAnchor(0));

  337. 

  338.     (void)GraphUtils::AddEdge(squareNode1->GetOutDataAnchor(0), mergeNode1->GetInDataAnchor(0));

  339.     (void)GraphUtils::AddEdge(squareNode2->GetOutDataAnchor(0), mergeNode1->GetInDataAnchor(1));

  340. 

  341.     (void)GraphUtils::AddEdge(mergeNode1->GetOutDataAnchor(0), switchNode3->GetInDataAnchor(0));

  342.     (void)GraphUtils::AddEdge(condNode->GetOutDataAnchor(0), switchNode3->GetInDataAnchor(1));

  343. 

  344.     (void)GraphUtils::AddEdge(zNode->GetOutDataAnchor(0), switchNode4->GetInDataAnchor(0));

  345.     (void)GraphUtils::AddEdge(condNode->GetOutDataAnchor(0), switchNode4->GetInDataAnchor(1));

  346. 

  347.     (void)GraphUtils::AddEdge(switchNode3->GetOutDataAnchor(0), squareNode3->GetInDataAnchor(0));

  348.     (void)GraphUtils::AddEdge(switchNode4->GetOutDataAnchor(1), squareNode4->GetInDataAnchor(0));

  349. 

  350.     (void)GraphUtils::AddEdge(squareNode3->GetOutDataAnchor(0), mergeNode2->GetInDataAnchor(0));

  351.     (void)GraphUtils::AddEdge(squareNode4->GetOutDataAnchor(0), mergeNode2->GetInDataAnchor(1));

  352. 

  353.     (void)GraphUtils::AddEdge(mergeNode2->GetOutDataAnchor(0), outputNode->GetInDataAnchor(0));

  354.   }

  355. 

  356.   void make_graph_case(ComputeGraphPtr graph, bool match = true) {

  357.     GeTensorDesc scalarTensorDesc(GeShape({1, 1, 1, 1}));

  358.     GeTensorDesc boolTensorDesc(GeShape({1, 1, 1, 1}), ge::FORMAT_NCHW, ge::DT_BOOL);

  359.     GeTensorDesc intTensorDesc(GeShape({1, 1, 1, 1}), ge::FORMAT_NCHW, ge::DT_INT32);

  360. 

  361.     auto xOpDef = std::make_shared<OpDesc>("x", VARIABLEV2);

  362.     xOpDef->AddOutputDesc(scalarTensorDesc);

  363.     auto xNode = graph->AddNode(xOpDef);

  364. 

  365.     auto yOpDef = std::make_shared<OpDesc>("y", VARIABLEV2);

  366.     yOpDef->AddOutputDesc(scalarTensorDesc);

  367.     auto yNode = graph->AddNode(yOpDef);

  368. 

  369.     auto zOpDef = std::make_shared<OpDesc>("z", VARIABLEV2);

  370.     zOpDef->AddOutputDesc(scalarTensorDesc);

  371.     auto zNode = graph->AddNode(zOpDef);

  372. 

  373.     auto greaterOpDef = std::make_shared<OpDesc>("Greater", "Greater");

  374.     greaterOpDef->AddInputDesc(scalarTensorDesc);

  375.     greaterOpDef->AddInputDesc(scalarTensorDesc);

  376.     greaterOpDef->AddOutputDesc(boolTensorDesc);

  377.     auto greaterNode = graph->AddNode(greaterOpDef);

  378. 

  379.     auto lessOpDef = std::make_shared<OpDesc>("Less", "Less");

  380.     lessOpDef->AddInputDesc(scalarTensorDesc);

  381.     lessOpDef->AddInputDesc(scalarTensorDesc);

  382.     lessOpDef->AddOutputDesc(boolTensorDesc);

  383.     auto lessNode = graph->AddNode(lessOpDef);

  384. 

  385.     auto switchOpDef1 = std::make_shared<OpDesc>("greater/Switch_t", SWITCH);

  386.     switchOpDef1->AddInputDesc(boolTensorDesc);

  387.     switchOpDef1->AddInputDesc(boolTensorDesc);

  388.     switchOpDef1->AddOutputDesc(boolTensorDesc);

  389.     switchOpDef1->AddOutputDesc(boolTensorDesc);

  390.     auto switchNode1 = graph->AddNode(switchOpDef1);

  391. 

  392.     auto switchOpDef2 = std::make_shared<OpDesc>("greater/Switch_f", SWITCH);

  393.     switchOpDef2->AddInputDesc(scalarTensorDesc);

  394.     switchOpDef2->AddInputDesc(boolTensorDesc);

  395.     switchOpDef2->AddOutputDesc(scalarTensorDesc);

  396.     switchOpDef2->AddOutputDesc(scalarTensorDesc);

  397.     auto switchNode2 = graph->AddNode(switchOpDef2);

  398. 

  399.     auto switchOpDef3 = std::make_shared<OpDesc>("less/Switch_t", SWITCH);

  400.     switchOpDef3->AddInputDesc(scalarTensorDesc);

  401.     switchOpDef3->AddInputDesc(boolTensorDesc);

  402.     switchOpDef3->AddOutputDesc(scalarTensorDesc);

  403.     switchOpDef3->AddOutputDesc(scalarTensorDesc);

  404.     auto switchNode3 = graph->AddNode(switchOpDef3);

  405. 

  406.     auto switchOpDef4 = std::make_shared<OpDesc>("less/Switch_f", SWITCH);

  407.     switchOpDef4->AddInputDesc(scalarTensorDesc);

  408.     switchOpDef4->AddInputDesc(boolTensorDesc);

  409.     switchOpDef4->AddOutputDesc(scalarTensorDesc);

  410.     switchOpDef4->AddOutputDesc(scalarTensorDesc);

  411.     auto switchNode4 = graph->AddNode(switchOpDef4);

  412. 

  413.     auto mergeOpDef1 = std::make_shared<OpDesc>("Merge1", "Merge");

  414.     mergeOpDef1->AddInputDesc(scalarTensorDesc);

  415.     mergeOpDef1->AddInputDesc(scalarTensorDesc);

  416.     mergeOpDef1->AddOutputDesc(scalarTensorDesc);

  417.     mergeOpDef1->AddOutputDesc(intTensorDesc);

  418.     auto mergeNode1 = graph->AddNode(mergeOpDef1);

  419. 

  420.     auto mergeOpDef2 = std::make_shared<OpDesc>("Merge2", "Merge");

  421.     mergeOpDef2->AddInputDesc(scalarTensorDesc);

  422.     mergeOpDef2->AddInputDesc(scalarTensorDesc);

  423.     mergeOpDef2->AddOutputDesc(scalarTensorDesc);

  424.     mergeOpDef2->AddOutputDesc(intTensorDesc);

  425.     auto mergeNode2 = graph->AddNode(mergeOpDef2);

  426. 

  427.     auto outputOpDef = std::make_shared<OpDesc>("NetOutput", "NetOutput");

  428.     outputOpDef->AddInputDesc(scalarTensorDesc);

  429.     outputOpDef->AddOutputDesc(scalarTensorDesc);

  430.     auto outputNode = graph->AddNode(outputOpDef);

  431. 

  432.     (void)GraphUtils::AddEdge(xNode->GetOutDataAnchor(0), greaterNode->GetInDataAnchor(0));

  433.     (void)GraphUtils::AddEdge(yNode->GetOutDataAnchor(0), greaterNode->GetInDataAnchor(1));

  434. 

  435.     (void)GraphUtils::AddEdge(xNode->GetOutDataAnchor(0), lessNode->GetInDataAnchor(0));

  436.     (void)GraphUtils::AddEdge(yNode->GetOutDataAnchor(0), lessNode->GetInDataAnchor(1));

  437. 

  438.     (void)GraphUtils::AddEdge(xNode->GetOutDataAnchor(0), switchNode1->GetInDataAnchor(0));

  439.     (void)GraphUtils::AddEdge(greaterNode->GetOutDataAnchor(0), switchNode1->GetInDataAnchor(1));

  440. 

  441.     (void)GraphUtils::AddEdge(lessNode->GetOutDataAnchor(0), switchNode2->GetInDataAnchor(0));

  442.     (void)GraphUtils::AddEdge(greaterNode->GetOutDataAnchor(0), switchNode2->GetInDataAnchor(1));

  443. 

  444.     (void)GraphUtils::AddEdge(yNode->GetOutDataAnchor(0), switchNode3->GetInDataAnchor(0));

  445.     (void)GraphUtils::AddEdge(switchNode2->GetOutDataAnchor(0), switchNode3->GetInDataAnchor(1));

  446. 

  447.     (void)GraphUtils::AddEdge(zNode->GetOutDataAnchor(0), switchNode4->GetInDataAnchor(0));

  448.     (void)GraphUtils::AddEdge(switchNode2->GetOutDataAnchor(0), switchNode4->GetInDataAnchor(1));

  449. 

  450.     (void)GraphUtils::AddEdge(switchNode3->GetOutDataAnchor(1), mergeNode1->GetInDataAnchor(0));

  451.     (void)GraphUtils::AddEdge(switchNode4->GetOutDataAnchor(0), mergeNode1->GetInDataAnchor(1));

  452. 

  453.     (void)GraphUtils::AddEdge(switchNode1->GetOutDataAnchor(1), mergeNode2->GetInDataAnchor(0));

  454.     (void)GraphUtils::AddEdge(mergeNode1->GetOutDataAnchor(0), mergeNode2->GetInDataAnchor(1));

  455. 

  456.     (void)GraphUtils::AddEdge(mergeNode2->GetOutDataAnchor(0), outputNode->GetInDataAnchor(0));

  457.   }

  458. };