OpenI
/
parser
Not watched
1
0
Fork 0
Code
Releases 0 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: 0eb76b898d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0eb76b898d'
${ noResults }
parser/tests/st/testcase/test_tensorflow_parser.cc

4465 lines
171 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. #define protected public

  20. #define private public

  21. #include "parser/common/op_parser_factory.h"

  22. #include "parser/tensorflow/tensorflow_parser.h"

  23. #include "graph/operator_reg.h"

  24. #include "register/op_registry.h"

  25. #include "external/register/register.h"

  26. #include "st/parser_st_utils.h"

  27. #include "tests/depends/ops_stub/ops_stub.h"

  28. #include "parser/common/acl_graph_parser_util.h"

  29. #include "external/ge/ge_api_types.h"

  30. #include "omg/parser/parser_factory.h"

  31. #include "common/pre_checker.h"

  32. #include "common/util.h"

  33. #include "external/parser/tensorflow_parser.h"

  34. #include "parser/tensorflow/tensorflow_constant_parser.h"

  35. #include "common/types.h"

  36. #include "parser/common/op_def/variable_operator.h"

  37. #include "parser/tensorflow/tensorflow_ref_switch_parser.h"

  38. #include "parser/tensorflow/tensorflow_fusion_op_parser.h"

  39. #include "parser/tensorflow/tensorflow_auto_mapping_parser_adapter.h"

  40. #include "parser/common/op_def/arg_op_operator.h"

  41. #include "parser/tensorflow/tensorflow_fusion_custom_parser_adapter.h"

  42. #include "parser/tensorflow/tensorflow_reshape_parser.h"

  43. #include "parser/tensorflow/tensorflow_custom_parser_adapter.h"

  44. #include "parser/tensorflow/tensorflow_squeeze_parser.h"

  45. #include "parser/tensorflow/graph_to_function_def.h"

  46. #include "parser/tensorflow/parser_graph_optimizer.h"

  47. #include "cce/dnn_base_def.hpp"

  48. #include "parser/tensorflow/scope/scope_pass_manager.h"

  49. #include "parser/tensorflow/tensorflow_util.h"

  50. #include "compute_graph_impl.h"

  51. #include "parser/tensorflow/tensorflow_enter_parser.h"

  52. #include "parser/common/op_def/ir_pb_converter.h"

  53. #include "parser/common/tuple.h"

  54. #include "common/op_def/framework_op_operator.h"

  55. #include "common/op_def/shape_n_operator.h"

  56. #include "common/op_def/var_is_initialized_op_operator.h"

  57. #include "common/op_def/fill_operator.h"

  58. #include "common/convert/pb2json.h"

  59. #include "common/convert/message2operator.h"

  60. #include "parser/common/proto_file_parser.h"

  61. #include "parser/common/pre_checker.h"

  62. #include "parser/common/tbe_plugin_loader.h"

  63. #include "parser/common/data_op_parser.h"

  64. #include "parser/common/model_saver.h"

  65. #include "framework/omg/parser/parser_api.h"

  66. #include "framework/omg/parser/parser_factory.h"

  67. #include "parser/common/parser_fp16_t.h"

  68. #include "parser/common/op_parser_factory.h"

  69. #include "parser/common/prototype_pass_manager.h"

  70. #include "parser/common/op_registration_tbe.h"

  71. #include "parser/common/pass_manager.h"

  72. #include "parser/tensorflow/parser_graph_optimizer.h"

  73. #include "metadef/inc/register/scope/scope_pass_registry_impl.h"

  74. #include "register/scope/scope_fusion_pass_register.h"

  75. #undef protected

  76. #undef private

  77. 

  78. using namespace std;

  79. using namespace domi::tensorflow;

  80. using namespace domi;

  81. using namespace cce;

  82. using namespace testing;

  83. using namespace std;

  84. using namespace google::protobuf;

  85. 

  86. static const string GRAPH_DEFAULT_NAME = "default";

  87. 

  88. namespace ge {

  89. class STestTensorflowParser : public testing::Test {

  90.  protected:

  91.   void SetUp() {

  92.     ParerSTestsUtils::ClearParserInnerCtx();

  93.   }

  94. 

  95.   void TearDown() {}

  96. 

  97.  public:

  98.   void RegisterCustomOp();

  99. };

  100. 

  101. class TestOperator : public ParserOperator

  102. {

  103. public:

  104.     TestOperator()

  105.       : ParserOperator("test")

  106.     {

  107.     }

  108. 

  109.     ~TestOperator()

  110.     {

  111.     }

  112. };

  113. 

  114. class ErrorGraphPass: public GraphPass

  115. {

  116.     Status Run(ComputeGraphPtr graph)

  117.     {

  118.         return domi::FAILED;

  119.     }

  120. };

  121. 

  122. class ScopeTestPass : public ScopeBasePass {

  123. protected:

  124.   vector<ScopeFusionPatterns> DefinePatterns() {

  125.     vector<ScopeFusionPatterns> patterns_list;

  126.     return patterns_list;

  127.   };

  128.   string PassName() {

  129.     return "test";

  130.   };

  131.   Status LastMatchScopesAndOPs(shared_ptr<ScopeGraph> &scope_graph, vector<ScopesResult> &results) {

  132.     return domi::SUCCESS;

  133.   };

  134.   void GenerateFusionResult(const vector<Scope *> &scopes, FusionScopesResult *fusion_rlt) {

  135.     return;

  136.   };

  137. };

  138. 

  139. static Status ParseParams(const google::protobuf::Message* op_src, ge::Operator& op_dest) {

  140.   return SUCCESS;

  141. }

  142. 

  143. static Status ParseParamByOpFunc(const ge::Operator &op_src, ge::Operator& op_dest) {

  144.   return SUCCESS;

  145. }

  146. 

  147. void STestTensorflowParser::RegisterCustomOp() {

  148.   REGISTER_CUSTOM_OP("Add")

  149.   .FrameworkType(domi::TENSORFLOW)

  150.   .OriginOpType("Add")

  151.   .ParseParamsFn(ParseParams);

  152.   std::vector<OpRegistrationData> reg_datas = domi::OpRegistry::Instance()->registrationDatas;

  153.   for (auto reg_data : reg_datas) {

  154.     domi::OpRegTbeParserFactory::Instance()->Finalize(reg_data);

  155.     domi::OpRegistry::Instance()->Register(reg_data);

  156.   }

  157.   domi::OpRegistry::Instance()->registrationDatas.clear();

  158. }

  159. 

  160. void AddDumpOriginName(const ge::NodePtr parent_node, const std::string& subgraph_name, ge::ComputeGraphPtr graph);

  161. 

  162. namespace {

  163.   NodeDef* AddNode(GraphDef& graph, string type, string name) {

  164.     NodeDef* nodeDef = graph.add_node();

  165.     nodeDef->set_op(type);

  166.     nodeDef->set_name(name);

  167. 

  168.     tensorflow::OpDef op_def;

  169.     string op_def_string;

  170.     op_def.SerializeToString(&op_def_string);

  171. 

  172.     tensorflow::AttrValue value;

  173.     value.set_s(op_def_string);

  174.     nodeDef->mutable_attr()->insert({"op_def", value});

  175.     return nodeDef;

  176.   }

  177. 

  178.   void AddInput(NodeDef* src, NodeDef* dst, int srcIndex) {

  179.     if(srcIndex == -1){

  180.         dst->add_input("^"+src->name());

  181.     } else {

  182.       if (srcIndex == 0) {

  183.         dst->add_input(src->name());

  184.       } else {

  185.         dst->add_input(src->name() + ":" + std::to_string(srcIndex));

  186.       }

  187.       {

  188.         auto input = (*dst->mutable_attr())[ge::ATTR_NAME_INPUT_TENSOR_DESC].mutable_list()->add_func();

  189.         tensorflow::AttrValue val1;

  190.         val1.set_i(0);

  191.         (*input->mutable_attr())["serialize_format"] = val1;

  192.         tensorflow::AttrValue val2;

  193.         val2.set_i(tensorflow::DT_FLOAT);

  194.         (*input->mutable_attr())["serialize_datatype"] = val2;

  195.         tensorflow::AttrValue val3;

  196.         val3.mutable_list()->add_i(10);

  197.         (*input->mutable_attr())["serialize_shape"] = val3;

  198.       }

  199. 

  200.       {

  201.         auto output = (*src->mutable_attr())[ge::ATTR_NAME_OUTPUT_TENSOR_DESC].mutable_list()->add_func();

  202.         tensorflow::AttrValue val1;

  203.         val1.set_i(0);

  204.         (*output->mutable_attr())["serialize_format"] = val1;

  205.         tensorflow::AttrValue val2;

  206.         val2.set_i(tensorflow::DT_FLOAT);

  207.         (*output->mutable_attr())["serialize_datatype"] = val2;

  208.         tensorflow::AttrValue val3;

  209.         val3.mutable_list()->add_i(10);

  210.         (*output->mutable_attr())["serialize_shape"] = val3;

  211.       }

  212.     }

  213.   }

  214. 

  215.   NodeDef *initNodeDef() {

  216.     NodeDef * nodeDef = new NodeDef();

  217.     nodeDef->set_op("Const");

  218.     ::google::protobuf::Map<std::string, tensorflow::AttrValue >* node_attr_map = nodeDef->mutable_attr();

  219. 

  220.     //设置 T属性

  221.     domi::tensorflow::AttrValue t_attr_value;

  222.     t_attr_value.set_type(domi::tensorflow::DT_INT32);

  223.     (*node_attr_map)[TENSORFLOW_ATTR_T] = t_attr_value;

  224. 

  225.     domi::tensorflow::AttrValue dtype_attr_value;

  226.     dtype_attr_value.set_type(domi::tensorflow::DT_INT32);

  227.     (*node_attr_map)[TENSORFLOW_ATTR_DTYPE] = dtype_attr_value;

  228. 

  229.     // out_put

  230.     domi::tensorflow::AttrValue outputs_attr_value;

  231.     ::tensorflow::AttrValue_ListValue* list = outputs_attr_value.mutable_list();

  232.     list->add_s("MatMul");

  233.     (*node_attr_map)[TENSORFLOW_ATTR_OUTPUT_OP] = outputs_attr_value;

  234. 

  235.     // 设置 tensor 属性

  236.     domi::tensorflow::AttrValue value_attr_value;

  237.     tensorflow::TensorProto* tensor = value_attr_value.mutable_tensor();

  238.     tensorflow::TensorShapeProto* tensor_shape = tensor->mutable_tensor_shape();

  239.     tensor_shape->clear_dim();

  240.     tensor_shape->add_dim()->set_size(4);

  241.     tensor_shape->add_dim()->set_size(6);

  242.     tensor->set_dtype(domi::tensorflow::DT_INT32);

  243. 

  244.     float *addr = new float[24];

  245.     for (int32_t i = 0; i < 24; i++) {

  246.         *(addr + i) = 1.0 + i;

  247.     }

  248.     tensor->set_tensor_content((void *)addr, 24 * sizeof(float));

  249. 

  250.     (*node_attr_map)[TENSORFLOW_ATTR_VALUE] = value_attr_value;

  251.     delete[] addr;

  252.     return nodeDef;

  253.   }

  254. 

  255.   NodeDef * initOpNodeDef_VariableV2() {

  256.     NodeDef * nodeDef = new NodeDef();

  257.     nodeDef->set_op("VariableV2");

  258.     google::protobuf::Map<std::string, tensorflow::AttrValue > *node_attr_map = nodeDef->mutable_attr();

  259. 

  260.     //设置data_format属性

  261.     domi::tensorflow::AttrValue format_attr_value;

  262.     format_attr_value.set_s("_FZ");

  263.     (*node_attr_map)[VAR_ATTR_FORMAT] = format_attr_value;

  264. 

  265.     domi::tensorflow::AttrValue type_attr;

  266.     type_attr.set_type(domi::tensorflow::DT_FLOAT);

  267.     (*node_attr_map)[VAR_ATTR_DTYPE] = type_attr;

  268. 

  269.     domi::tensorflow::AttrValue container_attr_value;

  270.     container_attr_value.set_s("container");

  271.     (*node_attr_map)[VAR_ATTR_CONTAINER] = container_attr_value;

  272. 

  273.     domi::tensorflow::AttrValue shard_name_attr_value;

  274.     shard_name_attr_value.set_s("shard_name");

  275.     (*node_attr_map)[VAR_ATTR_SHARED_NAME] = shard_name_attr_value;

  276. 

  277.     domi::tensorflow::AttrValue shape_attr_value;

  278.     shape_attr_value.mutable_shape()->add_dim()->set_size(1);

  279.     shape_attr_value.mutable_shape()->add_dim()->set_size(2);

  280.     shape_attr_value.mutable_shape()->add_dim()->set_size(3);

  281.     shape_attr_value.mutable_shape()->add_dim()->set_size(4);

  282.     (*node_attr_map)[ge::VAR_ATTR_SHAPE] = shape_attr_value;

  283. 

  284.     domi::tensorflow::AttrValue shape;

  285.     shape.mutable_list()->add_i((int64)32);

  286.     shape.mutable_list()->add_i((int64)32);

  287.     shape.mutable_list()->add_i((int64)14);

  288.     shape.mutable_list()->add_i((int64)14);

  289. 

  290.     //设置data_format属性

  291.     domi::tensorflow::AttrValue df_attr_value;

  292.     domi::tensorflow::AttrValue df_attr_value2;

  293.     df_attr_value2.set_s(TENSORFLOWF_TENSOR_NHWC);

  294. 

  295.     df_attr_value.set_i((int64_t)ccTensorFormat_t::CC_TENSOR_NHWC);

  296.     (*node_attr_map)[TENSORFLOW_ATTR_DATA_FORMAT] = df_attr_value2;

  297.     //设置padding属性

  298.     domi::tensorflow::AttrValue pad_attr_value;

  299.     domi::tensorflow::AttrValue pad_attr_value2;

  300.     pad_attr_value2.set_s(TENSORFLOWF_OP_PADDING_SAME);

  301.     (*node_attr_map)[TENSORFLOW_ATTR_PADDING] = pad_attr_value2;

  302.     pad_attr_value.set_i((int64_t)tensorflow::DT_FLOAT);

  303. 

  304.     domi::tensorflow::NameAttrList name_attr_list;

  305.     name_attr_list.set_name(std::to_string(0));

  306.     name_attr_list.mutable_attr()->insert({"serialize_shape", shape});

  307.     name_attr_list.mutable_attr()->insert({"serialize_format", df_attr_value});

  308.     name_attr_list.mutable_attr()->insert({"serialize_datatype", pad_attr_value});

  309.     domi::tensorflow::AttrValue output_tensor_descs;

  310.     *(output_tensor_descs.mutable_list()->add_func()) = name_attr_list;

  311.     nodeDef->mutable_attr()->insert({ge::ATTR_NAME_OUTPUT_TENSOR_DESC, output_tensor_descs});

  312.     return nodeDef;

  313.   }

  314. 

  315.   NodeDef *initOpNodeDef_TemporaryVariable() {

  316.     NodeDef * nodeDef = new NodeDef();

  317.     nodeDef->set_op("TemporaryVariable");

  318.     google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map = nodeDef->mutable_attr();

  319. 

  320.     //设置dtype属性

  321.     domi::tensorflow::AttrValue type_attr;

  322.     type_attr.set_type(domi::tensorflow::DT_FLOAT);

  323.     (*node_attr_map)[VAR_ATTR_DTYPE] = type_attr;

  324. 

  325.     //设置var_name属性

  326.     domi::tensorflow::AttrValue var_name_attr_value;

  327.     var_name_attr_value.set_s("temporary_variable_name");

  328.     (*node_attr_map)[ge::VAR_ATTR_NAME] = var_name_attr_value;

  329. 

  330.     //设置shape属性

  331.     domi::tensorflow::AttrValue shape_attr_value;

  332.     shape_attr_value.mutable_shape()->add_dim()->set_size(1);

  333.     shape_attr_value.mutable_shape()->add_dim()->set_size(2);

  334.     shape_attr_value.mutable_shape()->add_dim()->set_size(3);

  335.     shape_attr_value.mutable_shape()->add_dim()->set_size(4);

  336.     (*node_attr_map)[ge::VAR_ATTR_SHAPE] = shape_attr_value;

  337. 

  338.     domi::tensorflow::AttrValue shape;

  339.     shape.mutable_list()->add_i((int64)32);

  340.     shape.mutable_list()->add_i((int64)32);

  341.     shape.mutable_list()->add_i((int64)14);

  342.     shape.mutable_list()->add_i((int64)14);

  343. 

  344.     //设置data_format属性

  345.     domi::tensorflow::AttrValue df_attr_value2;

  346.     df_attr_value2.set_s(TENSORFLOWF_TENSOR_NHWC);

  347.     (*node_attr_map)[TENSORFLOW_ATTR_DATA_FORMAT] = df_attr_value2;

  348.     domi::tensorflow::AttrValue df_attr_value;

  349.     df_attr_value.set_i((int64_t)ccTensorFormat_t::CC_TENSOR_NHWC);

  350. 

  351.     //设置padding属性

  352.     domi::tensorflow::AttrValue pad_attr_value2;

  353.     pad_attr_value2.set_s(TENSORFLOWF_OP_PADDING_SAME);

  354.     (*node_attr_map)[TENSORFLOW_ATTR_PADDING] = pad_attr_value2;

  355.     domi::tensorflow::AttrValue pad_attr_value;

  356.     pad_attr_value.set_i((int64_t)tensorflow::DT_FLOAT);

  357. 

  358.     domi::tensorflow::NameAttrList name_attr_list;

  359.     name_attr_list.set_name(std::to_string(0));

  360.     name_attr_list.mutable_attr()->insert({"serialize_shape", shape});

  361.     name_attr_list.mutable_attr()->insert({"serialize_format", df_attr_value});

  362.     name_attr_list.mutable_attr()->insert({"serialize_datatype", pad_attr_value});

  363.     domi::tensorflow::AttrValue output_tensor_descs;

  364.     *(output_tensor_descs.mutable_list()->add_func()) = name_attr_list;

  365.     nodeDef->mutable_attr()->insert({ge::ATTR_NAME_OUTPUT_TENSOR_DESC, output_tensor_descs});

  366.     return nodeDef;

  367.   }

  368. 

  369.   NodeDef *fusioninitNodeDef(int index) {

  370.     NodeDef *nodeDef = new NodeDef();

  371.     google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map = nodeDef->mutable_attr();

  372. 

  373.     //设置 type属性

  374.     domi::tensorflow::AttrValue dtype_attr_value ;

  375. 

  376.     if (index == 0) {

  377.         dtype_attr_value.set_type(domi::tensorflow::DT_FLOAT);

  378.     } else if (index == 1) {

  379.         dtype_attr_value.set_type(domi::tensorflow::DT_INT32);

  380.     } else if (index == 2) {

  381.         dtype_attr_value.set_type(tensorflow::DT_HALF);

  382.     }

  383.     (*node_attr_map)[ge::TENSORFLOW_ATTR_DTYPE] = dtype_attr_value;

  384.     //设置data_format属性

  385.     domi::tensorflow::AttrValue df_attr_value;

  386.     df_attr_value.set_s(TENSORFLOWF_TENSOR_NCHW);

  387.     (*node_attr_map)[TENSORFLOW_ATTR_DATA_FORMAT] = df_attr_value;

  388. 

  389.     // 设置 tensor 属性

  390.     domi::tensorflow::AttrValue value_attr_value;

  391.     ::tensorflow::TensorProto* tensor = value_attr_value.mutable_tensor();

  392.     ::tensorflow::TensorShapeProto* tensor_shape = tensor->mutable_tensor_shape();

  393.     tensor_shape->clear_dim();

  394.     ::tensorflow::TensorShapeProto_Dim* dim = tensor_shape->add_dim();

  395.     dim->set_name("tensor dim");

  396.     dim->set_size(1);

  397. 

  398.     if (index == 0) {

  399.         tensor->set_dtype(domi::tensorflow::DT_FLOAT);

  400.         float *addr = new float[1];

  401.         *addr = 1.0;

  402.         tensor->set_tensor_content((void *)addr, sizeof(float));

  403.         (*node_attr_map)[TENSORFLOW_ATTR_VALUE] = value_attr_value;

  404.         delete[] addr;

  405.     } else if (index == 1) {

  406.         tensor->set_dtype(domi::tensorflow::DT_INT32);

  407.         int32_t *addr = new int32_t[1];

  408.         *addr = 1;

  409.         tensor->set_tensor_content((void *)addr, sizeof(int32_t));

  410.         (*node_attr_map)[TENSORFLOW_ATTR_VALUE] = value_attr_value;

  411.         delete[] addr;

  412.     } else if (index == 2) {

  413.         tensor->set_dtype(tensorflow::DT_HALF);

  414.         tensor->add_half_val(1);

  415.         (*node_attr_map)[TENSORFLOW_ATTR_VALUE] = value_attr_value;

  416.     }

  417.     return nodeDef;

  418.   }

  419. 

  420.   NodeDef *MallocNodeDef(const string &name, const string &type) {

  421.     NodeDef* node_def = new (std::nothrow) NodeDef();

  422.     if (node_def != nullptr) {

  423.       node_def->set_name(name);

  424.       node_def->set_op(type);

  425.     }

  426.     return node_def;

  427.   }

  428. 

  429.   void GenOriginNodeDef(ge::TensorFlowModelParser *tensorflow_parser, vector<string> &node_name_list) {

  430.     NodeDef* pre_node_a = MallocNodeDef("pre_node_a", "Const");

  431.     EXPECT_NE(pre_node_a, nullptr);

  432.     {

  433.       google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* node_attr_map = pre_node_a->mutable_attr();

  434.       tensorflow::AttrValue attr_dtype;

  435.       attr_dtype.set_type(tensorflow::DT_FLOAT);

  436.       (*node_attr_map)["dtype"] = attr_dtype;

  437.       tensorflow::AttrValue attr_value;

  438.       tensorflow::TensorProto* tensor = attr_value.mutable_tensor();

  439.       tensor->add_bool_val(true);

  440.       tensor->set_dtype(tensorflow::DT_BOOL);

  441.       (*node_attr_map)["value"] = attr_value;

  442.     }

  443.     tensorflow_parser->nodedef_map_["pre_node_a"] = pre_node_a;

  444.     node_name_list.push_back("pre_node_a");

  445. 

  446.     NodeDef* pre_node_ctrl_in = MallocNodeDef("pre_node_ctrl_in", "Const");

  447.     EXPECT_NE(pre_node_ctrl_in, nullptr);

  448.     {

  449.       ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* node_attr_map = pre_node_ctrl_in->mutable_attr();

  450.       tensorflow::AttrValue attr_dtype;

  451.       attr_dtype.set_type(tensorflow::DT_FLOAT);

  452.       (*node_attr_map)["dtype"] = attr_dtype;

  453.       tensorflow::AttrValue attr_value;

  454.       tensorflow::TensorProto* tensor = attr_value.mutable_tensor();

  455.       tensor->add_bool_val(true);

  456.       tensor->set_dtype(tensorflow::DT_BOOL);

  457.       (*node_attr_map)["value"] = attr_value;

  458.     }

  459.     tensorflow_parser->nodedef_map_["pre_node_ctrl_in"] = pre_node_ctrl_in;

  460.     node_name_list.push_back("pre_node_ctrl_in");

  461. 

  462.     NodeDef* post_node_b = MallocNodeDef("post_node_b", "Identity");

  463.     EXPECT_NE(post_node_b, nullptr);

  464.     tensorflow_parser->nodedef_map_["post_node_b"] = post_node_b;

  465.     node_name_list.push_back("post_node_b");

  466. 

  467.     NodeDef* post_node_c = MallocNodeDef("post_node_c", "Identity");

  468.     EXPECT_NE(post_node_c, nullptr);

  469.     tensorflow_parser->nodedef_map_["post_node_c"] = post_node_c;

  470.     node_name_list.push_back("post_node_c");

  471. 

  472.     NodeDef* post_node_d = MallocNodeDef("post_node_d", "Identity");

  473.     EXPECT_NE(post_node_d, nullptr);

  474.     tensorflow_parser->nodedef_map_["post_node_d"] = post_node_d;

  475.     node_name_list.push_back("post_node_d");

  476.   }

  477. 

  478.   void FreeNodeDefMap(ge::TensorFlowModelParser *tensorflow_parser, set<string> &malloc_node_name_list) {

  479.     for (auto &item : tensorflow_parser->nodedef_map_) {

  480.       if (item.second != nullptr && malloc_node_name_list.count(item.first) > 0) {

  481.         delete (item.second);

  482.         item.second = nullptr;

  483.       }

  484.     }

  485.   }

  486. 

  487.   void GenFusionScopesResult(shared_ptr<ScopeGraph> &scope_graph, FusionScopesResult *fusion_rlt,

  488.                             const string &fusion_op_name) {

  489.     if (fusion_rlt == nullptr) {

  490.       return;

  491.     }

  492.     fusion_rlt->InsertInputs("scope_node_1", {0});   // scope input 0

  493.     fusion_rlt->InsertOutputs("scope_node_m", {0});  // scope output 0

  494.     fusion_rlt->InsertOutputs("scope_node_n", {1});  // scope output 1

  495. 

  496.     fusion_rlt->SetType(ge::kScopeToMultiNodes);

  497.     fusion_rlt->SetName(fusion_op_name);

  498.     fusion_rlt->SetDescription("Description for fusion node");

  499. 

  500.     // Add inner nodes in sequence.

  501.     auto node1 = fusion_rlt->AddInnerNode("inner_node_1", "Unique");  // add inner node1

  502.     CHECK_INNER_NODE_CONDITION(node1 != nullptr, fusion_rlt);

  503.     auto ret = node1

  504.       ->InsertInput(ge::kInputFromFusionScope, 0)   // Input from 0th of boundary (a)

  505.       .InsertOutput(ge::kOutputToFusionScope, 0)                 // Output to 0th of boundary (b)

  506.       .InsertOutput("inner_node_2", 0)  // Output to input 0th of internal node 2

  507.       .BuildInnerNode();                                         // Construct an internal Operator

  508.     CHECK_INNER_NODE_CONDITION(ret == ge::GRAPH_SUCCESS, fusion_rlt);

  509.     string str_val = "This is a string.";

  510.     node1->MutableOperator()->SetAttr("key1", 2);        // Set integer attribute

  511.     node1->MutableOperator()->SetAttr("key2", str_val);  // Set the string attribute

  512.     node1->MutableOperator()->SetAttr("key3", true);     // Set boolean attribute

  513. 

  514.     auto node2 = fusion_rlt->AddInnerNode("inner_node_2", "Identity");  // add inner node2

  515.     CHECK_INNER_NODE_CONDITION(node2 != nullptr, fusion_rlt);

  516.     ret = node2

  517.       ->InsertInput("inner_node_1", 1)  // The input comes from the 1st output of internal node 1

  518.       .InsertOutput("inner_node_3", 0)  // Output to input 0th of internal node 3

  519.       .BuildInnerNode();

  520.     CHECK_INNER_NODE_CONDITION(ret == ge::GRAPH_SUCCESS, fusion_rlt);

  521.     node2->SetInputFormat("x", "NHWC");

  522.     node2->SetOutputFormat("y", "NHWC");

  523. 

  524.     auto node3 = fusion_rlt->AddInnerNode("inner_node_3", "Identity");  // add inner node3

  525.     CHECK_INNER_NODE_CONDITION(node3 != nullptr, fusion_rlt);

  526.     ret = node3

  527.       ->InsertInput("inner_node_2", 0)  // The input comes from the 0th output of internal node 2

  528.       .InsertOutput(ge::kOutputToFusionScope, 1)     // Output to 1st of boundary (c)

  529.       .BuildInnerNode();

  530.     CHECK_INNER_NODE_CONDITION(ret == ge::GRAPH_SUCCESS, fusion_rlt);

  531. 

  532.     scope_graph->impl_->AddFusionScopesResult(fusion_rlt);

  533.   }

  534. 

  535.   void GenOriginContext(ge::TensorFlowModelParser *tensorflow_parser, const string &fusion_op_name) {

  536.     // op_node_context for fusion op

  537.     ge::OpNodeContext op_node_context;

  538.     op_node_context.input_map["pre_node_a"].push_back({0, 0});

  539.     op_node_context.input_map["pre_node_ctrl_in"].push_back({-1, -1}); // ctrl edges

  540.     op_node_context.output_map["post_node_b"].push_back({0, 0});

  541.     op_node_context.output_map["post_node_c"].push_back({1, 0});

  542.     op_node_context.output_map["post_node_d"].push_back({-1, -1});

  543.     op_node_context.output_map["_Retval"].push_back({0, 1});

  544.     // ctrl edges

  545.     tensorflow_parser->op_node_context_map_[fusion_op_name] = op_node_context;

  546.     tensorflow_parser->SaveEdgesControlInfo(fusion_op_name, -1);

  547. 

  548.     // op_node_context for pre_node_a

  549.     ge::OpNodeContext op_node_context_a;

  550.     op_node_context_a.output_map[fusion_op_name].push_back({0, 0});

  551.     tensorflow_parser->op_node_context_map_["pre_node_a"] = op_node_context_a;

  552. 

  553.     // op_node_context for pre_node_ctrl_in

  554.     ge::OpNodeContext op_node_context_ctrl_in;

  555.     op_node_context_ctrl_in.output_map[fusion_op_name].push_back({-1, -1}); // ctrl edges

  556.     tensorflow_parser->op_node_context_map_["pre_node_ctrl_in"] = op_node_context_ctrl_in;

  557. 

  558.     // op_node_context for post_node_b

  559.     ge::OpNodeContext op_node_context_b;

  560.     op_node_context_b.input_map[fusion_op_name].push_back({0, 0});

  561.     tensorflow_parser->op_node_context_map_["post_node_b"] = op_node_context_b;

  562. 

  563.     // op_node_context for post_node_c

  564.     ge::OpNodeContext op_node_context_c;

  565.     op_node_context_c.output_map["post_node_d"].push_back({0, 0});

  566.     tensorflow_parser->op_node_context_map_["post_node_c"] = op_node_context_c;

  567. 

  568.     // op_node_context for post_node_d

  569.     ge::OpNodeContext op_node_context_d;

  570.     op_node_context_d.input_map[fusion_op_name].push_back({-1, -1}); // ctrl edges

  571.     tensorflow_parser->op_node_context_map_["post_node_d"] = op_node_context_d;

  572. 

  573.     // op_node_context for Retval

  574.     ge::OpNodeContext op_node_context_Retval;

  575.     op_node_context_d.input_map["post_node_d"].push_back({-1, -1});

  576.     op_node_context_c.output_map["fusion_op_name"].push_back({0,1});

  577.     tensorflow_parser->op_node_context_map_["_Retval"] = op_node_context_Retval;

  578.     tensorflow_parser->SaveEdgesControlInfo("op_node_context_Retval", -1);

  579. 

  580.     string fusion_op_type = ge::kScopeToMultiNodes;

  581.     string description = "fusion op description";

  582.     tensorflow_parser->fusion_op_type_map_[fusion_op_name].push_back(fusion_op_type);

  583.     tensorflow_parser->fusion_op_type_map_[fusion_op_name].push_back(description);

  584.   }

  585. 

  586.   void register_tbe_op() {

  587.     std::vector<OpRegistrationData> registrationDatas = OpRegistry::Instance()->registrationDatas;

  588.     for (OpRegistrationData reg_data : registrationDatas) {

  589.       domi::OpRegTbeParserFactory::Instance()->Finalize(reg_data);

  590.       OpRegistry::Instance()->Register(reg_data);

  591.     }

  592.     OpRegistry::Instance()->registrationDatas.clear();

  593.   }

  594. 

  595.   NodeDef *initNodeDef_axis_dims() {

  596.     NodeDef *nodeDef = new NodeDef();

  597.     google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map = nodeDef->mutable_attr();

  598. 

  599.     //设置T属性

  600.     domi::tensorflow::AttrValue dtype_attr_value ;

  601.     dtype_attr_value.set_type(domi::tensorflow::DT_FLOAT);

  602.     (*node_attr_map)[TENSORFLOW_ATTR_T] = dtype_attr_value;

  603. 

  604.     //设置strides属性

  605.     domi::tensorflow::AttrValue axis_attr_value;

  606.     ::tensorflow::AttrValue_ListValue* list = axis_attr_value.mutable_list();

  607.     list->add_i(1);

  608.     list->add_i(2);

  609.     (*node_attr_map)[ge::SQUEEZE_ATTR_AXIS] = axis_attr_value;

  610.     (*node_attr_map)[ge::SQUEEZE_ATTR_DIMS] = axis_attr_value;

  611. 

  612.     return nodeDef;

  613.   }

  614. 

  615.   NodeDef *initNodeDef_dims() {

  616.     NodeDef *nodeDef = new NodeDef();

  617.     ::google::protobuf::Map<std::string, tensorflow::AttrValue > *node_attr_map = nodeDef->mutable_attr();

  618. 

  619.     //设置T属性

  620.     domi::tensorflow::AttrValue dtype_attr_value ;

  621.     dtype_attr_value.set_type(domi::tensorflow::DT_FLOAT);

  622.     (*node_attr_map)[TENSORFLOW_ATTR_T] = dtype_attr_value;

  623. 

  624.     //设置strides属性

  625.     domi::tensorflow::AttrValue axis_attr_value;

  626.     ::tensorflow::AttrValue_ListValue* list = axis_attr_value.mutable_list();

  627.     list->add_i(1);

  628.     list->add_i(2);

  629.     (*node_attr_map)[ge::SQUEEZE_ATTR_DIMS] = axis_attr_value;

  630.     return nodeDef;

  631.   }

  632. 

  633.   void CreateOpDef(const string& _name, const string& _type, ge::OpDescPtr opDef) {

  634.     tensorflow::OpDef tsOpDef;

  635.     tsOpDef.set_name(_name);

  636.     tensorflow::OpDef_ArgDef* outArgDef = tsOpDef.add_output_arg();

  637.     outArgDef->set_name(_name);

  638.     outArgDef->set_description("outArgDef");

  639.     outArgDef->set_type((tensorflow::DataType)3);

  640. 

  641.     if ((_name == "A") || (_name == "B")) {

  642.       tensorflow::OpDef_ArgDef* argDef1 = tsOpDef.add_output_arg();

  643.       string name = _name+"t";

  644.       argDef1->set_name(name);

  645.       argDef1->set_description("this is a test 2");

  646.       argDef1->set_type((tensorflow::DataType)3);

  647.     }

  648.     if ((_name == "C") ) {

  649.       outArgDef->set_number_attr("num");

  650.     }

  651.     if ((_name == "D") ) {

  652.       outArgDef->set_type_list_attr("type_list");

  653.     }

  654. 

  655.     string strTsOpDef;

  656.     tsOpDef.SerializeToString(&strTsOpDef);

  657.     ge::AttrUtils::SetStr(opDef, "op_def", strTsOpDef);

  658. 

  659.     tensorflow::NodeDef nodedef;

  660.     nodedef.set_name(_name);

  661.     nodedef.set_op(_name);

  662. 

  663.     string name("op_def");

  664.     tensorflow::AttrValue value;

  665.     value.set_s(strTsOpDef);

  666.     TensorFlowUtil::AddNodeAttr(name, value, &nodedef);

  667.     value.set_i(1);

  668.     TensorFlowUtil::AddNodeAttr("num", value, &nodedef);

  669.     value.mutable_list();

  670.     TensorFlowUtil::AddNodeAttr("type_list", value, &nodedef);

  671. 

  672.     string strNodeDef;

  673.     nodedef.SerializeToString(&strNodeDef);

  674.     ge::GeAttrValue::BYTES nodedefBytes;

  675.     nodedefBytes = ge::GeAttrValue::BYTES::CopyFrom((uint8_t*)strNodeDef.data(), strNodeDef.length());

  676.     ge::AttrUtils::SetBytes(opDef, "node_def", nodedefBytes);

  677. 

  678.     if ((_name== "S") || (_name == "K")) {

  679.       int index = 0;

  680. 

  681.       ge::AttrUtils::SetInt(opDef, "T", 1);

  682.       ge::AttrUtils::SetInt(opDef, "arg_index", index);

  683.       ge::AttrUtils::SetInt(opDef, "ret_index", index);

  684.     }

  685.   }

  686. 

  687.   ge::NodePtr AddNode(ge::ComputeGraphPtr graph, const string& _name, const string& _type,int32_t i_n, int32_t o_n) {

  688.     ge::OpDescPtr opDef = std::make_shared<ge::OpDesc>();

  689.     opDef->SetName(_name);

  690.     opDef->SetType(_type);

  691.     for(int32_t i = 0; i < i_n; i++) {

  692.       ge::GeTensorDesc input;

  693.       input.SetDataType((ge::DataType)1);

  694.       opDef->AddInputDesc(input);

  695.     }

  696. 

  697.     for(int32_t i = 0;i < o_n; i++) {

  698.       ge::GeTensorDesc output;

  699.       output.SetDataType((ge::DataType)1);

  700.       opDef->AddOutputDesc(output);

  701.     }

  702.     CreateOpDef(_name, _type, opDef);

  703.     return graph->AddNode(opDef);

  704.   }

  705. 

  706.   void MakeDagGraph(ge::ComputeGraphPtr graph, const string& input_node_type) {

  707.     ge::NodePtr node_s = AddNode(graph, "S", parser::DATA,1,1);

  708.     ge::NodePtr node_a = AddNode(graph, "A", "testa",1,2);

  709.     ge::NodePtr node_b = AddNode(graph, "B", "testb",1,2);

  710.     ge::NodePtr node_c = AddNode(graph, "C", "testc",1,1);

  711.     ge::NodePtr node_d = AddNode(graph, "D", "testd",1,1);

  712.     ge::NodePtr node_e = AddNode(graph, "E", "teste",1,1);

  713.     ge::NodePtr node_f = AddNode(graph, "F", "testf",1,1);

  714.     ge::NodePtr node_g = AddNode(graph, "G", "testg",2,1);

  715.     ge::NodePtr node_h = AddNode(graph, "H", "testh",1,1);

  716.     ge::NodePtr node_i = AddNode(graph, "I", "testi",1,1);

  717.     ge::NodePtr node_j = AddNode(graph, "J", "testj",2,1);

  718.     ge::NodePtr node_k = AddNode(graph, "K", parser::NETOUTPUT,1,1);

  719. 

  720.     ge::GraphUtils::AddEdge(node_s->GetOutDataAnchor(0), node_a->GetInDataAnchor(0));

  721.     ge::GraphUtils::AddEdge(node_a->GetOutDataAnchor(0), node_b->GetInDataAnchor(0));

  722.     ge::GraphUtils::AddEdge(node_a->GetOutDataAnchor(1), node_c->GetInDataAnchor(0));

  723.     ge::GraphUtils::AddEdge(node_b->GetOutDataAnchor(0), node_d->GetInDataAnchor(0));

  724.     ge::GraphUtils::AddEdge(node_b->GetOutDataAnchor(1), node_e->GetInDataAnchor(0));

  725.     ge::GraphUtils::AddEdge(node_c->GetOutDataAnchor(0), node_g->GetInDataAnchor(0));

  726.     ge::GraphUtils::AddEdge(node_d->GetOutDataAnchor(0), node_f->GetInDataAnchor(0));

  727.     ge::GraphUtils::AddEdge(node_e->GetOutDataAnchor(0), node_g->GetInDataAnchor(1));

  728.     ge::GraphUtils::AddEdge(node_f->GetOutDataAnchor(0), node_h->GetInDataAnchor(0));

  729.     ge::GraphUtils::AddEdge(node_g->GetOutDataAnchor(0), node_j->GetInDataAnchor(0));

  730.     ge::GraphUtils::AddEdge(node_h->GetOutDataAnchor(0), node_i->GetInDataAnchor(0));

  731.     ge::GraphUtils::AddEdge(node_i->GetOutDataAnchor(0), node_j->GetInDataAnchor(1));

  732.     ge::GraphUtils::AddEdge(node_j->GetOutDataAnchor(0), node_k->GetInDataAnchor(0));

  733.     ge::GraphUtils::AddEdge(node_h->GetOutControlAnchor(), node_j->GetInControlAnchor());

  734.   }

  735. 

  736.   void MakeGraph(const ComputeGraphPtr &root_graph, const string &name) {

  737.     root_graph->SetName(name);

  738.     ge::NodePtr data1 = AddNode(root_graph, name + "_input1", parser::DATA, 1, 1);

  739.     ge::NodePtr data2 = AddNode(root_graph, name + "_input2", parser::DATA, 1, 1);

  740.     ge::NodePtr add = AddNode(root_graph, name + "_add", parser::ADD, 2, 1);

  741.     ge::NodePtr net_output = AddNode(root_graph, name + "_net_output", parser::NETOUTPUT, 1, 1);

  742.     ge::GraphUtils::AddEdge(data1->GetOutDataAnchor(0), add->GetInDataAnchor(0));

  743.     ge::GraphUtils::AddEdge(data2->GetOutDataAnchor(0), add->GetInDataAnchor(1));

  744.     ge::GraphUtils::AddEdge(add->GetOutDataAnchor(0), net_output->GetInDataAnchor(0));

  745.   }

  746. 

  747.   void ChangeDataType(tensorflow::NodeDef* node_tf, int32_t data_type)

  748.   {

  749.     domi::tensorflow::AttrValue input_attr_value;

  750.     google::protobuf::Map<std::string, tensorflow::AttrValue>* attr = node_tf->mutable_attr();

  751.     google::protobuf::Map<std::string, tensorflow::AttrValue>::const_iterator it = attr->find(ge::ATTR_NAME_INPUT_TENSOR_DESC);

  752.     if (it != attr->end()) {

  753.         input_attr_value = it->second;

  754.     }

  755.     (*attr)[ge::ATTR_NAME_INPUT_TENSOR_DESC] = input_attr_value;

  756.   }

  757. 

  758.   NodeDef* AddGraphNode(GraphDef *graph, string name, string optype, string input) 

  759.   {

  760.     NodeDef *node_def = graph->add_node();

  761.     node_def->set_name(name);

  762.     node_def->set_op(optype);

  763.     node_def->add_input(input);

  764.     return node_def;

  765.   }

  766. 

  767.   ge::ComputeGraphPtr build_graph(bool with_leaf_node = false)

  768.   {

  769.       ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("default");

  770.       ge::OpDescPtr data_op = std::make_shared<ge::OpDesc>();

  771.       data_op->SetType(parser::DATA);

  772.       data_op->SetName("Data1");

  773.       data_op->AddInputDesc(ge::GeTensorDesc());

  774.       data_op->AddOutputDesc(ge::GeTensorDesc());

  775.       ge::NodePtr data1 = graph->AddNode(data_op);

  776. 

  777.       ge::OpDescPtr relu_op1 = std::make_shared<ge::OpDesc>();

  778.       relu_op1->SetType(parser::ACTIVATION);

  779.       relu_op1->SetName("Relu1");

  780.       relu_op1->AddInputDesc(ge::GeTensorDesc());

  781.       relu_op1->AddOutputDesc(ge::GeTensorDesc());

  782.       ge::NodePtr relu1 = graph->AddNode(relu_op1);

  783. 

  784.       ge::OpDescPtr relu_op2 = std::make_shared<ge::OpDesc>();

  785.       relu_op2->SetType(parser::RELU);

  786.       relu_op2->SetName("Relu2");

  787.       relu_op2->AddInputDesc(ge::GeTensorDesc());

  788.       relu_op2->AddOutputDesc(ge::GeTensorDesc());

  789.       relu_op2->AddOutputDesc(ge::GeTensorDesc());

  790.       ge::NodePtr relu2 = graph->AddNode(relu_op2);

  791. 

  792.       ge::OpDescPtr relu_op3 = std::make_shared<ge::OpDesc>();

  793.       relu_op3->SetType(parser::ACTIVATION);

  794.       relu_op3->SetName("Relu3");

  795.       relu_op3->AddInputDesc(ge::GeTensorDesc());

  796.       relu_op3->AddOutputDesc(ge::GeTensorDesc());

  797.       ge::NodePtr relu3;

  798.       if (with_leaf_node == true) {

  799.           relu3 = graph->AddNode(relu_op3);

  800.       }

  801. 

  802.       ge::OpDescPtr mul_op = std::make_shared<ge::OpDesc>();

  803.       mul_op->SetType(parser::MUL);

  804.       mul_op->SetName("Mul");

  805.       mul_op->AddInputDesc(ge::GeTensorDesc());

  806.       mul_op->AddInputDesc(ge::GeTensorDesc());

  807.       mul_op->AddOutputDesc(ge::GeTensorDesc());

  808.       mul_op->AddOutputDesc(ge::GeTensorDesc());

  809.       mul_op->AddOutputDesc(ge::GeTensorDesc());

  810.       mul_op->AddOutputDesc(ge::GeTensorDesc());

  811.       ge::NodePtr mul = graph->AddNode(mul_op);

  812. 

  813.       ge::OpDescPtr mul_op1 = std::make_shared<ge::OpDesc>();

  814.       mul_op1->SetType(parser::MUL);

  815.       mul_op1->SetName("Mul1");

  816.       mul_op1->AddInputDesc(ge::GeTensorDesc());

  817.       mul_op1->AddInputDesc(ge::GeTensorDesc());

  818.       mul_op1->AddOutputDesc(ge::GeTensorDesc());

  819.       ge::NodePtr mul1 = graph->AddNode(mul_op1);

  820. 

  821.       ge::OpDescPtr mul_op2 = std::make_shared<ge::OpDesc>();

  822.       mul_op2->SetType(parser::MUL);

  823.       mul_op2->SetName("Mul2");

  824.       mul_op2->AddInputDesc(ge::GeTensorDesc());

  825.       mul_op2->AddInputDesc(ge::GeTensorDesc());

  826.       mul_op2->AddOutputDesc(ge::GeTensorDesc());

  827.       ge::NodePtr mul2 = graph->AddNode(mul_op2);

  828. 

  829.       ge::OpDescPtr fc_op = std::make_shared<ge::OpDesc>();

  830.       fc_op->SetType(parser::FULL_CONNECTION);

  831.       fc_op->SetName("FullConnection");

  832.       fc_op->AddInputDesc(ge::GeTensorDesc());

  833.       fc_op->AddOutputDesc(ge::GeTensorDesc());

  834.       fc_op->AddOutputDesc(ge::GeTensorDesc());

  835.       ge::NodePtr fc = graph->AddNode(fc_op);

  836. 

  837.       ge::GraphUtils::AddEdge(data1->GetOutDataAnchor(0), relu1->GetInDataAnchor(0));

  838.       ge::GraphUtils::AddEdge(relu1->GetOutDataAnchor(0), fc->GetInDataAnchor(0));

  839.       ge::GraphUtils::AddEdge(fc->GetOutDataAnchor(0), relu2->GetInDataAnchor(0));

  840.       if (with_leaf_node == true) {

  841.           ge::GraphUtils::AddEdge(fc->GetOutDataAnchor(1), relu3->GetInDataAnchor(0));

  842.       }

  843.       ge::GraphUtils::AddEdge(relu2->GetOutDataAnchor(0), mul->GetInDataAnchor(0));

  844.       ge::GraphUtils::AddEdge(relu2->GetOutDataAnchor(1), mul->GetInDataAnchor(1));

  845.       ge::GraphUtils::AddEdge(mul->GetOutDataAnchor(0), mul1->GetInDataAnchor(0));

  846.       ge::GraphUtils::AddEdge(mul->GetOutDataAnchor(1), mul1->GetInDataAnchor(1));

  847.       ge::GraphUtils::AddEdge(mul->GetOutDataAnchor(2), mul2->GetInDataAnchor(0));

  848.       ge::GraphUtils::AddEdge(mul->GetOutDataAnchor(3), mul2->GetInDataAnchor(1));

  849. 

  850.       return graph;

  851.   }

  852. }

  853. 

  854. namespace {

  855. REG_OP(Data)

  856.     .INPUT(x, TensorType::ALL())

  857.     .OUTPUT(y, TensorType::ALL())

  858.     .ATTR(index, Int, 0)

  859.     .OP_END_FACTORY_REG(Data)

  860. 

  861. REG_OP(Add)

  862.     .INPUT(x1, TensorType({DT_FLOAT, DT_INT32, DT_INT64, DT_FLOAT16, DT_INT16,

  863.                            DT_INT8, DT_UINT8, DT_DOUBLE, DT_COMPLEX128,

  864.                            DT_COMPLEX64, DT_STRING}))

  865.     .INPUT(x2, TensorType({DT_FLOAT, DT_INT32, DT_INT64, DT_FLOAT16, DT_INT16,

  866.                            DT_INT8, DT_UINT8, DT_DOUBLE, DT_COMPLEX128,

  867.                            DT_COMPLEX64, DT_STRING}))

  868.     .OUTPUT(y, TensorType({DT_FLOAT, DT_INT32, DT_INT64, DT_FLOAT16, DT_INT16,

  869.                            DT_INT8, DT_UINT8, DT_DOUBLE, DT_COMPLEX128,

  870.                            DT_COMPLEX64, DT_STRING}))

  871.     .OP_END_FACTORY_REG(Add)

  872. }

  873. 

  874. static Status FusionParserParams(const std::vector<const google::protobuf::Message *> inside_nodes, ge::Operator &op) {

  875.   return domi::SUCCESS;

  876. }

  877. 

  878. static MemBuffer* MemBufferFromFile(const char *path)

  879. {

  880.     char path_temp[PATH_MAX + 1] = {0x00};

  881.     if(strlen(path) > PATH_MAX || nullptr == realpath(path, path_temp)) {

  882.         return nullptr;

  883.     }

  884.     FILE *fp = fopen(path_temp, "r+");

  885.     if (fp == nullptr) {

  886.         return nullptr;

  887.     }

  888. 

  889.     // get model file length

  890.     if (0 != fseek(fp, 0, SEEK_END)) {

  891.         fclose(fp);

  892.         return nullptr;

  893.     }

  894.     long file_length = ftell(fp);

  895.     if (fseek(fp, 0, SEEK_SET)) {

  896.         fclose(fp);

  897.         return nullptr;

  898.     }

  899.     if (file_length <= 0) {

  900.         fclose(fp);

  901.         return nullptr;

  902.     }

  903. 

  904.     // alloc model buffer

  905.     void *data = malloc((unsigned int)file_length);

  906.     if (!data) {

  907.         fclose(fp);

  908.         return nullptr;

  909.     }

  910. 

  911.     // read file into memory

  912.     uint32_t read_size = (uint32_t)fread(data, 1, (unsigned int)file_length, fp);

  913. 

  914.     // check if read success

  915.     if ((long)read_size != file_length) {

  916.         free(data);

  917.         data = nullptr;

  918.         fclose(fp);

  919.         return nullptr;

  920.     }

  921. 

  922.     // close model file

  923.     fclose(fp);

  924. 

  925.     // create an MemBuffer

  926.     MemBuffer* membuf = new MemBuffer();

  927.     if (!membuf) {

  928.         free(data);

  929.         data = nullptr;

  930.         return nullptr;

  931.     }

  932.     membuf->data = malloc((unsigned int)read_size);

  933. 

  934.     // set size && data

  935.     membuf->size = (uint32_t)read_size;

  936.     memcpy((char*)membuf->data, (char*)data, read_size);

  937.     free(data);

  938.     return membuf;

  939. }

  940. 

  941. ///        placeholder0  placeholder1

  942. ///          |       /\  /\       |

  943. ///          |      /  \/  \      |

  944. ///          |     /   /\   \     |

  945. ///          |     |  /  \  |     |

  946. ///          |     add0   mul0    |

  947. ///          |     /     /c | \   |

  948. ///            mul1 --- /   |   add1

  949. ///              \          |    |

  950. ///               \ ---- add2    |

  951. ///                      |       |

  952. ///                    retval0 retval1

  953. 

  954. void CreateGraphDef(domi::tensorflow::GraphDef &graph_def) {

  955.   // 1. add node

  956.   auto placeholder0 = graph_def.add_node();

  957.   auto placeholder1 = graph_def.add_node();

  958.   auto add0 = graph_def.add_node();

  959.   auto add1 = graph_def.add_node();

  960.   auto mul0 = graph_def.add_node();

  961.   auto mul1 = graph_def.add_node();

  962.   auto add2 = graph_def.add_node();

  963.   auto retval0 = graph_def.add_node();

  964.   auto retval1 = graph_def.add_node();

  965.   auto softmax0 = graph_def.add_node();

  966.   auto softmax1 = graph_def.add_node();

  967. 

  968.   // 2. set info

  969.   placeholder0->set_name("placeholder0");

  970.   placeholder0->set_op("PlaceHolder");

  971.   placeholder1->set_name("placeholder1");

  972.   placeholder1->set_op("PlaceHolder");

  973. 

  974.   add0->set_name("add0");

  975.   add0->set_op("Add");

  976.   add1->set_name("add1");

  977.   add1->set_op("Add");

  978.   add2->set_name("add2");

  979.   add2->set_op("Add");

  980. 

  981.   mul0->set_name("mul0");

  982.   mul0->set_op("Mul");

  983.   mul1->set_name("mul1");

  984.   mul1->set_op("Mul");

  985. 

  986.   retval0->set_name("retval0");

  987.   retval0->set_op("_RetVal");

  988.   retval1->set_name("retval1");

  989.   retval1->set_op("_RetVal");

  990. 

  991.   retval0->set_name("retval0");

  992.   retval0->set_op("_RetVal");

  993.   retval1->set_name("retval1");

  994.   retval1->set_op("_RetVal");

  995. 

  996.   softmax0->set_name("Softmax0");

  997.   softmax0->set_op("Softmax");

  998.   softmax1->set_name("Softmax1");

  999.   softmax1->set_op("Softmax");

  1000. 

  1001.   // 3. add edges

  1002.   add0->add_input("placeholder0");

  1003.   add0->add_input("placeholder1");

  1004. 

  1005.   mul0->add_input("placeholder0");

  1006.   mul0->add_input("placeholder1");

  1007. 

  1008.   mul1->add_input("placeholder0");

  1009.   mul1->add_input("add0");

  1010.   mul1->add_input("^mul0");

  1011. 

  1012.   add1->add_input("mul0");

  1013.   add1->add_input("placeholder1");

  1014. 

  1015.   add2->add_input("mul1");

  1016.   add2->add_input("mul0");

  1017. 

  1018.   retval0->add_input("add2:0");

  1019.   retval1->add_input("add1:0");

  1020. 

  1021.   softmax0->add_input("add3:0");

  1022.   softmax0->add_input("add2:0");

  1023. }

  1024. 

  1025. TEST_F(STestTensorflowParser, tensorflow_parser_success) {

  1026.   RegisterCustomOp();

  1027. 

  1028.   std::string case_dir = __FILE__;

  1029.   ParserOperator unused("Add");

  1030.   case_dir = case_dir.substr(0, case_dir.find_last_of("/"));

  1031.   std::string model_file = case_dir + "/origin_models/tf_add.pb";

  1032.   std::map<ge::AscendString, ge::AscendString> parser_params = {

  1033.       {ge::AscendString(ge::ir_option::INPUT_DATA_NAMES), ge::AscendString("Placeholder,Placeholder_1")},

  1034.   };

  1035.   ge::Graph graph;

  1036.   auto ret = ge::aclgrphParseTensorFlow(model_file.c_str(), parser_params, graph);

  1037.   ASSERT_EQ(ret, SUCCESS);

  1038.   ge::ComputeGraphPtr compute_graph = ge::GraphUtils::GetComputeGraph(graph);

  1039.   auto output_nodes_info = compute_graph->GetGraphOutNodesInfo();

  1040.   ASSERT_EQ(output_nodes_info.size(), 1);

  1041.   EXPECT_EQ((output_nodes_info.at(0).first->GetName()), "add_test_1");

  1042.   EXPECT_EQ((output_nodes_info.at(0).second), 0);

  1043.   auto &net_out_name = ge::GetParserContext().net_out_nodes;

  1044.   ASSERT_EQ(net_out_name.size(), 1);

  1045.   EXPECT_EQ(net_out_name.at(0), "add_test_1:0");

  1046. }

  1047. 

  1048. TEST_F(STestTensorflowParser, tensorflow_parser_failed_for_input_data_names_error) {

  1049.   RegisterCustomOp();

  1050. 

  1051.   std::string case_dir = __FILE__;

  1052.   ParserOperator unused("Add");

  1053.   case_dir = case_dir.substr(0, case_dir.find_last_of("/"));

  1054.   std::string model_file = case_dir + "/origin_models/tf_add.pb";

  1055.   std::map<ge::AscendString, ge::AscendString> parser_params = {

  1056.     {ge::AscendString(ge::ir_option::INPUT_DATA_NAMES), ge::AscendString("Placeholder_1,Placeholder_3")},

  1057.   };

  1058.   ge::Graph graph;

  1059.   auto ret = ge::aclgrphParseTensorFlow(model_file.c_str(), parser_params, graph);

  1060.   ASSERT_EQ(ret, ge::GRAPH_FAILED);

  1061. }

  1062. 

  1063. TEST_F(STestTensorflowParser, tensorflow_model_Failed) {

  1064.   ge::Graph graph;

  1065.   std::string caseDir = __FILE__;

  1066.   std::size_t idx = caseDir.find_last_of("/");

  1067.   caseDir = caseDir.substr(0, idx);

  1068. 

  1069.   std::string modelFile = caseDir + "/origin_models/model.pb";

  1070.   auto status = ge::aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1071.   EXPECT_EQ(status, ge::SUCCESS);

  1072. 

  1073.   modelFile = caseDir + "/origin_models/test_depth_wise_conv2d.pb";

  1074.   status = ge::aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1075.   EXPECT_EQ(status, ge::GRAPH_FAILED);

  1076. }

  1077. 

  1078. TEST_F(STestTensorflowParser, tensorflow_model_not_exist) {

  1079.   ge::Graph graph;

  1080.   std::string caseDir = __FILE__;

  1081.   std::size_t idx = caseDir.find_last_of("/");

  1082.   caseDir = caseDir.substr(0, idx);

  1083. 

  1084.   // model file is not exist

  1085.   std::string modelFile = caseDir + "/origin_models/conv2d_explicit1_pad.pb";

  1086.   auto status = ge::aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1087.   EXPECT_EQ(status, ge::GRAPH_FAILED);

  1088. }

  1089. 

  1090. TEST_F(STestTensorflowParser, parser_tensorflow_model) {

  1091.   std::string caseDir = __FILE__;

  1092.   std::size_t idx = caseDir.find_last_of("/");

  1093.   caseDir = caseDir.substr(0, idx);

  1094.   std::string modelFile = caseDir + "/origin_models/tf_add.pb";

  1095.   const char *model_file = modelFile.c_str();

  1096.   std::string op_name = "ge_ascend_irgraph";

  1097.   ge::Graph graph(op_name);

  1098. 

  1099.   std::map<ge::AscendString, ge::AscendString> parser_options = {

  1100.     {ge::AscendString(ge::ir_option::INPUT_FORMAT), ge::AscendString("NHWC")},

  1101.   };

  1102.   auto ret_graph = ge::aclgrphParseTensorFlow(model_file, parser_options, graph);

  1103.   EXPECT_EQ(ret_graph, ge::FAILED);

  1104. 

  1105.   // parser tensorflow model out_node_size is equal to index

  1106.   string graph_name;

  1107.   AclGraphParserUtil acl_graph_parse_util;

  1108.   std::map<AscendString, AscendString> out_nodes_with_node_and_index = {

  1109.     {AscendString(ge::ir_option::OUT_NODES), AscendString("Placeholder:0;Placeholder_1:1")}};

  1110.   ParerSTestsUtils::ClearParserInnerCtx();

  1111.   auto ret = acl_graph_parse_util.ParseParamsBeforeGraph(out_nodes_with_node_and_index, graph_name);

  1112.   ret_graph = ge::aclgrphParseTensorFlow(model_file, graph);

  1113.   EXPECT_EQ(ret_graph, domi::FAILED);

  1114. 

  1115.   // parser tensorflow model success

  1116.   modelFile = caseDir + "/origin_models/model.pb";

  1117.   model_file = modelFile.c_str();

  1118.   out_nodes_with_node_and_index = {{AscendString(ge::ir_option::OUT_NODES), AscendString("x:0;y:0")}};

  1119.   ParerSTestsUtils::ClearParserInnerCtx();

  1120.   ret = acl_graph_parse_util.ParseParamsBeforeGraph(out_nodes_with_node_and_index, graph_name);

  1121.   ret_graph = ge::aclgrphParseTensorFlow(model_file, graph);

  1122.   EXPECT_EQ(ret_graph, domi::SUCCESS);

  1123. }

  1124. 

  1125. TEST_F(STestTensorflowParser, tensorflow_parser_to_json)

  1126. {

  1127.   TensorFlowModelParser modelParser;

  1128.   std::string caseDir = __FILE__;

  1129.   std::size_t idx = caseDir.find_last_of("/");

  1130.   caseDir = caseDir.substr(0, idx);

  1131.   std::string modelFile = caseDir + "/origin_models/tf_add.pb";

  1132.   std::string jsonFile = caseDir + "/origin_models/test.json";

  1133.   const char *model_file = modelFile.c_str();

  1134.   const char *json_file = jsonFile.c_str();

  1135.   Status ret = modelParser.ToJson(model_file, json_file);

  1136.   EXPECT_EQ(ret, SUCCESS);

  1137. }

  1138. 

  1139. TEST_F(STestTensorflowParser, tensorflow_parserfrommemory_failed)

  1140. {

  1141.   TensorFlowModelParser modelParser;

  1142.   std::string caseDir = __FILE__;

  1143.   std::size_t idx = caseDir.find_last_of("/");

  1144.   caseDir = caseDir.substr(0, idx);

  1145.   std::string modelFile = caseDir + "/origin_models/tf_add.pb";

  1146.   uint32_t size = 1;

  1147.   ge::Graph graph;

  1148.   std::map<ge::AscendString, ge::AscendString> parser_params;

  1149.   Status ret = ge::aclgrphParseTensorFlow(modelFile.c_str(), parser_params, graph);

  1150.   ASSERT_EQ(ret, SUCCESS);

  1151. 

  1152.   parser_params = {{AscendString(ge::ir_option::OUT_NODES), AscendString("Placeholder:0;Placeholder_1:0")}};

  1153.   ret = ge::aclgrphParseTensorFlow(modelFile.c_str(), parser_params, graph);

  1154.   ge::ComputeGraphPtr compute_graph = ge::GraphUtils::GetComputeGraph(graph);

  1155.   ret = modelParser.ParseFromMemory(modelFile.c_str(), size, compute_graph);

  1156.   EXPECT_NE(ret, SUCCESS);

  1157. }

  1158. 

  1159. TEST_F(STestTensorflowParser, modelparser_parsefrommemory_success)

  1160. {

  1161.   std::string caseDir = __FILE__;

  1162.   std::size_t idx = caseDir.find_last_of("/");

  1163.   caseDir = caseDir.substr(0, idx);

  1164.   std::string modelFile = caseDir + "/origin_models/tf_add.pb";

  1165.   const char* tmp_tf_pb_model = modelFile.c_str();

  1166.   ge::Graph graph;

  1167.   std::map<ge::AscendString, ge::AscendString> parser_params;

  1168.   Status ret = ge::aclgrphParseTensorFlow(modelFile.c_str(), parser_params, graph);

  1169.   ASSERT_EQ(ret, SUCCESS);

  1170. 

  1171.   ge::ComputeGraphPtr compute_graph = ge::GraphUtils::GetComputeGraph(graph);

  1172.   TensorFlowModelParser modelParser;

  1173.   MemBuffer* memBuffer = MemBufferFromFile(tmp_tf_pb_model);

  1174.   PreChecker::Instance().HasError() == false;

  1175.   ret = modelParser.ParseFromMemory((char*)memBuffer->data, memBuffer->size, compute_graph);

  1176.   free(memBuffer->data);

  1177.   delete memBuffer;

  1178. }

  1179. 

  1180. TEST_F(STestTensorflowParser, weightsparser_parsefrommemory_success)

  1181. {

  1182.   std::string caseDir = __FILE__;

  1183.   std::size_t idx = caseDir.find_last_of("/");

  1184.   caseDir = caseDir.substr(0, idx);

  1185.   std::string modelFile = caseDir + "/origin_models/tf_add.pb";

  1186.   const char* tmp_tf_pb_model = modelFile.c_str();

  1187.   ge::Graph graph;

  1188.   std::map<ge::AscendString, ge::AscendString> parser_params;

  1189.   Status ret = ge::aclgrphParseTensorFlow(modelFile.c_str(), parser_params, graph);

  1190.   ASSERT_EQ(ret, SUCCESS);

  1191. 

  1192.   ge::ComputeGraphPtr compute_graph = ge::GraphUtils::GetComputeGraph(graph);

  1193.   auto weights_parser = domi::WeightsParserFactory::Instance()->CreateWeightsParser(domi::TENSORFLOW);

  1194.   MemBuffer* memBuffer = MemBufferFromFile(tmp_tf_pb_model);

  1195.   ret = weights_parser->ParseFromMemory((char*)memBuffer->data, memBuffer->size, compute_graph);

  1196.   free(memBuffer->data);

  1197.   delete memBuffer;

  1198.   EXPECT_EQ(SUCCESS, ret);

  1199. }

  1200. 

  1201. std::string getGraphCallbackV2(string subgraph_name)

  1202. {

  1203.   std::string caseDir = __FILE__;

  1204.   std::size_t idx = caseDir.find_last_of("/");

  1205.   caseDir = caseDir.substr(0, idx);

  1206.   subgraph_name = caseDir + "/origin_models/tf_add.pb";

  1207.   return subgraph_name;

  1208. }

  1209. 

  1210. TEST_F(STestTensorflowParser, parser_ParseProtoWithSubgraphV2)

  1211. {

  1212.   std::string caseDir = __FILE__;

  1213.   std::size_t idx = caseDir.find_last_of("/");

  1214.   caseDir = caseDir.substr(0, idx);

  1215.   const std::string root_proto = caseDir + "/origin_models/tf_add.pb";

  1216.   ge::Graph graph;

  1217.   std::map<ge::AscendString, ge::AscendString> parser_params;

  1218.   Status ret = ge::aclgrphParseTensorFlow(root_proto.c_str(), parser_params, graph);

  1219.   ASSERT_EQ(ret, SUCCESS);

  1220. 

  1221.   ge::ComputeGraphPtr root_graph = ge::GraphUtils::GetComputeGraph(graph);

  1222.   domi::GetGraphCallbackV2 callback(&getGraphCallbackV2);

  1223.   TensorFlowModelParser parser;

  1224.   ret = parser.ParseProtoWithSubgraph(root_proto, callback, root_graph);

  1225. }

  1226. 

  1227. TEST_F(STestTensorflowParser, parser_ConvertToGeDataType)

  1228. {

  1229.   // convert to ge type success

  1230.   const uint32_t type1 = domi::tensorflow::DataType::DT_FLOAT;

  1231.   TensorFlowModelParser parser;

  1232.   ge::DataType dataType = parser.ConvertToGeDataType(type1);

  1233.   ASSERT_EQ(dataType, ge::DataType::DT_FLOAT);

  1234. 

  1235.   const uint32_t type2 = 80; // invalid type

  1236.   dataType = parser.ConvertToGeDataType(type2);

  1237.   ASSERT_EQ(dataType, ge::DataType::DT_UNDEFINED);

  1238. }

  1239. 

  1240. TEST_F(STestTensorflowParser, tensorflow_parser_with_external_normal_graph) {

  1241.   // 1. Create root graph

  1242.   ComputeGraphPtr root_graph = ge::parser::MakeShared<ge::ComputeGraph>("root_graph");

  1243.   MakeGraph(root_graph, "root_graph");

  1244. 

  1245.   // 2. Create ONNX sub graph

  1246.   // 2.1 Sub graph of onnx graph

  1247.   ge::ComputeGraphPtr sub_sub_graph = ge::parser::MakeShared<ge::ComputeGraph>("sub_sub");

  1248.   // 2.2 ONNX graph

  1249.   ComputeGraphPtr sub_graph = ge::parser::MakeShared<ge::ComputeGraph>("sub_sub");

  1250.   MakeGraph(sub_graph, "sub_graph");

  1251.   auto add = sub_graph->FindNode("sub_graph_add");

  1252.   ASSERT_NE(add, nullptr);

  1253.   add->GetOpDesc()->AddSubgraphName("sub_sub_graph");

  1254.   add->GetOpDesc()->SetSubgraphInstanceName(0, sub_sub_graph->GetName());

  1255.   sub_graph->AddSubGraph(sub_sub_graph);

  1256.   auto input1 = sub_graph->FindNode("sub_graph_input1");

  1257.   ASSERT_NE(input1, nullptr);

  1258.   AttrUtils::SetInt(input1->GetOpDesc(), ATTR_NAME_INDEX, 0);

  1259.   auto input2 = sub_graph->FindNode("sub_graph_input2");

  1260.   ASSERT_NE(input2, nullptr);

  1261.   AttrUtils::SetInt(input2->GetOpDesc(), ATTR_NAME_INDEX, 1);

  1262. 

  1263.   // 3. Serialize ONNX graph to string

  1264.   // 3.1 normal

  1265.   ge::Model model("model", "");

  1266.   model.SetGraph(GraphUtils::CreateGraphFromComputeGraph(sub_graph));

  1267.   Buffer buffer;

  1268.   graphStatus save_ret = model.Save(buffer, false);

  1269.   ASSERT_EQ(save_ret, GRAPH_SUCCESS);

  1270.   std::string external_graph(reinterpret_cast<const char *>(buffer.GetData()),

  1271.                              buffer.GetSize());

  1272.   // model will failed

  1273.   input1->GetOpDesc()->DelAttr(ATTR_NAME_INDEX);

  1274.   ge::Model model_will_fail("model_will_fail", "");

  1275.   model_will_fail.SetGraph(GraphUtils::CreateGraphFromComputeGraph(sub_graph));

  1276.   Buffer buffer_fail;

  1277.   save_ret = model_will_fail.Save(buffer_fail, false);

  1278.   ASSERT_EQ(save_ret, GRAPH_SUCCESS);

  1279.   std::string external_graph_fail(

  1280.       reinterpret_cast<const char *>(buffer_fail.GetData()),

  1281.       buffer_fail.GetSize());

  1282. 

  1283.   // 4. Set string to function node

  1284.   auto root_add = root_graph->FindNode("root_graph_add");

  1285.   ASSERT_NE(root_add, nullptr);

  1286.   AttrUtils::SetStr(root_add->GetOpDesc(), "_external_model", external_graph);

  1287.   auto root_input1 = root_graph->FindNode("root_graph_input1");

  1288.   ASSERT_NE(root_input1, nullptr);

  1289.   AttrUtils::SetInt(root_input1->GetOpDesc(), ATTR_NAME_INDEX, 0);

  1290.   auto root_input2 = root_graph->FindNode("root_graph_input2");

  1291.   ASSERT_NE(root_input2, nullptr);

  1292.   AttrUtils::SetInt(root_input2->GetOpDesc(), ATTR_NAME_INDEX, 1);

  1293. 

  1294.   // 5. Run test (normal)

  1295.   auto ret = TensorFlowModelParser::AddExternalGraph(root_graph);

  1296.   EXPECT_EQ(ret, SUCCESS);

  1297.   EXPECT_EQ(root_graph->GetAllSubgraphs().size(), 2);

  1298.   EXPECT_EQ(sub_graph->GetAllSubgraphs().size(), 1);

  1299.   EXPECT_NE(root_graph->GetSubgraph(sub_graph->GetName()), nullptr);

  1300.   EXPECT_EQ(root_graph->GetSubgraph(sub_graph->GetName())->GetAllSubgraphs().size(), 0);

  1301. }

  1302. 

  1303. TEST_F(STestTensorflowParser, tensorflow_ParserProto_failed)

  1304. {

  1305.   std::string caseDir = __FILE__;

  1306.   std::size_t idx = caseDir.find_last_of("/");

  1307.   caseDir = caseDir.substr(0, idx);

  1308.   const std::string root_proto = caseDir + "/origin_models/avgpool3dgrad.pb.txt";

  1309.   domi::tensorflow::GraphDef graphDef;

  1310.   ge::Graph graph;

  1311.   std::map<ge::AscendString, ge::AscendString> parser_params;

  1312.   Status ret = ge::aclgrphParseTensorFlow(root_proto.c_str(), parser_params, graph);

  1313.   ASSERT_EQ(ret, SUCCESS);

  1314. 

  1315.   ge::ComputeGraphPtr root_graph = ge::GraphUtils::GetComputeGraph(graph);

  1316.   TensorFlowModelParser tensorflow_parser;

  1317.   ret = tensorflow_parser.ParseProto(reinterpret_cast<google::protobuf::Message *>(&graphDef), root_graph);

  1318.   EXPECT_EQ(PARAM_INVALID, ret);

  1319. 

  1320.   // proto解析失败

  1321.   bool protoRet = parser::ReadProtoFromText(root_proto.c_str(), &graphDef);

  1322.   ASSERT_EQ(protoRet, false);

  1323.   ret = tensorflow_parser.ParseProto(reinterpret_cast<google::protobuf::Message *>(&graphDef), root_graph);

  1324.   ASSERT_EQ(ret, PARAM_INVALID);

  1325. 

  1326.   std::string serialized_proto = "";

  1327.   ret = tensorflow_parser.ParseProto(serialized_proto, root_graph);

  1328.   ASSERT_EQ(ret, FAILED);

  1329. }

  1330. 

  1331. TEST_F(STestTensorflowParser, tensorflow_parserAllGraph_failed)

  1332. {

  1333.   std::string caseDir = __FILE__;

  1334.   std::size_t idx = caseDir.find_last_of("/");

  1335.   caseDir = caseDir.substr(0, idx);

  1336.   const std::string root_proto = caseDir + "/origin_models/conv2d.pb";

  1337.   domi::tensorflow::GraphDef graphDef;

  1338.   CreateGraphDef(graphDef);

  1339. 

  1340.   auto no_op = graphDef.add_node();

  1341.   no_op->set_name("no_op");

  1342.   no_op->set_op("NoOp");

  1343.   no_op->add_input("placeholder0");

  1344.   no_op->add_input("placeholder1");

  1345. 

  1346.   ge::Graph graph;

  1347.   std::map<ge::AscendString, ge::AscendString> parser_params;

  1348.   Status ret = ge::aclgrphParseTensorFlow(root_proto.c_str(), parser_params, graph);

  1349.   ASSERT_EQ(ret, SUCCESS);

  1350. 

  1351.   ge::ComputeGraphPtr root_graph = ge::GraphUtils::GetComputeGraph(graph);

  1352.   TensorFlowModelParser tensorflow_parser;

  1353.   ret = tensorflow_parser.ParseAllGraph(reinterpret_cast<google::protobuf::Message *>(&graphDef), root_graph);

  1354.   ASSERT_NE(ret, SUCCESS);

  1355. }

  1356. 

  1357. TEST_F(STestTensorflowParser, test_parse_acl_output_nodes)

  1358. {

  1359.   AclGraphParserUtil acl_graph_parse_util;

  1360.   string graph_name;

  1361.   // case 1: Normal with 'node and index'

  1362.   ParerSTestsUtils::ClearParserInnerCtx();

  1363.   GetParserContext().type = domi::ONNX;

  1364.   std::map<AscendString, AscendString> out_nodes_with_node_and_index = {

  1365.     {AscendString(ge::ir_option::OUT_NODES), AscendString("Out1:0;Out2:1")}};

  1366.   ParerSTestsUtils::ClearParserInnerCtx();

  1367.   auto ret = acl_graph_parse_util.ParseParamsBeforeGraph(out_nodes_with_node_and_index, graph_name);

  1368.   ASSERT_EQ(ret, SUCCESS);

  1369.   EXPECT_EQ(ge::GetParserContext().user_out_nodes.size(), 2);

  1370.   EXPECT_EQ(ge::GetParserContext().out_nodes_map.size(), 2);

  1371.   EXPECT_EQ(ge::GetParserContext().user_out_tensors.size(), 0);

  1372. 

  1373.   // case 2: Normal with 'tensor name'

  1374.   ParerSTestsUtils::ClearParserInnerCtx();

  1375.   GetParserContext().type = domi::ONNX;

  1376.   std::map<AscendString, AscendString> out_nodes_with_tensor_name = {

  1377.     {AscendString(ge::ir_option::OUT_NODES), AscendString("Out_tensor_1;Out_tensor_2")}};

  1378.   ret = acl_graph_parse_util.ParseParamsBeforeGraph(out_nodes_with_tensor_name, graph_name);

  1379.   ASSERT_EQ(ret, SUCCESS);

  1380.   EXPECT_EQ(ge::GetParserContext().user_out_nodes.size(), 0);

  1381.   EXPECT_EQ(ge::GetParserContext().out_nodes_map.size(), 0);

  1382.   EXPECT_EQ(ge::GetParserContext().user_out_tensors.size(), 2);

  1383. 

  1384.   // case 3: Failed with 'node and index' before 'tensor name'

  1385.   ParerSTestsUtils::ClearParserInnerCtx();

  1386.   GetParserContext().type = domi::ONNX;

  1387.   std::map<AscendString, AscendString> out_nodes_mode_mixex_pre = {

  1388.     {AscendString(ge::ir_option::OUT_NODES), AscendString("Out1:0;Out2:1;Out_tensor_1;Out_tensor_2")}};

  1389.   ret = acl_graph_parse_util.ParseParamsBeforeGraph(out_nodes_mode_mixex_pre, graph_name);

  1390.   ASSERT_EQ(ret, PARAM_INVALID);

  1391.   EXPECT_EQ(ge::GetParserContext().user_out_nodes.size(), 2);

  1392.   EXPECT_EQ(ge::GetParserContext().out_nodes_map.size(), 2);

  1393.   EXPECT_EQ(ge::GetParserContext().user_out_tensors.size(), 0);

  1394. 

  1395.   // case 4: Failed with 'node and index' inserted in 'tensor name'

  1396.   ParerSTestsUtils::ClearParserInnerCtx();

  1397.   GetParserContext().type = domi::ONNX;

  1398.   std::map<AscendString, AscendString> out_nodes_mode_mixex_mid = {

  1399.     {AscendString(ge::ir_option::OUT_NODES), AscendString("Out_tensor_1;Out1:0;Out2:1;Out_tensor_2")}};

  1400.   ret = acl_graph_parse_util.ParseParamsBeforeGraph(out_nodes_mode_mixex_mid, graph_name);

  1401.   ASSERT_EQ(ret, PARAM_INVALID);

  1402.   EXPECT_EQ(ge::GetParserContext().user_out_nodes.size(), 0);

  1403.   EXPECT_EQ(ge::GetParserContext().out_nodes_map.size(), 0);

  1404.   EXPECT_EQ(ge::GetParserContext().user_out_tensors.size(), 1);

  1405. 

  1406.   // case 5: Failed with 'node and index' after 'tensor name'

  1407.   ParerSTestsUtils::ClearParserInnerCtx();

  1408.   GetParserContext().type = domi::ONNX;

  1409.   std::map<AscendString, AscendString> out_nodes_mode_mixex_post = {

  1410.     {AscendString(ge::ir_option::OUT_NODES), AscendString("Out_tensor_1;Out_tensor_2;Out1:0;Out2:1")}};

  1411.   ret = acl_graph_parse_util.ParseParamsBeforeGraph(out_nodes_mode_mixex_post, graph_name);

  1412.   ASSERT_EQ(ret, PARAM_INVALID);

  1413.   EXPECT_EQ(ge::GetParserContext().user_out_nodes.size(), 0);

  1414.   EXPECT_EQ(ge::GetParserContext().out_nodes_map.size(), 0);

  1415.   EXPECT_EQ(ge::GetParserContext().user_out_tensors.size(), 2);

  1416. }

  1417. 

  1418. TEST_F(STestTensorflowParser, parse_AutoMappingByOp) {

  1419.   static const string KEY_STRING = "key_string";

  1420.   static const string KEY_INT = "key_int";

  1421.   static const string KEY_FLOAT = "key_float";

  1422.   static const string KEY_BOOL = "key_bool";

  1423.   static const string KEY_TYPE = "key_type";

  1424.   static const string VALUE_STRING = "string";

  1425.   static const int64_t VALUE_INT = 1;

  1426.   static const float VALUE_FLOAT = 1.0;

  1427.   static const bool VALUE_BOOL = true;

  1428.   static const  domi::tensorflow::DataType VALUE_TYPE = domi::tensorflow::DataType::DT_FLOAT;

  1429.   static const string VALUE_NAME = "test_name";

  1430.   ge::OpDescPtr op_desc = std::make_shared<ge::OpDesc>();

  1431.   NodeDef node_def;

  1432.   domi::tensorflow::AttrValue value;

  1433.   ge::Operator op = ge::OpDescUtils::CreateOperatorFromOpDesc(op_desc);

  1434. 

  1435.   node_def.set_name(VALUE_NAME);

  1436.   value.set_s(VALUE_STRING);

  1437.   TensorFlowUtil::AddNodeAttr(KEY_STRING, value, &node_def);

  1438.   value.set_i(VALUE_INT);

  1439.   TensorFlowUtil::AddNodeAttr(KEY_INT, value, &node_def);

  1440.   value.set_f(VALUE_FLOAT);

  1441.   TensorFlowUtil::AddNodeAttr(KEY_FLOAT, value, &node_def);

  1442.   value.set_b(VALUE_BOOL);

  1443.   TensorFlowUtil::AddNodeAttr(KEY_BOOL, value, &node_def);

  1444.   value.set_type(VALUE_TYPE);

  1445.   TensorFlowUtil::AddNodeAttr(KEY_TYPE, value, &node_def);

  1446. 

  1447.   domi::Status status = domi::AutoMappingFn(reinterpret_cast<google::protobuf::Message *>(&node_def), op);

  1448.   EXPECT_EQ(domi::SUCCESS, status);

  1449.   EXPECT_EQ(VALUE_NAME, op_desc->GetName());

  1450. 

  1451.   string value_string = "";

  1452.   ge::AttrUtils::GetStr(op_desc, KEY_STRING, value_string);

  1453.   EXPECT_EQ(VALUE_STRING, value_string);

  1454. 

  1455.   int64_t value_int = 0;

  1456.   ge::AttrUtils::GetInt(op_desc, KEY_INT, value_int);

  1457.   EXPECT_EQ(VALUE_INT, value_int);

  1458. 

  1459.   float value_float = 0.0;

  1460.   ge::AttrUtils::GetFloat(op_desc, KEY_FLOAT, value_float);

  1461.   EXPECT_EQ(VALUE_FLOAT, value_float);

  1462. 

  1463.   bool value_bool = false;

  1464.   ge::AttrUtils::GetBool(op_desc, KEY_BOOL, value_bool);

  1465.   EXPECT_EQ(VALUE_BOOL, value_bool);

  1466. 

  1467.   ge::DataType data_type = ge::DT_UNDEFINED;

  1468.   ge::AttrUtils::GetDataType(op_desc, KEY_TYPE, data_type);

  1469.   EXPECT_EQ(ge::DT_FLOAT, data_type);

  1470. 

  1471.   // test AutoMappingByOpFn

  1472.   ge::OpDescPtr op_desc_dest = std::make_shared<ge::OpDesc>();

  1473.   ge::Operator op_dest = ge::OpDescUtils::CreateOperatorFromOpDesc(op_desc_dest);

  1474. 

  1475.   status = domi::AutoMappingByOpFn(op, op_dest);

  1476.   EXPECT_EQ(domi::SUCCESS, status);

  1477.   EXPECT_EQ(VALUE_NAME, op_dest.GetName());

  1478. 

  1479.   value_string = "";

  1480.   ge::AttrUtils::GetStr(op_desc_dest, KEY_STRING, value_string);

  1481.   EXPECT_EQ(VALUE_STRING, value_string);

  1482. 

  1483.   value_int = 0;

  1484.   ge::AttrUtils::GetInt(op_desc_dest, KEY_INT, value_int);

  1485.   EXPECT_EQ(VALUE_INT, value_int);

  1486. 

  1487.   value_float = 0.0;

  1488.   ge::AttrUtils::GetFloat(op_desc_dest, KEY_FLOAT, value_float);

  1489.   EXPECT_EQ(VALUE_FLOAT, value_float);

  1490. 

  1491.   value_bool = false;

  1492.   ge::AttrUtils::GetBool(op_desc_dest, KEY_BOOL, value_bool);

  1493.   EXPECT_EQ(VALUE_BOOL, value_bool);

  1494. 

  1495.   data_type = ge::DT_UNDEFINED;

  1496.   ge::AttrUtils::GetDataType(op_desc_dest, KEY_TYPE, data_type);

  1497.   EXPECT_EQ(ge::DT_FLOAT, data_type);

  1498. }

  1499. 

  1500. TEST_F(STestTensorflowParser, parse_ParseNodeDef)

  1501. {

  1502.   NodeDef * node_def = new NodeDef();

  1503.   node_def->set_name("test_name");

  1504.   node_def->set_op("PlaceholderWithDefault");

  1505. 

  1506.   bool isDatasetInit = true;

  1507.   TensorFlowModelParser model_parser;

  1508.   Status ret = model_parser.AdaptOpType(node_def, isDatasetInit);

  1509.   EXPECT_EQ(domi::SUCCESS, ret);

  1510. 

  1511.   node_def->set_op("Add");

  1512.   ret = model_parser.AdaptOpType(node_def, isDatasetInit);

  1513.   EXPECT_EQ(domi::SUCCESS, ret);

  1514.   delete node_def;

  1515. }

  1516. 

  1517. TEST_F(STestTensorflowParser, parse_AddFmkNode)

  1518. {

  1519.   TensorFlowModelParser modelParser;

  1520.   std::string caseDir = __FILE__;

  1521.   std::size_t idx = caseDir.find_last_of("/");

  1522.   caseDir = caseDir.substr(0, idx);

  1523.   std::string modelFile = caseDir + "/origin_models/tf_add.pb";

  1524.   ge::Graph graph;

  1525.   string graph_name;

  1526.   AclGraphParserUtil acl_graph_parse_util;

  1527.   std::map<ge::AscendString, ge::AscendString> parser_options = {{AscendString(ge::ir_option::OUT_NODES), AscendString("Placeholder:0;Placeholder_1:0")}};

  1528.   ParerSTestsUtils::ClearParserInnerCtx();

  1529.   Status ret = acl_graph_parse_util.ParseParamsBeforeGraph(parser_options, graph_name);

  1530.   ret = aclgrphParseTensorFlow(modelFile.c_str(), parser_options, graph);

  1531.   ASSERT_EQ(ret, SUCCESS);

  1532. 

  1533.   ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);

  1534.   tensorflow::GraphDef *graphDef = new (std::nothrow) tensorflow::GraphDef();

  1535.   ScopePassManager pass_manager;

  1536.   std::shared_ptr<ScopeGraph> scope_graph = pass_manager.BuildScopeGraph(graphDef);

  1537. 

  1538.   std::string fusion_op_name = "fusion_op_name";

  1539.   FusionScopesResult *fusion_rlt = new (std::nothrow) FusionScopesResult();

  1540.   EXPECT_NE(fusion_rlt, nullptr);

  1541.   fusion_rlt->Init();

  1542.   GenFusionScopesResult(scope_graph, fusion_rlt, fusion_op_name);

  1543.   GenOriginContext(&modelParser, fusion_op_name);

  1544. 

  1545.   // origin inner node def

  1546.   NodeDef* node_def = MallocNodeDef("scope_node_1", "Add");

  1547.   EXPECT_NE(node_def, nullptr);

  1548.   modelParser.fusion_op_nodedef_map_[fusion_op_name].push_back(node_def);

  1549. 

  1550.   bool train_flag_backup = ge::GetParserContext().train_flag;

  1551.   ge::GetParserContext().train_flag = true;

  1552. 

  1553.   REGISTER_CUSTOM_OP("Identity")

  1554.     .FrameworkType(domi::TENSORFLOW)

  1555.     .OriginOpType("Identity")

  1556.     .ParseParamsFn(ParseParams)

  1557.     .ImplyType(ImplyType::TVM);

  1558.   REGISTER_CUSTOM_OP("Constant")

  1559.     .FrameworkType(domi::TENSORFLOW)

  1560.     .OriginOpType("Const")

  1561.     .ParseParamsFn(ParseParams)

  1562.     .ImplyType(ImplyType::TVM);

  1563. 

  1564.   register_tbe_op();

  1565. 

  1566.   std::vector<std::string> node_name_list;

  1567.   GenOriginNodeDef(&modelParser, node_name_list);

  1568.   std::set<std::string> malloc_node_name_list(node_name_list.begin(), node_name_list.end());

  1569.   node_name_list.push_back(fusion_op_name);

  1570. 

  1571.   ret = modelParser.AddFmkNode(compute_graph, scope_graph, node_name_list, false);

  1572.   EXPECT_EQ(ret, PARAM_INVALID);

  1573.   EXPECT_EQ(modelParser.scope_inner_node_map_.size(), 0);

  1574.   EXPECT_EQ(modelParser.nodedef_map_.size(), 5);

  1575. 

  1576.   ret = modelParser.AddEdges(compute_graph);

  1577.   EXPECT_EQ(ret, SUCCESS);

  1578. 

  1579.   // release resource

  1580.   delete graphDef;

  1581.   delete node_def;

  1582.   modelParser.DeleteFuisonNodeDef();

  1583.   FreeNodeDefMap(&modelParser, malloc_node_name_list);

  1584.   ge::GetParserContext().train_flag = train_flag_backup;

  1585. }

  1586. 

  1587. TEST_F(STestTensorflowParser, parse_AddScopeInnerNode)

  1588. {

  1589.   TensorFlowModelParser modelParser;

  1590.   std::string caseDir = __FILE__;

  1591.   std::size_t idx = caseDir.find_last_of("/");

  1592.   caseDir = caseDir.substr(0, idx);

  1593.   std::string modelFile = caseDir + "/origin_models/tf_add.pb";

  1594.   std::string op_name = "ge_ascend_irgraph";

  1595.   ge::Graph graph(op_name);

  1596.   ge::ComputeGraphPtr compute_graph = ge::GraphUtils::GetComputeGraph(graph);

  1597.   std::map<ge::AscendString, ge::AscendString> parser_params = {

  1598.     {AscendString(ge::ir_option::OUT_NODES), AscendString("Placeholder:0;Placeholder_1:0")}};

  1599.   Status ret = ge::aclgrphParseTensorFlow(modelFile.c_str(), parser_params, graph);

  1600.   EXPECT_EQ(ret, SUCCESS);

  1601. 

  1602.   std::mutex graph_mutex;

  1603.   tensorflow::NodeDef *node_def = initNodeDef();

  1604.   node_def->set_name("FastrcnnPredictions");

  1605.   node_def->set_op("FastrcnnPredictions");

  1606.   // can't find in scope_inner_node_map

  1607.   ret = modelParser.AddScopeInnerNode(&modelParser, compute_graph, &graph_mutex, node_def);

  1608.   EXPECT_EQ(ret, PARAM_INVALID);

  1609.   delete node_def;

  1610. }

  1611. 

  1612. TEST_F(STestTensorflowParser, dyncmic_rnn_scope_pass_plugin_test) {

  1613.   ge::Graph graph;

  1614. 

  1615.   std::cout << __FILE__ << std::endl;

  1616.   std::string caseDir = __FILE__;

  1617.   std::size_t idx = caseDir.find_last_of("/");

  1618.   caseDir = caseDir.substr(0, idx);

  1619.   std::string modelFile = caseDir + "/origin_models/tensor_array.pb";

  1620.   std::map<ge::AscendString, ge::AscendString> params;

  1621.   string key ="enable_scope_fusion_passes";

  1622.   string value ="ScopeDynamicRNNPass";

  1623.   params.insert(std::make_pair(ge::AscendString(key.c_str()), ge::AscendString(value.c_str())));

  1624.   auto status = aclgrphParseTensorFlow(modelFile.c_str(), params, graph);

  1625.   EXPECT_EQ(status, SUCCESS);

  1626. }

  1627. 

  1628. TEST_F(STestTensorflowParser, avgpool3dgrad_plugin_test_format_NDHWC) {

  1629.   ge::Graph graph;

  1630.   std::cout << __FILE__ << std::endl;

  1631.   std::string caseDir = __FILE__;

  1632.   std::size_t idx = caseDir.find_last_of("/");

  1633.   caseDir = caseDir.substr(0, idx);

  1634.   std::string modelFile = caseDir + "/origin_models/avgpool3dgrad_case_1.pb";

  1635.   auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1636.   EXPECT_EQ(status, SUCCESS);

  1637. }

  1638. 

  1639. TEST_F(STestTensorflowParser, tensorflow_merge_test) {

  1640.   ge::Graph graph;

  1641.   std::cout << __FILE__ << std::endl;

  1642.   std::string caseDir = __FILE__;

  1643.   std::size_t idx = caseDir.find_last_of("/");

  1644.   caseDir = caseDir.substr(0, idx);

  1645.   std::string modelFile = caseDir + "/origin_models/merge.pb";

  1646.   auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1647.   EXPECT_EQ(status, FAILED);

  1648. }

  1649. 

  1650. TEST_F(STestTensorflowParser, tensorflow_no_op_test) {

  1651.   ge::Graph graph;

  1652.   std::cout << __FILE__ << std::endl;

  1653.   std::string caseDir = __FILE__;

  1654.   std::size_t idx = caseDir.find_last_of("/");

  1655.   caseDir = caseDir.substr(0, idx);

  1656.   std::string modelFile = caseDir + "/origin_models/test_no_op.pb";

  1657.   auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1658.   EXPECT_EQ(status, SUCCESS);

  1659. }

  1660. 

  1661. TEST_F(STestTensorflowParser, tensorflow_identity_test) {

  1662.   ge::Graph graph;

  1663.   std::cout << __FILE__ << std::endl;

  1664.   std::string caseDir = __FILE__;

  1665.   std::size_t idx = caseDir.find_last_of("/");

  1666.   caseDir = caseDir.substr(0, idx);

  1667.   std::string modelFile = caseDir + "/origin_models/test_identity.pb";

  1668.   auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1669.   EXPECT_EQ(status, SUCCESS);

  1670. }

  1671. 

  1672. TEST_F(STestTensorflowParser, tensorflow_constant_test) {

  1673.   ge::Graph graph;

  1674.   std::cout << __FILE__ << std::endl;

  1675.   std::string caseDir = __FILE__;

  1676.   std::size_t idx = caseDir.find_last_of("/");

  1677.   caseDir = caseDir.substr(0, idx);

  1678.   std::string modelFile = caseDir + "/origin_models/test_constant.pb";

  1679.   auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1680.   EXPECT_EQ(status, SUCCESS);

  1681. 

  1682.   TensorFlowConstantParser constantParser;

  1683.   ge::OpDescPtr op_dest = make_shared<ge::OpDesc>("constant", ge::parser::CONSTANT);

  1684.   NodeDef* node_def = initNodeDef();

  1685.   node_def->set_name("Constant");

  1686.   auto params = constantParser.ParseParams(node_def, op_dest);

  1687.   EXPECT_EQ(params, SUCCESS);

  1688. 

  1689.   auto value = constantParser.ParseValue(node_def, op_dest);

  1690.   EXPECT_EQ(value, SUCCESS);

  1691. 

  1692.   ConstantOperator op;

  1693.   auto type = constantParser.ParseDType(node_def, &op);

  1694.   EXPECT_EQ(type, SUCCESS);

  1695. }

  1696. 

  1697. TEST_F(STestTensorflowParser, tensorflow_reshpae_test) {

  1698.   ge::Graph graph;

  1699.   std::cout << __FILE__ << std::endl;

  1700.   std::string caseDir = __FILE__;

  1701.   std::size_t idx = caseDir.find_last_of("/");

  1702.   caseDir = caseDir.substr(0, idx);

  1703.   std::string modelFile = caseDir + "/origin_models/test_reshape.pb";

  1704.   auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1705.   EXPECT_EQ(status, SUCCESS);

  1706. 

  1707.   TensorFlowReshapeParser parser;

  1708.   NodeDef * nodeDef = new NodeDef();

  1709.   ge::OpDescPtr opdef_ = make_shared<::ge::OpDesc>("","");

  1710.   google::protobuf::Map<std::string, tensorflow::AttrValue > *attr_map = nodeDef->mutable_attr();

  1711.   domi::tensorflow::AttrValue tshape_attr_value;

  1712.   tshape_attr_value.set_type(domi::tensorflow::DT_INT32);

  1713.   (*attr_map)[TENSORFLOW_ATTR_TSHAPE] = tshape_attr_value;

  1714.   domi::tensorflow::AttrValue t_attr_value;

  1715.   t_attr_value.set_type(domi::tensorflow::DT_FLOAT);

  1716.   (*attr_map)[TENSORFLOW_ATTR_T] = t_attr_value;

  1717. 

  1718.   Status ret = parser.ParseParams(nodeDef, opdef_);

  1719.   EXPECT_EQ(domi::SUCCESS, ret);

  1720.   delete nodeDef;

  1721. }

  1722. 

  1723. TEST_F(STestTensorflowParser, tensorflow_squeeze_test) {

  1724.   ge::Graph graph;

  1725.   std::cout << __FILE__ << std::endl;

  1726.   std::string caseDir = __FILE__;

  1727.   std::size_t idx = caseDir.find_last_of("/");

  1728.   caseDir = caseDir.substr(0, idx);

  1729.   std::string modelFile = caseDir + "/origin_models/test_sequeeze.pb";

  1730.   auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1731.   EXPECT_EQ(status, SUCCESS);

  1732. 

  1733.   TensorFlowSqueezeParser parser;

  1734.   NodeDef *nodeDef = initNodeDef();

  1735.   ge::OpDescPtr opDef = make_shared<::ge::OpDesc>("Squeeze","Squeeze");

  1736.   Status ret = parser.ParseParams(nodeDef, opDef);

  1737.   EXPECT_EQ(ret, SUCCESS);

  1738. 

  1739.   NodeDef *nodeDef_dim = initNodeDef_dims();

  1740.   ret = parser.ParseParams(nodeDef_dim, opDef);

  1741.   EXPECT_EQ(SUCCESS, ret);

  1742. 

  1743.   NodeDef *nodeDef_axis_dims = initNodeDef_axis_dims();

  1744.   ret = parser.ParseParams(nodeDef_axis_dims, opDef);

  1745.   EXPECT_EQ(GRAPH_PARAM_INVALID, ret);

  1746. 

  1747.   static const string KEY_SHAPE_LIST = "key_shape_list";

  1748.   static const string KEY_TENSOR_LIST = "key_tensor_list";

  1749.   static const string KEY_DEFAULT = "key_default";

  1750. 

  1751.   NodeDef *nodeDef2 = new NodeDef();

  1752.   google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map = nodeDef2->mutable_attr();

  1753.   domi::tensorflow::AttrValue dtype_attr_value ;

  1754.   dtype_attr_value.set_type(domi::tensorflow::DT_FLOAT);

  1755.   (*node_attr_map)[TENSORFLOW_ATTR_T] = dtype_attr_value;

  1756.   //设置strides属性

  1757.   tensorflow::AttrValue axis_attr_value;

  1758.   tensorflow::AttrValue_ListValue *list = axis_attr_value.mutable_list();

  1759.   list->add_i(1);

  1760.   list->add_i(2);

  1761.   (*node_attr_map)[ge::SQUEEZE_ATTR_AXIS] = axis_attr_value;

  1762.   domi::tensorflow::AttrValue value;

  1763.   domi::tensorflow::AttrValue df_attr_value;

  1764.   df_attr_value.set_i((int64_t)ccTensorFormat_t::CC_TENSOR_NHWC);

  1765. 

  1766.   domi::tensorflow::AttrValue pad_attr_value;

  1767.   pad_attr_value.set_i((int64_t)tensorflow::DT_FLOAT);

  1768. 

  1769.   domi::tensorflow::AttrValue shape;

  1770.   shape.mutable_list()->add_i((int64)32);

  1771.   shape.mutable_list()->add_i((int64)32);

  1772.   shape.mutable_list()->add_i((int64)14);

  1773.   

  1774.   static const string KEY_TYPE_LIST = "key_type_list";

  1775.   const std::string ATTR_NAME_INPUT_TENSOR_DESC  = "input_tensor_desc";

  1776.   const std::string ATTR_NAME_OUTPUT_TENSOR_DESC = "output_tensor_desc";

  1777.   static const  domi::tensorflow::DataType VALUE_TYPE = domi::tensorflow::DataType::DT_FLOAT;

  1778.   value.clear_value();

  1779.   value.mutable_list()->add_type(VALUE_TYPE);

  1780.   TensorFlowUtil::AddNodeAttr(KEY_TYPE_LIST, value, nodeDef2);

  1781. 

  1782.   value.clear_value();

  1783.   domi::tensorflow::NameAttrList name_attr_list;

  1784.   name_attr_list.mutable_attr()->insert({"serialize_datatype", pad_attr_value});

  1785.   name_attr_list.mutable_attr()->insert({"serialize_format", df_attr_value});

  1786.   name_attr_list.mutable_attr()->insert({"serialize_shape", shape});

  1787.   *(value.mutable_list()->add_func()) = name_attr_list;

  1788. 

  1789.   nodeDef2->mutable_attr()->insert({ge::ATTR_NAME_INPUT_TENSOR_DESC, value});

  1790.   nodeDef2->mutable_attr()->insert({ge::ATTR_NAME_OUTPUT_TENSOR_DESC, value});

  1791.   ret = parser.ParseParams(nodeDef2, opDef);

  1792.   EXPECT_EQ(domi::SUCCESS, ret);

  1793. 

  1794.   GeTensorDesc ge_desc;

  1795.   ge_desc.SetFormat(ge::FORMAT_C1HWNCoC0);

  1796.   ge_desc.SetDataType(ge::DT_FLOAT);

  1797.   ge_desc.SetShape(GeShape({1,1,1,1,1,1}));

  1798.   ret = parser.ParseDesc(value, ge_desc);

  1799.   EXPECT_EQ(ret, SUCCESS);

  1800. 

  1801.   delete nodeDef2;

  1802.   delete nodeDef_axis_dims;

  1803.   delete nodeDef_dim;

  1804.   delete nodeDef;

  1805. }

  1806. 

  1807. TEST_F(STestTensorflowParser, tensorflow_fill_test) {

  1808.   ge::Graph graph;

  1809.   std::cout << __FILE__ << std::endl;

  1810.   std::string caseDir = __FILE__;

  1811.   std::size_t idx = caseDir.find_last_of("/");

  1812.   caseDir = caseDir.substr(0, idx);

  1813.   std::string modelFile = caseDir + "/origin_models/test_fill.pb";

  1814.   auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1815.   EXPECT_EQ(status, SUCCESS);

  1816. }

  1817. 

  1818. TEST_F(STestTensorflowParser, tensorflow_shape_n_test) {

  1819.   ge::Graph graph;

  1820.   std::cout << __FILE__ << std::endl;

  1821.   std::string caseDir = __FILE__;

  1822.   std::size_t idx = caseDir.find_last_of("/");

  1823.   caseDir = caseDir.substr(0, idx);

  1824.   std::string modelFile = caseDir + "/origin_models/test_shape_n.pb";

  1825.   auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1826.   EXPECT_EQ(status, SUCCESS);

  1827. }

  1828. 

  1829. TEST_F(STestTensorflowParser, tensorflow_switch_test) {

  1830.   ge::Graph graph;

  1831.   std::cout << __FILE__ << std::endl;

  1832.   std::string caseDir = __FILE__;

  1833.   std::size_t idx = caseDir.find_last_of("/");

  1834.   caseDir = caseDir.substr(0, idx);

  1835.   std::string modelFile = caseDir + "/origin_models/test_switch.pb";

  1836.   auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1837.   EXPECT_EQ(status, SUCCESS);

  1838. 

  1839.   TensorFlowRefSwitchParser refSwitchParser;

  1840.   ge::OpDescPtr op_dest = make_shared<ge::OpDesc>("constant", ge::parser::CONSTANT);

  1841.   NodeDef* node_def = initNodeDef();

  1842.   node_def->set_name("RefSwitch");

  1843.   auto params = refSwitchParser.ParseParams(node_def, op_dest);

  1844.   EXPECT_EQ(params, SUCCESS);

  1845. 

  1846.   RefSwitchOperator op;

  1847.   auto parseRet = refSwitchParser.ParseT(node_def, &op);

  1848.   EXPECT_EQ(parseRet, SUCCESS);

  1849. }

  1850. 

  1851. TEST_F(STestTensorflowParser, tensorflow_enter_test) {

  1852.   ge::Graph graph;

  1853.   std::cout << __FILE__ << std::endl;

  1854.   std::string caseDir = __FILE__;

  1855.   std::size_t idx = caseDir.find_last_of("/");

  1856.   caseDir = caseDir.substr(0, idx);

  1857.   std::string modelFile = caseDir + "/origin_models/test_enter.pb";

  1858.   auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1859.   EXPECT_EQ(status, SUCCESS);

  1860. 

  1861.   TensorFlowEnterParser enterParser;

  1862.   ge::OpDescPtr op_dest = make_shared<ge::OpDesc>("Enter", ge::parser::ENTER);

  1863.   NodeDef* node_def = initNodeDef();

  1864.   node_def->set_name("Enter");

  1865.   Status ret = enterParser.ParseParams(node_def, op_dest);

  1866.   EXPECT_EQ(ret, FAILED);

  1867. 

  1868.   static const string KEY_SHAPE_LIST = "key_shape_list";

  1869.   static const string KEY_TENSOR_LIST = "key_tensor_list";

  1870.   static const string KEY_DEFAULT = "key_default";

  1871. 

  1872.   google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map = node_def->mutable_attr();

  1873.   domi::tensorflow::AttrValue dtype_attr_value;

  1874.   dtype_attr_value.set_type(domi::tensorflow::DT_FLOAT);

  1875.   (*node_attr_map)[TENSORFLOW_ATTR_T] = dtype_attr_value;

  1876. 

  1877.   //设置strides属性

  1878.   domi::tensorflow::AttrValue axis_attr_value;

  1879.   ::tensorflow::AttrValue_ListValue* list = axis_attr_value.mutable_list();

  1880.   list->add_i(1);

  1881.   list->add_i(2);

  1882.   (*node_attr_map)[ge::SQUEEZE_ATTR_AXIS] = axis_attr_value;

  1883. 

  1884.   domi::tensorflow::AttrValue value;

  1885.   domi::tensorflow::AttrValue df_attr_value;

  1886.   df_attr_value.set_i((int64_t)ccTensorFormat_t::CC_TENSOR_NHWC);

  1887. 

  1888.   domi::tensorflow::AttrValue pad_attr_value;

  1889.   pad_attr_value.set_i((int64_t)tensorflow::DT_FLOAT);

  1890. 

  1891.   domi::tensorflow::AttrValue shape;

  1892.   shape.mutable_list()->add_i((int64)32);

  1893.   shape.mutable_list()->add_i((int64)32);

  1894.   shape.mutable_list()->add_i((int64)14);

  1895.   

  1896.   static const string KEY_TYPE_LIST = "key_type_list";

  1897.   const std::string ENTER_ATTR_FRAME_NAME = "frame_name";

  1898.   const std::string ATTR_NAME_OUTPUT_TENSOR_DESC = "output_tensor_desc";

  1899.   static const  domi::tensorflow::DataType VALUE_TYPE = domi::tensorflow::DataType::DT_FLOAT;

  1900.   value.clear_value();

  1901.   value.mutable_list()->add_type(VALUE_TYPE);

  1902.   TensorFlowUtil::AddNodeAttr(KEY_TYPE_LIST, value, node_def);

  1903. 

  1904.   value.clear_value();

  1905.   domi::tensorflow::NameAttrList name_attr_list;

  1906.   name_attr_list.mutable_attr()->insert({"serialize_datatype", pad_attr_value});

  1907.   name_attr_list.mutable_attr()->insert({"serialize_format", df_attr_value});

  1908.   name_attr_list.mutable_attr()->insert({"serialize_shape", shape});

  1909.   *(value.mutable_list()->add_func()) = name_attr_list;

  1910. 

  1911.   node_def->mutable_attr()->insert({ge::ENTER_ATTR_FRAME_NAME, value});

  1912.   node_def->mutable_attr()->insert({ge::ATTR_NAME_OUTPUT_TENSOR_DESC, value});

  1913.   ret = enterParser.ParseParams(node_def, op_dest);

  1914.   EXPECT_EQ(ret, FAILED);

  1915. }

  1916. 

  1917. TEST_F(STestTensorflowParser, tensorflow_VariableV2_test) {

  1918.   ge::Graph graph;

  1919.   std::string caseDir = __FILE__;

  1920.   std::size_t idx = caseDir.find_last_of("/");

  1921.   caseDir = caseDir.substr(0, idx);

  1922.   std::string modelFile = caseDir + "/origin_models/test_VariableV2.pb";

  1923.   auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph);

  1924.   EXPECT_EQ(status, SUCCESS);

  1925. }

  1926. 

  1927. TEST_F(STestTensorflowParser, tensorflow_fusion_op_parser_test)

  1928. {

  1929.   TensorFlowFusionOpParser fusionOpParser;

  1930.   ge::OpDescPtr op_dest = make_shared<ge::OpDesc>("FusionOp", ge::parser::CONSTANT);

  1931.   int index = 0;

  1932.   NodeDef* node_def = fusioninitNodeDef(index);

  1933.   node_def->set_name("FusionOp");

  1934.   auto ret = fusionOpParser.ParseParams(node_def, op_dest);

  1935.   EXPECT_EQ(ret, SUCCESS);

  1936. 

  1937.   int32_t param = 1;

  1938.   ret = fusionOpParser.ParseParamFromConst(node_def, param);

  1939.   EXPECT_EQ(ret, SUCCESS);

  1940. 

  1941.   ret = fusionOpParser.ParseParamFromConst(node_def, param, index);

  1942.   EXPECT_EQ(ret, SUCCESS);

  1943. 

  1944.   float params = 0.0;

  1945.   ret = fusionOpParser.ParseParamFromConst(node_def, params);

  1946.   EXPECT_EQ(ret, SUCCESS);

  1947. 

  1948.   index = 2;

  1949.   node_def = fusioninitNodeDef(index);

  1950.   ret = fusionOpParser.ParseParamFromConst(node_def, params, index);

  1951.   EXPECT_EQ(ret, domi::PARAM_INVALID);

  1952. 

  1953.   ret = fusionOpParser.ParseHalfFromConst(node_def, params, 0);

  1954.   EXPECT_EQ(ret, SUCCESS);

  1955. 

  1956.   ret = fusionOpParser.ParseHalfFromConst(node_def, params, 3);

  1957.   EXPECT_EQ(ret, domi::PARAM_INVALID);

  1958. 

  1959.   node_def = fusioninitNodeDef(0);

  1960.   ret = fusionOpParser.ParseHalfFromConst(node_def, params, 3);

  1961.   EXPECT_EQ(ret, domi::PARAM_INVALID);

  1962. 

  1963.   static const float VALUE_FLOAT = 1.0;

  1964.   ge::GeTensorPtr weight = nullptr;

  1965.   ret = fusionOpParser.ParseWeightFromConst(node_def, weight);

  1966.   EXPECT_EQ(ret, domi::SUCCESS);

  1967.   EXPECT_NE(weight, nullptr);

  1968. 

  1969.   ge::DataType ge_data_type = weight->GetTensorDesc().GetDataType();

  1970.   EXPECT_EQ(ge_data_type, ge::DataType::DT_FLOAT);

  1971. 

  1972.   const uint8_t* data_buff = weight->GetData().GetData();

  1973.   size_t data_size = weight->GetData().size();

  1974.   EXPECT_NE(data_buff, nullptr);

  1975.   EXPECT_EQ(data_size, sizeof(float));

  1976. 

  1977.   float value_float = *((float*)data_buff);

  1978.   EXPECT_EQ(value_float, VALUE_FLOAT);

  1979.   delete node_def;

  1980. }

  1981. 

  1982. TEST_F(STestTensorflowParser, tensorflow_auto_mapping_parser_adapter_test)

  1983. {

  1984.   ge::OpDescPtr op_dest = nullptr;

  1985.   Message *op_src = nullptr;

  1986.   TensorFlowAutoMappingParserAdapter autoMappingParser;

  1987.   NodeDef* node_def = initNodeDef();

  1988.   Status ret = autoMappingParser.ParseParams(op_src, op_dest);

  1989.   EXPECT_EQ(ret, PARAM_INVALID);

  1990. 

  1991.   ret = autoMappingParser.ParseParams(node_def, op_dest);

  1992.   EXPECT_EQ(ret, PARAM_INVALID);

  1993. 

  1994.   op_dest = make_shared<ge::OpDesc>("AutoMapping", ge::parser::CONSTANT);

  1995.   op_dest->SetType(ge::parser::EMPTY);

  1996.   ret = autoMappingParser.ParseParams(node_def, op_dest);

  1997.   EXPECT_EQ(ret, SUCCESS);

  1998. 

  1999.   op_dest->SetType(ge::parser::IDENTITYN);

  2000.   ret = autoMappingParser.ParseParams(node_def, op_dest);

  2001.   EXPECT_EQ(ret, SUCCESS);

  2002. 

  2003.   op_dest->SetType(ge::parser::SIZE);

  2004.   ret = autoMappingParser.ParseParams(node_def, op_dest);

  2005.   EXPECT_EQ(ret, SUCCESS);

  2006. 

  2007.   op_dest->SetType(ge::parser::SHAPE);

  2008.   op_dest->AddOutputDesc(GeTensorDesc());

  2009.   ret = autoMappingParser.ParseParams(node_def, op_dest);

  2010.   EXPECT_EQ(ret, SUCCESS);

  2011. }

  2012. 

  2013. TEST_F(STestTensorflowParser, tensorflow_fusion_custom_parser_adapter_test)

  2014. {

  2015.   REGISTER_CUSTOM_OP("FusionCustom")

  2016.     .FrameworkType(domi::TENSORFLOW)

  2017.     .OriginOpType("FusionCustom")

  2018.     .FusionParseParamsFn(FusionParserParams)

  2019.     .ImplyType(ImplyType::TVM);

  2020.   register_tbe_op();

  2021. 

  2022.   auto graph = std::make_shared<ge::ComputeGraph>("FusionCustom");

  2023.   auto op_desc = std::make_shared<ge::OpDesc>("FusionCustom", "FusionCustom");

  2024.   auto node = graph->AddNode(op_desc);

  2025. 

  2026.   NodeDef *node_def = new NodeDef();

  2027.   std::vector<const NodeDef *> v_input_const1;

  2028.   v_input_const1.push_back(node_def);

  2029. 

  2030.   TensorFlowFusionCustomParserAdapter parser;

  2031.   domi::Status status = parser.ParseParams(v_input_const1, node);

  2032.   EXPECT_EQ(SUCCESS, status);

  2033. 

  2034.   ge::Operator op_src("pool", "pooling");

  2035.   std::vector<ge::Operator> v_input_const2;

  2036.   v_input_const2.push_back(op_src);

  2037.   Status ret = parser.ParseParams(v_input_const2, node);

  2038.   EXPECT_EQ(FAILED, ret);

  2039.   delete node_def;

  2040. }

  2041. 

  2042. TEST_F(STestTensorflowParser, tensorflow_custom_parser_adapter_test)

  2043. {

  2044.   ge::Operator op_src("pool", "pooling");

  2045.   ge::OpDescPtr op_dest = std::make_shared<ge::OpDesc>();

  2046.   TensorFlowCustomParserAdapter parser;

  2047.   Status ret = parser.ParseParams(op_src, op_dest);

  2048.   EXPECT_EQ(ret, FAILED);

  2049. 

  2050.   REGISTER_CUSTOM_OP("Variable")

  2051.     .FrameworkType(domi::TENSORFLOW)

  2052.     .OriginOpType("VariableV2")

  2053.     .ParseParamsFn(ParseParams)

  2054.     .ParseParamsByOperatorFn(ParseParamByOpFunc)

  2055.     .ImplyType(ImplyType::CUSTOM);

  2056.   register_tbe_op();

  2057. 

  2058.   Operator opSrc(ge::parser::VARIABLE, "VariableV2");

  2059.   ret = parser.ParseParams(opSrc, op_dest);

  2060.   EXPECT_EQ(ret, SUCCESS);

  2061. }

  2062. 

  2063. TEST_F(STestTensorflowParser, tensorflow_graph_functiondef_FindAttrValue_test)

  2064. {

  2065.   GraphToFunctionDef functionDef;

  2066.   NodeDef *node_def = nullptr;

  2067.   std::string attr_name = "Const";

  2068.   tensorflow::AttrValue attr_value;

  2069.   bool ret = functionDef.FindAttrValue(node_def, attr_name, attr_value);

  2070.   EXPECT_EQ(ret, false);

  2071. 

  2072.   node_def = initNodeDef();

  2073.   attr_name = ge::ATTR_NAME_INPUT_TENSOR_DESC;

  2074.   node_def->set_name("Const");

  2075.   ret = functionDef.FindAttrValue(node_def, attr_name, attr_value);

  2076.   EXPECT_EQ(ret, false);

  2077. }

  2078. 

  2079. TEST_F(STestTensorflowParser, tensorflow_graph_functiondef_BuildFunctionDef_test)

  2080. {

  2081.   ge::ComputeGraphPtr subGraph = std::make_shared<ge::ComputeGraph>("default");

  2082.   string inputNodeType = "DATA";

  2083.   MakeDagGraph(subGraph, inputNodeType);

  2084. 

  2085.   FunctionDefLibrary library;

  2086.   tensorflow::NodeDef call_node_def;

  2087.   call_node_def.set_op("fusionop");

  2088.   call_node_def.set_name("fusionop");

  2089. 

  2090.   vector<ge::InDataAnchorPtr> in_anchor;

  2091.   vector<ge::OutDataAnchorPtr> out_anchor;

  2092.   for (ge::NodePtr node : subGraph->GetAllNodes()) {

  2093.     for (auto in : node->GetAllInDataAnchors()) {

  2094.       if (in->GetPeerOutAnchor() != nullptr && in->GetPeerOutAnchor()->GetOwnerNode()->GetOpDesc()->GetType() == parser::DATA) {

  2095.           in_anchor.push_back(in);

  2096.       }

  2097.     }

  2098.     for (auto out : node->GetAllOutDataAnchors()) {

  2099.       for (auto i : out->GetPeerInDataAnchors()) {

  2100.           if (i->GetOwnerNode()->GetOpDesc()->GetType() == parser::NETOUTPUT) {

  2101.               out_anchor.push_back(out);

  2102.           }

  2103.         }

  2104.     }

  2105.   }

  2106.   Status ret = GraphToFunctionDef::BuildFunctionDef(subGraph,

  2107.                           "fusionop",

  2108.                           &library,

  2109.                           &call_node_def,

  2110.                           in_anchor,

  2111.                           out_anchor);

  2112.   EXPECT_EQ(domi::INTERNAL_ERROR, ret);

  2113. }

  2114. 

  2115. TEST_F(STestTensorflowParser, tensorflow_CheckOpShapeDim_test)

  2116. {

  2117.   NodeDef *node_def = initNodeDef();

  2118.   std::set<int> dims;

  2119.   dims.insert(1);

  2120.   dims.insert(2);

  2121.   bool valid = true;

  2122.   TensorFlowModelParser parser;

  2123.   Status ret = parser.CheckOpShapeDim(node_def, dims, valid);

  2124.   EXPECT_EQ(ret, SUCCESS);

  2125. 

  2126.   static const string KEY_SHAPE_LIST = "key_shape_list";

  2127.   static const string KEY_TENSOR_LIST = "key_tensor_list";

  2128.   static const string KEY_DEFAULT = "key_default";

  2129. 

  2130.   google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map = node_def->mutable_attr();

  2131.   domi::tensorflow::AttrValue dtype_attr_value;

  2132.   dtype_attr_value.set_type(domi::tensorflow::DT_FLOAT);

  2133.   (*node_attr_map)[TENSORFLOW_ATTR_T] = dtype_attr_value;

  2134. 

  2135.   //设置strides属性

  2136.   domi::tensorflow::AttrValue axis_attr_value;

  2137.   ::tensorflow::AttrValue_ListValue* list = axis_attr_value.mutable_list();

  2138.   list->add_i(1);

  2139.   list->add_i(2);

  2140.   (*node_attr_map)[ge::SQUEEZE_ATTR_AXIS] = axis_attr_value;

  2141. 

  2142.   domi::tensorflow::AttrValue value;

  2143.   domi::tensorflow::AttrValue df_attr_value;

  2144.   df_attr_value.set_i((int64_t)ccTensorFormat_t::CC_TENSOR_NHWC);

  2145. 

  2146.   domi::tensorflow::AttrValue pad_attr_value;

  2147.   pad_attr_value.set_i((int64_t)tensorflow::DT_FLOAT);

  2148. 

  2149.   domi::tensorflow::AttrValue shape;

  2150.   shape.mutable_list()->add_i((int64)32);

  2151.   shape.mutable_list()->add_i((int64)32);

  2152.   shape.mutable_list()->add_i((int64)14);

  2153.   

  2154.   static const string KEY_TYPE_LIST = "key_type_list";

  2155.   const std::string ATTR_NAME_INPUT_TENSOR_DESC  = "input_tensor_desc";

  2156.   const std::string ATTR_NAME_OUTPUT_TENSOR_DESC = "output_tensor_desc";

  2157.   static const  domi::tensorflow::DataType VALUE_TYPE = domi::tensorflow::DataType::DT_FLOAT;

  2158.   value.clear_value();

  2159.   value.mutable_list()->add_type(VALUE_TYPE);

  2160.   TensorFlowUtil::AddNodeAttr(KEY_TYPE_LIST, value, node_def);

  2161. 

  2162.   value.clear_value();

  2163.   domi::tensorflow::NameAttrList name_attr_list;

  2164.   name_attr_list.mutable_attr()->insert({"serialize_datatype", pad_attr_value});

  2165.   name_attr_list.mutable_attr()->insert({"serialize_format", df_attr_value});

  2166.   name_attr_list.mutable_attr()->insert({"serialize_shape", shape});

  2167.   *(value.mutable_list()->add_func()) = name_attr_list;

  2168. 

  2169.   node_def->mutable_attr()->insert({ge::ATTR_NAME_INPUT_TENSOR_DESC, value});

  2170.   node_def->mutable_attr()->insert({ge::ATTR_NAME_OUTPUT_TENSOR_DESC, value});

  2171.   ret = parser.CheckOpShapeDim(node_def, dims, valid);

  2172.   EXPECT_EQ(ret, SUCCESS);

  2173. }

  2174. 

  2175. TEST_F(STestTensorflowParser, tensorflow_Scope_pass_test)

  2176. {

  2177.   ScopePassManager passmanager;

  2178.   auto scope_graph = ge::parser::MakeShared<ge::ScopeGraph>();

  2179.   if (scope_graph == nullptr) {

  2180.     GELOGE(FAILED, "Scope graph make shared failed.");

  2181.     return;

  2182.   }

  2183.   if (scope_graph->Init() != SUCCESS) {

  2184.     GELOGE(FAILED, "Scope graph init failed.");

  2185.     return;

  2186.   }

  2187. 

  2188.   ge::TensorFlowModelParser tf_model_parser;

  2189.   std::vector<string> scope_passes_list = {"ScopeBasicLSTMCellPass", "ScopeLayerNormPass"};

  2190.   Status ret = tf_model_parser.RunScopeFusionPass(scope_passes_list, passmanager, scope_graph);

  2191.   EXPECT_NE(ge::SUCCESS, ret);

  2192. }

  2193. 

  2194. TEST_F(STestTensorflowParser, tensorflow_variable_v2_parser_test)

  2195. {

  2196.   TensorFlowCustomParserAdapter parser;

  2197.   ge::OpDescPtr op_dest = std::make_shared<ge::OpDesc>();

  2198.   NodeDef *node_def = initNodeDef();

  2199.   TensorFlowModelParser modelParser;

  2200.   std::shared_ptr<OpParserFactory> factory = OpParserFactory::Instance(domi::TENSORFLOW);

  2201.   std::shared_ptr<OpParser> op_parser = factory->CreateOpParser("Variable");

  2202.   shared_ptr<TensorFlowOpParser> tensorflow_op_parser = std::dynamic_pointer_cast<TensorFlowOpParser>(op_parser);

  2203.   Status ret = tensorflow_op_parser->ParseParams(node_def, op_dest);

  2204.   EXPECT_EQ(ret, PARAM_INVALID);

  2205. 

  2206.   node_def->set_name("TemporaryVariable");

  2207.   node_def->set_op("TemporaryVariable");

  2208.   op_parser = factory->CreateOpParser("TemporaryVariable");

  2209.   tensorflow_op_parser = std::dynamic_pointer_cast<TensorFlowOpParser>(op_parser);

  2210.   ret = tensorflow_op_parser->ParseParams(node_def, op_dest);

  2211.   EXPECT_EQ(ret, PARAM_INVALID);

  2212. 

  2213.   NodeDef *nodeDef_temporaryVariable = initOpNodeDef_TemporaryVariable();

  2214.   op_parser = factory->CreateOpParser("TemporaryVariable");

  2215.   tensorflow_op_parser = std::dynamic_pointer_cast<TensorFlowOpParser>(op_parser);

  2216.   ret = tensorflow_op_parser->ParseParams(nodeDef_temporaryVariable, op_dest);

  2217.   EXPECT_EQ(ret, SUCCESS);

  2218. 

  2219.   NodeDef *nodeDef_VariableV2 = initOpNodeDef_VariableV2();

  2220.   op_parser = factory->CreateOpParser("Variable");

  2221.   tensorflow_op_parser = std::dynamic_pointer_cast<TensorFlowOpParser>(op_parser);

  2222.   ret = tensorflow_op_parser->ParseParams(nodeDef_VariableV2, op_dest);

  2223.   EXPECT_EQ(ret, SUCCESS);

  2224. }

  2225. 

  2226. TEST_F(STestTensorflowParser, tensorflow_var_is_initialized_op_test)

  2227. {

  2228.   TensorFlowCustomParserAdapter parser;

  2229.   ge::OpDescPtr op_dest = std::make_shared<ge::OpDesc>();

  2230.   NodeDef *node_def = initNodeDef();

  2231.   TensorFlowModelParser modelParser;

  2232.   std::shared_ptr<OpParserFactory> factory = OpParserFactory::Instance(domi::TENSORFLOW);

  2233.   std::shared_ptr<OpParser> op_parser = factory->CreateOpParser("VarIsInitializedOp");

  2234.   shared_ptr<TensorFlowOpParser> tensorflow_op_parser = std::dynamic_pointer_cast<TensorFlowOpParser>(op_parser);

  2235.   Status ret = tensorflow_op_parser->ParseParams(node_def, op_dest);

  2236.   EXPECT_EQ(ret, SUCCESS);

  2237. }

  2238. 

  2239. TEST_F(STestTensorflowParser, tensorflow_arg_parser_test)

  2240. {

  2241.   TensorFlowCustomParserAdapter parser;

  2242.   ge::OpDescPtr op_dest = std::make_shared<ge::OpDesc>();

  2243.   NodeDef *node_def = initNodeDef();

  2244.   TensorFlowModelParser modelParser;

  2245.   std::shared_ptr<OpParserFactory> factory = OpParserFactory::Instance(domi::TENSORFLOW);

  2246.   std::shared_ptr<OpParser> op_parser = factory->CreateOpParser("_Arg");

  2247.   shared_ptr<TensorFlowOpParser> tensorflow_op_parser = std::dynamic_pointer_cast<TensorFlowOpParser>(op_parser);

  2248.   Status ret = tensorflow_op_parser->ParseParams(node_def, op_dest);

  2249.   EXPECT_EQ(ret, SUCCESS);

  2250. 

  2251.   static const string KEY_SHAPE_LIST = "key_shape_list";

  2252.   static const string KEY_TENSOR_LIST = "key_tensor_list";

  2253.   static const string KEY_DEFAULT = "key_default";

  2254. 

  2255.   google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map = node_def->mutable_attr();

  2256.   domi::tensorflow::AttrValue dtype_attr_value;

  2257.   dtype_attr_value.set_type(domi::tensorflow::DT_FLOAT);

  2258.   (*node_attr_map)[TENSORFLOW_ATTR_T] = dtype_attr_value;

  2259. 

  2260.   //设置strides属性

  2261.   domi::tensorflow::AttrValue axis_attr_value;

  2262.   ::tensorflow::AttrValue_ListValue* list = axis_attr_value.mutable_list();

  2263.   list->add_i(1);

  2264.   list->add_i(2);

  2265.   (*node_attr_map)[ge::SQUEEZE_ATTR_AXIS] = axis_attr_value;

  2266. 

  2267.   domi::tensorflow::AttrValue value;

  2268.   domi::tensorflow::AttrValue df_attr_value;

  2269.   df_attr_value.set_i((int64_t)ccTensorFormat_t::CC_TENSOR_NHWC);

  2270. 

  2271.   domi::tensorflow::AttrValue pad_attr_value;

  2272.   pad_attr_value.set_i((int64_t)tensorflow::DT_FLOAT);

  2273. 

  2274.   domi::tensorflow::AttrValue shape;

  2275.   shape.mutable_list()->add_i((int64)32);

  2276.   shape.mutable_list()->add_i((int64)32);

  2277.   shape.mutable_list()->add_i((int64)14);

  2278.   

  2279.   static const string KEY_TYPE_LIST = "key_type_list";

  2280.   const std::string ATTR_NAME_INPUT_TENSOR_DESC  = "input_tensor_desc";

  2281.   const std::string ATTR_NAME_OUTPUT_TENSOR_DESC = "output_tensor_desc";

  2282.   static const  domi::tensorflow::DataType VALUE_TYPE = domi::tensorflow::DataType::DT_FLOAT;

  2283.   value.clear_value();

  2284.   value.mutable_list()->add_type(VALUE_TYPE);

  2285.   TensorFlowUtil::AddNodeAttr(KEY_TYPE_LIST, value, node_def);

  2286. 

  2287.   value.clear_value();

  2288.   domi::tensorflow::NameAttrList name_attr_list;

  2289.   name_attr_list.mutable_attr()->insert({"serialize_datatype", pad_attr_value});

  2290.   name_attr_list.mutable_attr()->insert({"serialize_format", df_attr_value});

  2291.   name_attr_list.mutable_attr()->insert({"serialize_shape", shape});

  2292.   *(value.mutable_list()->add_func()) = name_attr_list;

  2293. 

  2294.   node_def->mutable_attr()->insert({ge::ATTR_NAME_INPUT_TENSOR_DESC, value});

  2295.   node_def->mutable_attr()->insert({ge::ATTR_NAME_OUTPUT_TENSOR_DESC, value});

  2296.   ret = tensorflow_op_parser->ParseParams(node_def, op_dest);

  2297.   EXPECT_EQ(ret, SUCCESS);

  2298. }

  2299. 

  2300. TEST_F(STestTensorflowParser, tensorflow_frameworkop_parser_test1)

  2301. {

  2302.   TensorFlowCustomParserAdapter parser;

  2303.   ge::OpDescPtr op_dest = std::make_shared<ge::OpDesc>();

  2304.   NodeDef *node_def = initNodeDef();

  2305.   TensorFlowModelParser modelParser;

  2306.   std::shared_ptr<OpParserFactory> factory = OpParserFactory::Instance(domi::TENSORFLOW);

  2307.   std::shared_ptr<OpParser> op_parser = factory->CreateOpParser("FrameworkOp");

  2308.   shared_ptr<TensorFlowOpParser> tensorflow_op_parser = std::dynamic_pointer_cast<TensorFlowOpParser>(op_parser);

  2309.   Status ret = tensorflow_op_parser->ParseParams(node_def, op_dest);

  2310.   EXPECT_EQ(ret, PARAM_INVALID);

  2311. 

  2312.   ChangeDataType(node_def, tensorflow::DT_UINT16);

  2313.   ret = tensorflow_op_parser->ParseParams(node_def, op_dest);

  2314.   EXPECT_EQ(ret, PARAM_INVALID);

  2315. }

  2316. 

  2317. TEST_F(STestTensorflowParser, tensorflow_frameworkop_parser_test2)

  2318. {

  2319.   TensorFlowCustomParserAdapter parser;

  2320.   ge::OpDescPtr op_dest = std::make_shared<ge::OpDesc>();

  2321.   NodeDef *node_def = initNodeDef();

  2322.   node_def->set_name("FrameworkOp");

  2323.   node_def->set_op("_Retval");

  2324.   TensorFlowModelParser modelParser;

  2325.   std::shared_ptr<OpParserFactory> factory = OpParserFactory::Instance(domi::TENSORFLOW);

  2326.   std::shared_ptr<OpParser> op_parser = factory->CreateOpParser("FrameworkOp");

  2327.   shared_ptr<TensorFlowOpParser> tensorflow_op_parser = std::dynamic_pointer_cast<TensorFlowOpParser>(op_parser);

  2328.   static const string KEY_SHAPE_LIST = "key_shape_list";

  2329.   static const string KEY_TENSOR_LIST = "key_tensor_list";

  2330.   static const string KEY_DEFAULT = "key_default";

  2331. 

  2332.   google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map = node_def->mutable_attr();

  2333.   domi::tensorflow::AttrValue dtype_attr_value;

  2334.   dtype_attr_value.set_type(domi::tensorflow::DT_FLOAT);

  2335.   (*node_attr_map)[TENSORFLOW_ATTR_T] = dtype_attr_value;

  2336. 

  2337.   //设置strides属性

  2338.   domi::tensorflow::AttrValue axis_attr_value;

  2339.   ::tensorflow::AttrValue_ListValue* list = axis_attr_value.mutable_list();

  2340.   list->add_i(1);

  2341.   list->add_i(2);

  2342.   (*node_attr_map)[ge::SQUEEZE_ATTR_AXIS] = axis_attr_value;

  2343. 

  2344.   domi::tensorflow::AttrValue value;

  2345.   domi::tensorflow::AttrValue df_attr_value;

  2346.   df_attr_value.set_i((int64_t)ccTensorFormat_t::CC_TENSOR_NHWC);

  2347. 

  2348.   domi::tensorflow::AttrValue pad_attr_value;

  2349.   pad_attr_value.set_i((int64_t)tensorflow::DT_FLOAT);

  2350. 

  2351.   domi::tensorflow::AttrValue shape;

  2352.   shape.mutable_list()->add_i((int64)32);

  2353.   shape.mutable_list()->add_i((int64)32);

  2354.   shape.mutable_list()->add_i((int64)14);

  2355.   

  2356.   static const string KEY_TYPE_LIST = "key_type_list";

  2357.   const std::string ATTR_NAME_INPUT_TENSOR_DESC  = "ATTR_NAME_FRAMEWORK_OP_DEF";

  2358.   const std::string ATTR_NAME_OUTPUT_TENSOR_DESC = "output_tensor_desc";

  2359.   static const  domi::tensorflow::DataType VALUE_TYPE = domi::tensorflow::DataType::DT_FLOAT;

  2360.   value.clear_value();

  2361.   value.mutable_list()->add_type(VALUE_TYPE);

  2362.   TensorFlowUtil::AddNodeAttr(KEY_TYPE_LIST, value, node_def);

  2363. 

  2364.   value.clear_value();

  2365.   domi::tensorflow::NameAttrList name_attr_list;

  2366.   name_attr_list.mutable_attr()->insert({"serialize_datatype", pad_attr_value});

  2367.   name_attr_list.mutable_attr()->insert({"serialize_format", df_attr_value});

  2368.   name_attr_list.mutable_attr()->insert({"serialize_shape", shape});

  2369.   *(value.mutable_list()->add_func()) = name_attr_list;

  2370. 

  2371.   node_def->mutable_attr()->insert({ge::ATTR_NAME_INPUT_TENSOR_DESC, value});

  2372.   node_def->mutable_attr()->insert({ge::ATTR_NAME_OUTPUT_TENSOR_DESC, value});

  2373.   Status ret = tensorflow_op_parser->ParseParams(node_def, op_dest);

  2374.   EXPECT_EQ(ret, SUCCESS);

  2375. }

  2376. 

  2377. TEST_F(STestTensorflowParser, tensorflow_reshape_parser_test)

  2378. {

  2379.   TensorFlowCustomParserAdapter parser;

  2380.   ge::OpDescPtr op_dest = std::make_shared<ge::OpDesc>();

  2381.   NodeDef *node_def = initNodeDef();

  2382.   TensorFlowModelParser modelParser;

  2383.   std::shared_ptr<OpParserFactory> factory = OpParserFactory::Instance(domi::TENSORFLOW);

  2384.   std::shared_ptr<OpParser> op_parser = factory->CreateOpParser("Reshape");

  2385.   shared_ptr<TensorFlowOpParser> tensorflow_op_parser = std::dynamic_pointer_cast<TensorFlowOpParser>(op_parser);

  2386.   Status ret = tensorflow_op_parser->ParseParams(node_def, op_dest);

  2387.   EXPECT_EQ(ret, SUCCESS);

  2388. 

  2389.   NodeDef * nodeDef = new NodeDef();

  2390.   nodeDef->set_op("Reshape");

  2391.   google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* node_attr_map = nodeDef->mutable_attr();

  2392.   domi::tensorflow::AttrValue attr_value;

  2393.   attr_value.mutable_list()->add_i((int64)32);

  2394.   attr_value.mutable_list()->add_i((int64)32);

  2395.   attr_value.mutable_list()->add_i((int64)14);

  2396. 

  2397.   domi::tensorflow::AttrValue df_attr_value2;

  2398.   df_attr_value2.set_s(TENSORFLOWF_TENSOR_NHWC);

  2399.   (*node_attr_map)[TENSORFLOW_ATTR_DATA_FORMAT] = df_attr_value2;

  2400.   domi::tensorflow::AttrValue df_attr_value;

  2401.   df_attr_value.set_i((int64_t)ccTensorFormat_t::CC_TENSOR_NHWC);

  2402. 

  2403.   //设置padding属性

  2404.   domi::tensorflow::AttrValue pad_attr_value2;

  2405.   pad_attr_value2.set_s(TENSORFLOWF_OP_PADDING_SAME);

  2406.   (*node_attr_map)[TENSORFLOW_ATTR_PADDING] = pad_attr_value2;

  2407.   domi::tensorflow::AttrValue pad_attr_value;

  2408.   pad_attr_value.set_i((int64_t)tensorflow::DT_FLOAT);

  2409. 

  2410.   domi::tensorflow::NameAttrList name_attr_list;

  2411.   name_attr_list.mutable_attr()->insert({"serialize_shape", attr_value});

  2412.   name_attr_list.mutable_attr()->insert({"serialize_format", df_attr_value});

  2413.   name_attr_list.mutable_attr()->insert({"serialize_datatype", pad_attr_value});

  2414.   *(attr_value.mutable_list()->add_func()) = name_attr_list;

  2415. 

  2416.   GeTensorDesc ge_desc;

  2417.   ge_desc.SetFormat(ge::FORMAT_C1HWNCoC0);

  2418.   ge_desc.SetDataType(ge::DT_FLOAT);

  2419.   ge_desc.SetShape(GeShape({1,1,1,1,1,1}));

  2420.   TensorFlowReshapeParser reshapeParser;

  2421.   ret = reshapeParser.ParseDesc(attr_value, ge_desc);

  2422.   EXPECT_EQ(ret, SUCCESS);

  2423. }

  2424. 

  2425. TEST_F(STestTensorflowParser, tensorflow_DefunToPartitionedCall_parser_test)

  2426. {

  2427.   TensorFlowModelParser parser;

  2428.   NodeDef *node_def = initNodeDef();

  2429.   node_def->set_name("ShapeN");

  2430.   ge::OpDescPtr op = make_shared<ge::OpDesc>("ShapeN", ge::parser::PARTITIONEDCALL);

  2431.   Status ret = parser.DefunToPartitionedCall(node_def, op);

  2432.   EXPECT_EQ(ret, FAILED);

  2433. 

  2434.   static const string KEY_SHAPE_LIST = "key_shape_list";

  2435.   static const string KEY_TENSOR_LIST = "key_tensor_list";

  2436.   static const string KEY_DEFAULT = "key_default";

  2437. 

  2438.   google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map = node_def->mutable_attr();

  2439.   domi::tensorflow::AttrValue dtype_attr_value;

  2440.   dtype_attr_value.set_type(domi::tensorflow::DT_FLOAT);

  2441.   (*node_attr_map)[TENSORFLOW_ATTR_T] = dtype_attr_value;

  2442. 

  2443.   //设置strides属性

  2444.   domi::tensorflow::AttrValue axis_attr_value;

  2445.   ::tensorflow::AttrValue_ListValue* list = axis_attr_value.mutable_list();

  2446.   list->add_i(1);

  2447.   list->add_i(2);

  2448.   (*node_attr_map)[ge::SQUEEZE_ATTR_AXIS] = axis_attr_value;

  2449. 

  2450.   domi::tensorflow::AttrValue value;

  2451.   domi::tensorflow::AttrValue df_attr_value;

  2452.   df_attr_value.set_i((int64_t)ccTensorFormat_t::CC_TENSOR_NHWC);

  2453. 

  2454.   domi::tensorflow::AttrValue pad_attr_value;

  2455.   pad_attr_value.set_i((int64_t)tensorflow::DT_FLOAT);

  2456. 

  2457.   domi::tensorflow::AttrValue shape;

  2458.   shape.mutable_list()->add_i((int64)32);

  2459.   shape.mutable_list()->add_i((int64)32);

  2460.   shape.mutable_list()->add_i((int64)14);

  2461.   

  2462.   static const string KEY_TYPE_LIST = "key_type_list";

  2463.   static const  domi::tensorflow::DataType VALUE_TYPE = domi::tensorflow::DataType::DT_FLOAT;

  2464.   value.clear_value();

  2465.   value.mutable_list()->add_type(VALUE_TYPE);

  2466.   TensorFlowUtil::AddNodeAttr(KEY_TYPE_LIST, value, node_def);

  2467. 

  2468.   value.clear_value();

  2469.   domi::tensorflow::NameAttrList name_attr_list;

  2470.   name_attr_list.mutable_attr()->insert({"serialize_datatype", pad_attr_value});

  2471.   name_attr_list.mutable_attr()->insert({"serialize_format", df_attr_value});

  2472.   name_attr_list.mutable_attr()->insert({"serialize_shape", shape});

  2473.   *(value.mutable_list()->add_func()) = name_attr_list;

  2474. 

  2475.   node_def->mutable_attr()->insert({"_disable_call_shape_inference", value});

  2476.   node_def->mutable_attr()->insert({"_disable_call_shape_inference", value});

  2477.   std::string fusion_op_name = "pre_node_a";

  2478.   GenOriginContext(&parser, fusion_op_name);

  2479.   node_def->set_name("pre_node_a");

  2480.   ret = parser.DefunToPartitionedCall(node_def, op);

  2481.   EXPECT_EQ(ret, SUCCESS);

  2482. }

  2483. 

  2484. TEST_F(STestTensorflowParser, tensorflow_TransNodeToOpDesc_parser_test)

  2485. {

  2486.   TensorFlowModelParser parser;

  2487.   NodeDef *node_def = initNodeDef();

  2488.   node_def->set_name("ge::parser::DATA");

  2489.   std::string op_type = "ge::parser::DATA";

  2490.   ge::OpDescPtr op = make_shared<ge::OpDesc>("constant", ge::parser::CONSTANT);

  2491.   Status ret = parser.TransNodeToOpDesc(node_def, op, op_type);

  2492.   EXPECT_EQ(ret, FAILED);

  2493. }

  2494. 

  2495. domi::Status fusion_parse_param_by_op(const std::vector<ge::Operator> &op_src, ge::Operator &op) {

  2496.   return domi::SUCCESS;

  2497. }

  2498. 

  2499. TEST_F(STestTensorflowParser, Fusion_node_parse_params_success) {

  2500.   ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);

  2501. 

  2502.   ModelParserFactory* factory = ModelParserFactory::Instance();

  2503.   shared_ptr<ModelParser> model_parser= factory->CreateModelParser(domi::TENSORFLOW);

  2504.   ASSERT_TRUE(NULL != model_parser);

  2505.   TensorFlowModelParser tensorflow_parser;

  2506.   domi::tensorflow::NodeDef node_def;

  2507.   node_def.set_name("data");

  2508.   node_def.set_op("FusionCustom");

  2509. 

  2510.   FusionParseParamByOpFunc function = fusion_parse_param_by_op;

  2511.   shared_ptr<ge::OpParserFactory> op_parser = ge::OpParserFactory::Instance(domi::TENSORFLOW);

  2512.   shared_ptr<OpParser> fusion_op_parser = op_parser->CreateFusionOpParser("FusionCustom");

  2513. 

  2514.   ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);

  2515.   ge::OpDescPtr op1 = std::make_shared<ge::OpDesc>("data", "FusionCustom");

  2516.   ge::NodePtr node1 = std::make_shared<ge::Node>(op1, graph);

  2517. 

  2518.   vector<const NodeDef *> node_defs;

  2519.   node_defs.push_back(&node_def);

  2520. 

  2521.   tensorflow_parser.fusion_op_nodedef_map_["data"] = node_defs;

  2522.   Status ret = tensorflow_parser.FusionNodeParseParams(fusion_op_parser, &node_def, node1);

  2523.   EXPECT_EQ(domi::SUCCESS, ret);

  2524. }

  2525. 

  2526. TEST_F(STestTensorflowParser, Tensorflow_recordFusionResult_parser_test)

  2527. {

  2528.   auto scope_graph = ge::parser::MakeShared<ge::ScopeGraph>();

  2529.   if (scope_graph == nullptr) {

  2530.     GELOGE(FAILED, "Scope graph make shared failed.");

  2531.     return;

  2532.   }

  2533. 

  2534.   if (scope_graph->Init() != SUCCESS) {

  2535.     GELOGE(FAILED, "Scope graph init failed.");

  2536.     return;

  2537.   }

  2538. 

  2539.   domi::tensorflow::NodeDef node_def;

  2540.   node_def.set_name("OP");

  2541.   FusionScopesResult *fusion_scope_rlt = new (std::nothrow) FusionScopesResult();

  2542.   if (fusion_scope_rlt == nullptr) {

  2543.     GELOGE(FAILED, "FusionScopesResult make shared failed.");

  2544.     return;

  2545.   }

  2546.   fusion_scope_rlt->Init();

  2547.   fusion_scope_rlt->SetName("OP");

  2548.   auto &impl_scope_graph = scope_graph->impl_;

  2549.   std::string scope_name = fusion_scope_rlt->Name();

  2550.   impl_scope_graph->fusion_results_.insert(std::make_pair(scope_name, fusion_scope_rlt));

  2551.   std::vector<ge::OperatorPtr> nodes;

  2552.   ge::OperatorPtr op = ge::parser::MakeShared<ge::Operator>("op_name", "op_type");

  2553.   if (op == nullptr) {

  2554.     GELOGE(FAILED, "Operator make shared failed.");

  2555.     return;

  2556.   }

  2557.   nodes.push_back(op);

  2558.   fusion_scope_rlt->impl_->AddNodes(nodes);

  2559. 

  2560.   ge::OpDescPtr opDesc = std::make_shared<ge::OpDesc>();

  2561.   ge::TensorFlowModelParser tf_model_parser;

  2562.   Status ret = tf_model_parser.RecordFusionResult(scope_graph, &node_def, opDesc);

  2563.   EXPECT_EQ(SUCCESS, ret);

  2564. }

  2565. 

  2566. TEST_F(STestTensorflowParser, Tensorflow_UpdateFusionOpContext_test)

  2567. {

  2568.   ModelParserFactory* factory = ModelParserFactory::Instance();

  2569.   shared_ptr<domi::ModelParser> model_parser = factory->CreateModelParser(domi::TENSORFLOW);

  2570.   TensorFlowModelParser tensorflow_parser;

  2571.   ScopeFusionOpInfo info;

  2572.   ge::OpNodeContext normal_op_node_context;

  2573.   ge::OpNodeContext fusion_op_node_context;

  2574. 

  2575.   /* 1.预置条件 */

  2576.   tensorflow::GraphDef *graph = new tensorflow::GraphDef();

  2577.   ScopePassManager passmanager;

  2578.   shared_ptr<ScopeGraph> scope_graph = passmanager.BuildScopeGraph(graph);

  2579.   NodeDef * node1 = graph->add_node();

  2580.   node1->set_name("conv_conv5/BatchNorm/batchnorm/add");

  2581.   node1->set_op("Add");

  2582.   node1->add_input("conv_conv5/BatchNorm/moving_variance");

  2583.   node1->add_input("conv_conv5/BatchNorm/batchnorm/add/y");

  2584. 

  2585.   NodeDef * node2 = graph->add_node();

  2586.   node2->set_name("conv_conv5/BatchNorm/moving_variance");

  2587.   node2->set_op("Const");

  2588. 

  2589.   NodeDef * node3 = graph->add_node();

  2590.   node3->set_name("conv_conv5/BatchNorm/batchnorm/add/y");

  2591.   node3->set_op("Const");

  2592. 

  2593.   info.fusion_node_name = "conv_conv5/BatchNorm/batchnorm";

  2594.   info.fusion_op_type = ge::parser::FUSIONBATCHNORM;

  2595.   info.node_name = "conv_conv5/BatchNorm/batchnorm/add";

  2596.   info.description = "";

  2597.   info.scope_pass = false;

  2598. 

  2599.   EXPECT_EQ(scope_graph->impl_->GetFusionScopesResults(nullptr), nullptr);

  2600.   EXPECT_EQ(scope_graph->impl_->GetFusionScopesResults(node1), nullptr);

  2601. 

  2602.   Status ret = tensorflow_parser.UpdateFusionOpContext(scope_graph, info, fusion_op_node_context, normal_op_node_context);

  2603.   EXPECT_EQ(ret, domi::SUCCESS);

  2604.   delete graph;

  2605. }

  2606. 

  2607. TEST_F(STestTensorflowParser, Tensorflow_GetInOutPutIndex_scope_pass)

  2608. {

  2609.   ModelParserFactory* factory = ModelParserFactory::Instance();

  2610.   shared_ptr<domi::ModelParser> model_parser = factory->CreateModelParser(domi::TENSORFLOW);

  2611.   TensorFlowModelParser tensorflow_parser;

  2612. 

  2613.   tensorflow::GraphDef *graph = new tensorflow::GraphDef();

  2614.   ScopePassManager passmanager;

  2615.   shared_ptr<ScopeGraph> scope_graph = passmanager.BuildScopeGraph(graph);

  2616.   FusionScopesResult* fusion_rlt = new FusionScopesResult();

  2617.   fusion_rlt->Init();

  2618.   fusion_rlt->impl_->inputs_.insert(std::make_pair<string, vector<int32_t>>("fw/fw/ToInt32" ,{0}));

  2619.   fusion_rlt->impl_->inputs_.insert(std::make_pair<string, vector<int32_t>>("bw/bw/ToInt32" ,{0}));

  2620.   fusion_rlt->impl_->inputs_.insert(std::make_pair<string, vector<int32_t>>("bw/ReverseSequence" ,{0, 1}));

  2621.   fusion_rlt->impl_->inputs_.insert(std::make_pair<string, vector<int32_t>>("bw/ReverseSequence" ,{1}));

  2622. 

  2623.   fusion_rlt->impl_->outputs_.insert(std::make_pair<string, vector<int32_t>>("concat" ,{0}));

  2624.   fusion_rlt->impl_->outputs_.insert(std::make_pair<string, vector<int32_t>>("fw/fw/while/Exit_3" ,{1}));

  2625.   fusion_rlt->impl_->outputs_.insert(std::make_pair<string, vector<int32_t>>("fw/fw/while/Exit_4" ,{2}));

  2626.   fusion_rlt->impl_->outputs_.insert(std::make_pair<string, vector<int32_t>>("bw/bw/while/Exit_3" ,{3}));

  2627.   fusion_rlt->impl_->outputs_.insert(std::make_pair<string, vector<int32_t>>("bw/bw/while/Exit_4" ,{4}));

  2628.   fusion_rlt->SetType("dynamic_rnn");

  2629.   fusion_rlt->SetName("dynamic_rnn_node1");

  2630.   scope_graph->impl_->AddFusionScopesResult(fusion_rlt);

  2631. 

  2632.   ScopeFusionOpInfo info1;

  2633.   info1.node_name = "fw/fw/ToInt32";

  2634.   info1.fusion_node_name = "dynamic_rnn_node1";

  2635.   info1.fusion_op_type = "dynamic_rnn";

  2636.   info1.description = "";

  2637.   info1.scope_pass = true;

  2638. 

  2639.   bool ignore = false;

  2640.   ignore = tensorflow_parser.FusionOpChildIgnore(scope_graph, info1);

  2641.   EXPECT_EQ(true, !ignore);

  2642. 

  2643.   ScopeFusionOpInfo info2;

  2644.   info2.node_name = "fw/fw/others";

  2645.   info2.fusion_node_name = "dynamic_rnn_node1";

  2646.   info2.fusion_op_type = "dynamic_rnn";

  2647.   info2.description = "";

  2648.   info2.scope_pass = true;

  2649. 

  2650.   ignore = tensorflow_parser.FusionOpChildIgnore(scope_graph, info2);

  2651.   EXPECT_EQ(true, ignore);

  2652. 

  2653.   ScopeFusionOpInfo input_node_info;

  2654.   input_node_info.node_name = "fw/fw/ToInt32";

  2655.   input_node_info.fusion_node_name = "dynamic_rnn_node1";

  2656.   input_node_info.fusion_op_type = "dynamic_rnn";

  2657.   input_node_info.description = "";

  2658.   input_node_info.scope_pass = true;

  2659. 

  2660.   ScopeFusionOpInfo output_node_info;

  2661.   output_node_info.node_name = "fw/fw/while/Exit_3";

  2662.   output_node_info.fusion_node_name = "dynamic_rnn_node1";

  2663.   output_node_info.fusion_op_type = "dynamic_rnn";

  2664.   output_node_info.description = "";

  2665.   output_node_info.scope_pass = true;

  2666. 

  2667.   int32_t old_index = 0, new_index = -1;

  2668.   Status ret = tensorflow_parser.GetInPutIndex(scope_graph, input_node_info, old_index, new_index);

  2669.   EXPECT_EQ(domi::SUCCESS, ret);

  2670.   EXPECT_EQ(true, (new_index == 0));

  2671. 

  2672.   ret = tensorflow_parser.GetOutPutIndex(scope_graph, output_node_info, old_index, new_index);

  2673.   EXPECT_EQ(domi::SUCCESS, ret);

  2674.   EXPECT_EQ(true, (new_index == 1));

  2675.   delete graph;

  2676. }

  2677. 

  2678. TEST_F(STestTensorflowParser, Tensorflow_AddFusionNodeDef_add_fusion_op_succ)

  2679. {

  2680.   ModelParserFactory* factory = ModelParserFactory::Instance();

  2681.   shared_ptr<domi::ModelParser> model_parser = factory->CreateModelParser(domi::TENSORFLOW);

  2682.   TensorFlowModelParser tensorflow_parser;

  2683.   string fusion_op_name = "dropout";

  2684.   string fusion_op_type = "Dropout";

  2685.   string description = "test/dropout";

  2686.   tensorflow_parser.fusion_op_type_map_[fusion_op_name].push_back(fusion_op_type);

  2687.   tensorflow_parser.fusion_op_type_map_[fusion_op_name].push_back(description);

  2688. 

  2689.   // op_node_context for fusion op

  2690.   ge::OpNodeContext op_node_context;

  2691.   op_node_context.input_map["pre_node_a"].push_back({0, 0});

  2692.   op_node_context.input_map["pre_node_b"].push_back({0, 1});

  2693.   tensorflow_parser.op_node_context_map_[fusion_op_name] = op_node_context;

  2694. 

  2695.   // origin inner node def

  2696.   NodeDef* node_def = new (std::nothrow) NodeDef();

  2697.   node_def->set_name("scope_node_1");

  2698.   node_def->set_op("Add");

  2699.   tensorflow_parser.fusion_op_nodedef_map_[fusion_op_name].push_back(node_def);

  2700. 

  2701.   ScopePassManager pass_manager;

  2702.   tensorflow::GraphDef *graph = new (std::nothrow) tensorflow::GraphDef();

  2703.   shared_ptr<ScopeGraph> scope_graph = pass_manager.BuildScopeGraph(graph);

  2704.   vector<string> node_name_list = {fusion_op_name};

  2705.   Status ret = tensorflow_parser.AddFusionNodeDef(scope_graph, node_name_list);

  2706.   EXPECT_EQ(ret, SUCCESS);

  2707.   EXPECT_EQ(tensorflow_parser.nodedef_map_.size(), 1);

  2708.   auto fusion_node_def = tensorflow_parser.nodedef_map_[fusion_op_name];

  2709.   EXPECT_NE(fusion_node_def, nullptr);

  2710.   EXPECT_EQ(fusion_node_def->op(), fusion_op_type);

  2711. 

  2712.   delete node_def;

  2713.   delete graph;

  2714.   tensorflow_parser.DeleteFuisonNodeDef();

  2715. }

  2716. 

  2717. TEST_F(STestTensorflowParser, remain_dpop_node)

  2718. {

  2719.   ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);

  2720.   ge::OpDescPtr op = std::make_shared<ge::OpDesc>("dpop_123", "FrameworkOp");

  2721.   ge::NodePtr node = std::make_shared<ge::Node>(op, graph);

  2722.   graph->AddNode(node);

  2723.   ModelParserFactory* factory = ModelParserFactory::Instance();

  2724.   shared_ptr<domi::ModelParser> model_parser= factory->CreateModelParser(domi::TENSORFLOW);

  2725.   ASSERT_TRUE(NULL != model_parser);

  2726. 

  2727.   TensorFlowModelParser tensorflow_parser;

  2728.   Status ret = tensorflow_parser.RemoveIsolateNode(graph);

  2729.   EXPECT_EQ(domi::SUCCESS, ret);

  2730. }

  2731. 

  2732. TEST_F(STestTensorflowParser, tensorflow_UpdateEdgesControlInfo_test)

  2733. {

  2734.   TensorFlowModelParser model_parser;

  2735.   ge::ScopeFusionOpInfo info;

  2736.   info.fusion_node_name = "conv_conv5/BatchNorm/batchnorm";

  2737.   info.fusion_op_type = ge::parser::FUSIONBATCHNORM;

  2738.   info.node_name = "conv_conv5/BatchNorm/batchnorm/add";

  2739.   info.description = "";

  2740.   info.scope_pass = false;

  2741.   model_parser.UpdateEdgesControlInfo(info);

  2742. }

  2743. 

  2744. TEST_F(STestTensorflowParser, tensorflow_OptimizeSnapShot_test)

  2745. {

  2746.   TensorFlowModelParser model_parser;

  2747.   tensorflow::NodeDef *curr_mode_def = initNodeDef();

  2748.   std::map<string, NodeDef *> nodedef_map;

  2749.   nodedef_map.emplace("pre_node_a", curr_mode_def);

  2750.   std::pair<string, int> input_data;

  2751.   std::vector<string> control_list;

  2752.   std::string curr_node_name = "pre_node_a";

  2753.   GenOriginContext(&model_parser, curr_node_name);

  2754.   Status ret = model_parser.OptimizeSnapShot(curr_mode_def, nodedef_map, input_data, control_list);

  2755.   EXPECT_EQ(ret, INTERNAL_ERROR);

  2756. 

  2757.   curr_mode_def->set_name("pre_node_a");

  2758.   GenOriginContext(&model_parser, curr_node_name);

  2759.   ret = model_parser.OptimizeSnapShot(curr_mode_def, nodedef_map, input_data, control_list);

  2760.   EXPECT_EQ(ret, SUCCESS);

  2761. }

  2762. 

  2763. TEST_F(STestTensorflowParser, tensorflow_GraphDefOptimizeSnapShot_test)

  2764. {

  2765.   TensorFlowModelParser model_parser;

  2766.   tensorflow::GraphDef graph_def;

  2767.   tensorflow::NodeDef *curr_mode_def = initNodeDef();

  2768.   std::map<string, NodeDef *> nodedef_map;

  2769.   nodedef_map.emplace("pre_node_a", curr_mode_def);

  2770.   std::vector<NodeDef *> nodedef_to_optimize;

  2771.   nodedef_to_optimize.emplace_back(curr_mode_def);

  2772.   Status ret = model_parser.GraphDefOptimizeSnapShot(&graph_def, nodedef_map, nodedef_to_optimize);

  2773.   EXPECT_EQ(ret, FAILED);

  2774. }

  2775. 

  2776. TEST_F(STestTensorflowParser, tensorflow_SetDestNodeName_test)

  2777. {

  2778.   TensorFlowModelParser model_parser;

  2779.   GraphDef graph;

  2780.   auto arg0 = AddNode(graph, "_Arg", "arg0");

  2781.   auto identity0 = AddNode(graph, "Identity", "identity0");

  2782.   auto add0 = AddNode(graph, "Add", "add0");

  2783. 

  2784.   int32_t input_idx = 0;

  2785.   bool is_control = true;

  2786.   bool clear_input_flag = true;

  2787.   AddInput(arg0, identity0, 0);

  2788.   AddInput(identity0, add0, 0);

  2789.   Status ret = model_parser.SetDestNodeName(identity0, add0, input_idx, is_control, clear_input_flag);

  2790.   EXPECT_EQ(ret, SUCCESS);

  2791. }

  2792. 

  2793. TEST_F(STestTensorflowParser, tensorflow_OptimizeDestroyTemporaryVariable_test)

  2794. {

  2795.   ModelParserFactory* factory = ModelParserFactory::Instance();

  2796.   shared_ptr<domi::ModelParser> model_parser= factory->CreateModelParser(domi::TENSORFLOW);

  2797.   TensorFlowModelParser tensorflow_parser;

  2798. 

  2799.   GraphDef graph;

  2800.   auto const0 = AddNode(graph, "Const", "Const0");

  2801.   auto tmpVar0 = AddNode(graph, "TemporaryVariable", "TemporaryVariable0");

  2802.   auto assign0 = AddNode(graph, "Assign", "Assign0");

  2803.   auto destroy0 = AddNode(graph, "DestroyTemporaryVariable", "DestroyTemporaryVariable0");

  2804.   auto add0 = AddNode(graph, "Add", "Add0");

  2805. 

  2806.   google::protobuf::Map< std::string, tensorflow::AttrValue> *node_attr_map = tmpVar0->mutable_attr();

  2807.   tensorflow::AttrValue var_name_attr_value;

  2808.   var_name_attr_value.set_s("temporary_variable_name");

  2809.   (*node_attr_map)[ge::VAR_ATTR_NAME] = var_name_attr_value;

  2810. 

  2811.   google::protobuf::Map<std::string, tensorflow::AttrValue>* node_attr_map_destroy = destroy0->mutable_attr();

  2812.   tensorflow::AttrValue var_name_attr_value_destroy;

  2813.   var_name_attr_value_destroy.set_s("destroy_temporary_variable_name");

  2814.   (*node_attr_map_destroy)[ge::VAR_ATTR_NAME] = var_name_attr_value_destroy;

  2815. 

  2816.   AddInput(tmpVar0, assign0, 0);

  2817.   AddInput(assign0, destroy0, 0);

  2818.   AddInput(const0, add0, 0);

  2819.   AddInput(destroy0, add0, 1);

  2820. 

  2821.   GraphDef* graphDef = &graph;

  2822.   int32_t no_input_node_size_original = 0;

  2823.   for (int w = 0; w < graphDef->node_size(); w++) {

  2824.       tensorflow::NodeDef* nodeTmp = graphDef->mutable_node(w);

  2825.       if (nodeTmp->input_size() == 0) {

  2826.         no_input_node_size_original++;

  2827.       }

  2828.   }

  2829. 

  2830.   Status ret = tensorflow_parser.GraphDefOptimize(graphDef);

  2831.   int32_t no_input_node_size_result = 0;

  2832.   for (int w = 0; w < graphDef->node_size(); w++) {

  2833.       tensorflow::NodeDef* nodeTmp = graphDef->mutable_node(w);

  2834.       if (nodeTmp->input_size() == 0) {

  2835.         no_input_node_size_result ++;

  2836.       }

  2837.   }

  2838.   ASSERT_EQ(ret, domi::FAILED);

  2839.   ASSERT_EQ(no_input_node_size_original, no_input_node_size_result);

  2840. }

  2841. 

  2842. TEST_F(STestTensorflowParser, tensorflow_OptimizeDestroyTemporaryVariable_test2)

  2843. {

  2844.   ModelParserFactory* factory = ModelParserFactory::Instance();

  2845.   shared_ptr<domi::ModelParser> model_parser= factory->CreateModelParser(domi::TENSORFLOW);

  2846.   TensorFlowModelParser tensorflow_parser;

  2847. 

  2848.   GraphDef graph;

  2849.   auto const0 = AddNode(graph, "Const", "Const0");

  2850.   auto tmpVar0 = AddNode(graph, "TemporaryVariable", "TemporaryVariable0");

  2851.   auto assign0 = AddNode(graph, "Assign", "Assign0");

  2852.   auto destroy0 = AddNode(graph, "DestroyTemporaryVariable", "DestroyTemporaryVariable0");

  2853.   auto add0 = AddNode(graph, "Add", "Add0");

  2854. 

  2855.   google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map = tmpVar0->mutable_attr();

  2856.   tensorflow::AttrValue var_name_attr_value;

  2857.   var_name_attr_value.set_s("temporary_variable_name");

  2858.   (*node_attr_map)[ge::VAR_ATTR_NAME] = var_name_attr_value;

  2859. 

  2860.   google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map_destroy = destroy0->mutable_attr();

  2861.   tensorflow::AttrValue var_name_attr_value_destroy;

  2862.   var_name_attr_value_destroy.set_s("temporary_variable_name");

  2863.   (*node_attr_map_destroy)[ge::VAR_ATTR_NAME] = var_name_attr_value_destroy;

  2864. 

  2865.   AddInput(tmpVar0, assign0, 0);

  2866.   AddInput(assign0, destroy0, 0);

  2867.   AddInput(const0, add0, 0);

  2868.   AddInput(destroy0, add0, 1);

  2869. 

  2870.   GraphDef* graphDef = &graph;

  2871.   int32_t no_input_node_size_original = 0;

  2872.   for (int w = 0; w < graphDef->node_size(); w++) {

  2873.     tensorflow::NodeDef* nodeTmp = graphDef->mutable_node(w);

  2874.     if (nodeTmp->input_size() == 0) {

  2875.       no_input_node_size_original ++;

  2876.     }

  2877.   }

  2878. 

  2879.   Status ret = tensorflow_parser.GraphDefOptimize(graphDef);

  2880.   int32_t no_input_node_size_result = 0;

  2881.   for (int w = 0; w < graphDef->node_size(); w++) {

  2882.     tensorflow::NodeDef* nodeTmp = graphDef->mutable_node(w);

  2883.     if (nodeTmp->input_size() == 0) {

  2884.       no_input_node_size_result ++;

  2885.     }

  2886.   }

  2887.   ASSERT_EQ(ret, domi::SUCCESS);

  2888.   ASSERT_EQ(no_input_node_size_original, (no_input_node_size_result - 1));

  2889. }

  2890. 

  2891. TEST_F(STestTensorflowParser, tensorflow_AddControlEdgeAfterRemoveInputs_test)

  2892. {

  2893.   tensorflow::GraphDef graph_def;

  2894.   TensorFlowModelParser tensorflow_parser;

  2895.   tensorflow::NodeDef *node_def = initNodeDef();

  2896.   node_def->set_name("Add0");

  2897.   node_def->set_op("add");

  2898.   std::map<std::string, NodeDef *> all_node_map;

  2899.   all_node_map.emplace("Add0", node_def);

  2900.   std::vector<std::string> removed_inputs_vec;

  2901.   removed_inputs_vec.emplace_back("Add0");

  2902.   Status ret = tensorflow_parser.AddControlEdgeAfterRemoveInputs(&graph_def, node_def, all_node_map, removed_inputs_vec);

  2903.   EXPECT_EQ(ret, SUCCESS);

  2904.     

  2905.   tensorflow::NodeDef *node_swith = initNodeDef();

  2906.   node_swith->set_name("switch_op");

  2907.   node_swith->set_op(parser::SWITCH);

  2908.   all_node_map.emplace("switch_op", node_swith);

  2909.   removed_inputs_vec.clear();

  2910.   removed_inputs_vec.emplace_back("switch_op");

  2911.   ret = tensorflow_parser.AddControlEdgeAfterRemoveInputs(&graph_def, node_swith, all_node_map, removed_inputs_vec);

  2912.   EXPECT_EQ(ret, SUCCESS);

  2913. }

  2914. 

  2915. TEST_F(STestTensorflowParser, tensorflow_optimizer_snapshot_no_retval_test) {

  2916.   std::string caseDir = __FILE__;

  2917.   std::size_t idx = caseDir.find_last_of("/");

  2918.   caseDir = caseDir.substr(0, idx);

  2919.   const std::string root_proto = caseDir + "/origin_models/test_snapshot.pb";

  2920.   domi::tensorflow::GraphDef graphDef;

  2921. 

  2922.   bool protoRet =

  2923.       parser::ReadProtoFromBinaryFile(root_proto.c_str(), &graphDef);

  2924.   ASSERT_EQ(protoRet, true);

  2925. 

  2926.   TensorFlowModelParser tensorflow_parser;

  2927.   ge::ComputeGraphPtr root_graph =

  2928.       ge::parser::MakeShared<ge::ComputeGraph>("tmp_graph");

  2929.   Status ret = tensorflow_parser.ParseProto(

  2930.       reinterpret_cast<google::protobuf::Message *>(&graphDef), root_graph);

  2931.   EXPECT_EQ(FAILED, ret);

  2932. }

  2933. 

  2934. TEST_F(STestTensorflowParser, tensorflow_RemoveInputs_test)

  2935. {

  2936.   tensorflow::GraphDef graph_def;

  2937.   tensorflow::NodeDef *node_def = initNodeDef();

  2938.   node_def->set_name("OP");

  2939.   node_def->add_input("OP/Input_1");

  2940.    node_def->add_input("OP/Input_2");

  2941.   std::set<uint32_t> remove_index_set;

  2942.   std::map<std::string, NodeDef *> all_node_map;

  2943.   TensorFlowModelParser model_parser;

  2944.   Status ret = model_parser.RemoveInputs(&graph_def, node_def, remove_index_set, all_node_map);

  2945.   EXPECT_EQ(ret, SUCCESS);

  2946. 

  2947.   remove_index_set.emplace(0);

  2948.   ret = model_parser.RemoveInputs(&graph_def, node_def, remove_index_set, all_node_map);

  2949.   EXPECT_EQ(ret, FAILED);

  2950. }

  2951. 

  2952. TEST_F(STestTensorflowParser, tensorflow_UpdateInnerNodeContext_test)

  2953. {

  2954.   std::string fusion_op_name = "post_node_a";

  2955.   std::vector<std::string> inner_nodes_name;

  2956.   inner_nodes_name.emplace_back("post_node_a");

  2957.   TensorFlowModelParser model_parser;

  2958.   Status ret = model_parser.UpdateInnerNodeContext(fusion_op_name, inner_nodes_name);

  2959.   EXPECT_EQ(ret, INTERNAL_ERROR);

  2960. 

  2961.   GenOriginContext(&model_parser, fusion_op_name);

  2962.   ret = model_parser.UpdateInnerNodeContext(fusion_op_name, inner_nodes_name);

  2963.   EXPECT_EQ(ret, SUCCESS);

  2964. }

  2965. 

  2966. TEST_F(STestTensorflowParser, tensorflow_UpdateInnerInputMap_test)

  2967. {

  2968.   string fusion_op_name = "post_node_a";

  2969.   OpNodeContext fusion_context;

  2970.   std::vector<std::string> inner_nodes_name;

  2971.   inner_nodes_name.emplace_back("post_node_a");

  2972.   std::set<string> fusion_input_nodes;

  2973.   fusion_input_nodes.insert("post_node_a");

  2974.   TensorFlowModelParser model_parser;

  2975.   GenOriginContext(&model_parser, fusion_op_name);

  2976.   model_parser.UpdateInnerInputMap(fusion_op_name, fusion_context, inner_nodes_name, fusion_input_nodes);

  2977. }

  2978. 

  2979. TEST_F(STestTensorflowParser, tensorflow_UpdateInnerOutputMap_test)

  2980. {

  2981.   string fusion_op_name = "post_node_a";

  2982.   OpNodeContext fusion_context;

  2983.   std::vector<std::string> inner_nodes_name;

  2984.   inner_nodes_name.emplace_back("post_node_a");

  2985.   std::set<string> fusion_output_nodes;

  2986.   fusion_output_nodes.insert("post_node_a");

  2987.   TensorFlowModelParser model_parser;

  2988.   GenOriginContext(&model_parser, fusion_op_name);

  2989.   model_parser.UpdateInnerOutputMap(fusion_op_name, fusion_context, inner_nodes_name, fusion_output_nodes);

  2990. }

  2991. 

  2992. TEST_F(STestTensorflowParser, tensorflow_ScopePassManager_AddPass_test)

  2993. {

  2994.   ScopePassManager passmanager;

  2995.   tensorflow::GraphDef *graph = new tensorflow::GraphDef();

  2996.   shared_ptr<ScopeGraph> scope_graph = passmanager.BuildScopeGraph(graph);

  2997. 

  2998.   unique_ptr<ScopeBasePass> pass;

  2999.   pass.reset(new ScopeTestPass());

  3000. 

  3001.   EXPECT_EQ(ge::SUCCESS, passmanager.AddPass(pass));

  3002.   EXPECT_NE(ge::SUCCESS, passmanager.Run(scope_graph));

  3003. 

  3004.   delete graph;

  3005.   graph = nullptr;

  3006. }

  3007. 

  3008. TEST_F(STestTensorflowParser, tensorflow_CheckAttrHasType_test1)

  3009. {

  3010.   tensorflow::AttrValue attr_value;

  3011.   attr_value.mutable_list();

  3012.   Status ret = TensorFlowUtil::CheckAttrHasType(attr_value, "int");

  3013.   EXPECT_EQ(FAILED, ret);

  3014. 

  3015.   attr_value.set_type(DT_INVALID);

  3016.   ret = TensorFlowUtil::CheckAttrHasType(attr_value, "type");

  3017.   EXPECT_EQ(FAILED, ret);

  3018. 

  3019.   tensorflow::AttrValue attr_value2;

  3020.   AttrValue_ListValue *list = attr_value2.mutable_list();

  3021.   list->add_type(tensorflow::DT_FLOAT);

  3022.   list->add_type((tensorflow::DataType)30);

  3023.   ret = TensorFlowUtil::CheckAttrHasType(attr_value2, "list(type)");

  3024.   EXPECT_EQ(FAILED, ret);

  3025. }

  3026. 

  3027. TEST_F(STestTensorflowParser, tensorflow_CheckAttrHasType_test2)

  3028. {

  3029.   tensorflow::AttrValue attr_value;

  3030.   AttrValue_ListValue * list = attr_value.mutable_list();

  3031.   list->add_type(tensorflow::DT_FLOAT);

  3032.   list->add_type(tensorflow::DT_INVALID);

  3033.   Status ret = TensorFlowUtil::CheckAttrHasType(attr_value, "list(type)");

  3034.   EXPECT_EQ(FAILED, ret);

  3035. 

  3036.   attr_value.set_placeholder("test");

  3037.   ret = TensorFlowUtil::CheckAttrHasType(attr_value, "");

  3038.   EXPECT_EQ(FAILED, ret);

  3039. }

  3040. 

  3041. TEST_F(STestTensorflowParser, tensorflow_TransTensorDescriptor_test)

  3042. {

  3043.   tensorflow::AttrValue attr_value;

  3044.   AttrValue_ListValue *list = attr_value.mutable_list();

  3045.   list->add_type(tensorflow::DT_FLOAT);

  3046. 

  3047.   ParserOperator op;

  3048.   uint32_t io = TENSORFLOW_NORMAL_INPUT_TENSOR_FLAG;

  3049.   std::string type = ge::parser::FUSEDBATCHNORMGRAD;

  3050.   Status ret = TensorFlowUtil::TransTensorDescriptor(attr_value, &op, io, type);

  3051.   EXPECT_EQ(ret, SUCCESS);

  3052. 

  3053.   io = TENSORFLOW_NORMAL_OUTPUT_TENSOR_FLAG;

  3054.   ret = TensorFlowUtil::TransTensorDescriptor(attr_value, &op, io, type);

  3055.   EXPECT_EQ(ret, SUCCESS);

  3056. }

  3057. 

  3058. TEST_F(STestTensorflowParser, tensorflow_GraphDefOptimizeDestroyTemporaryVariable_test)

  3059. {

  3060.   tensorflow::GraphDef *graph_def = nullptr;

  3061.   tensorflow::NodeDef *nodeCurrent = initNodeDef();

  3062.   TensorFlowModelParser model_parser;

  3063.   Status ret = model_parser.GraphDefOptimizeDestroyTemporaryVariable(graph_def, nodeCurrent);

  3064.   EXPECT_EQ(ret, FAILED);

  3065. }

  3066. 

  3067. TEST_F(STestTensorflowParser, tensorflow_GetFunctionProto_test)

  3068. {

  3069.   std::cout << __FILE__ << std::endl;

  3070.   std::string caseDir = __FILE__;

  3071.   std::size_t idx = caseDir.find_last_of("/");

  3072.   caseDir = caseDir.substr(0, idx);

  3073.   std::string file = caseDir + "/origin_models/test_enter.pb";

  3074.   domi::tensorflow::GraphDefLibrary graph_def_library;

  3075.   TensorFlowModelParser model_parser;

  3076.   Status ret = model_parser.GetFunctionProto(file, graph_def_library);

  3077.   EXPECT_EQ(ret, FAILED);

  3078. }

  3079. 

  3080. TEST_F(STestTensorflowParser, tensorflow_GetNodeFormat_test)

  3081. {

  3082.   NodeDef *node_def1 = initNodeDef();

  3083.   node_def1->set_op("NoOp");

  3084.   node_def1->set_name("NoOp");

  3085. 

  3086.   NodeDef *node_def2 = initNodeDef();

  3087.   node_def2->set_op("Add");

  3088.   node_def2->set_name("Add0");

  3089.   TfTranspose pred_transpose = TO_NCHW;

  3090.   domiTensorFormat_t format = domi::DOMI_TENSOR_NC1HWC0;

  3091.   std::set<const NodeDef *> visited_node;

  3092.   visited_node.emplace(node_def2);

  3093.   TensorFlowModelParser model_parser;

  3094.   Status ret = model_parser.GetNodeFormat(node_def1, pred_transpose, format, visited_node);

  3095.   EXPECT_EQ(ret, FAILED);

  3096. 

  3097. 

  3098.   delete node_def1;

  3099.   delete node_def2;

  3100. }

  3101. 

  3102. TEST_F(STestTensorflowParser, tensorflow_GetFormatTranspose_test)

  3103. {

  3104.   NodeDef *transpose_node = initNodeDef();

  3105.   transpose_node->set_op("Transpose");

  3106.   TfTranspose transpose_direc = NO_TRANSPOSE;

  3107.   TensorFlowModelParser modelParser;

  3108.   Status ret = modelParser.GetFormatTranspose(transpose_node, transpose_direc);

  3109.   EXPECT_EQ(ret, FAILED);

  3110.   delete transpose_node;

  3111. }

  3112. 

  3113. TEST_F(STestTensorflowParser, tensorflow_GetFormatTranspose_test2)

  3114. {

  3115.   TensorFlowModelParser modelParser;

  3116.   TfTranspose transpose_direc = NO_TRANSPOSE;

  3117.   NodeDef *transpose_node = initNodeDef();

  3118.   GraphDef graph;

  3119. 

  3120.   auto arg0 = AddNode(graph, "_Arg", "arg0");

  3121.   auto snapshot0 = AddNode(graph, "Snapshot", "snapshot0");

  3122.   auto ret0 = AddNode(graph, "_Retval", "retval0");

  3123. 

  3124.   auto arg1 = AddNode(graph, "_Arg", "arg1");

  3125.   auto snapshot1 = AddNode(graph, "Snapshot", "snapshot1");

  3126.   auto ret1 = AddNode(graph, TENSORFLOWF_NODE_OP_TRANSPOSE, "retval1");

  3127. 

  3128.   auto arg2 = AddNode(graph, "_Arg", "arg2");

  3129.   auto snapshot2 = AddNode(graph, "Snapshot", "snapshot2");

  3130.   auto ret2 = AddNode(graph, TENSORFLOWF_NODE_OP_TRANSPOSE, TENSORFLOWF_NODE_OP_TRANSPOSE);

  3131. 

  3132.   AddInput(arg0, snapshot0, 0);

  3133.   AddInput(snapshot0, ret0, 0);

  3134.   AddInput(arg1, snapshot1, 0);

  3135.   AddInput(snapshot1, ret1, 0);

  3136.   AddInput(arg2, snapshot2, 0);

  3137.   AddInput(snapshot2, ret2, 0);

  3138.   AddInput(snapshot0, snapshot1, -1);

  3139.   AddInput(snapshot1, snapshot2, -1);

  3140. 

  3141.   bool train_flag = ge::GetParserContext().train_flag;

  3142.   ge::GetParserContext().train_flag = true;

  3143.   ASSERT_EQ(modelParser.GraphDefOptimize(&graph), SUCCESS);

  3144.   ge::GetParserContext().train_flag = train_flag;

  3145. 

  3146.   modelParser.nodedef_map_["arg1"] = transpose_node;

  3147.   modelParser.nodedef_map_["^arg0"] = transpose_node;

  3148.   Status ret = modelParser.GetFormatTranspose(ret1, transpose_direc);

  3149.   EXPECT_EQ(ret, SUCCESS);

  3150.   delete transpose_node;

  3151. }

  3152. 

  3153. TEST_F(STestTensorflowParser, tensorflow_GetTensorflowGraphInOutMap_test)

  3154. {

  3155.   TensorFlowModelParser model_parser;

  3156.   tensorflow::GraphDef *graph = new tensorflow::GraphDef();

  3157.   tensorflow::NodeDef *node_input = graph->add_node();

  3158.   node_input->set_name("name_input");

  3159.   node_input->set_op("op_input");

  3160. 

  3161.   AddGraphNode(graph, "t_lstm/t_lstm_cell/Sigmoid5", "Sigmoid", "node_input");

  3162.   AddGraphNode(graph, "t_lstm/t_lstm_cell/Sigmoid6", "Sigmoid", "node_input");

  3163.   AddGraphNode(graph, "t_lstm/t_lstm_cell/Sigmoid7", "Sigmoid", "node_input");

  3164.   AddGraphNode(graph, "t_lstm/t_lstm_cell/Mul5", "Mul", "node_input");

  3165.   AddGraphNode(graph, "t_lstm/t_lstm_cell/Mul6", "Mul", "node_input");

  3166.   AddGraphNode(graph, "t_lstm/t_lstm_cell/Mul7", "Mul", "node_input");

  3167.   AddGraphNode(graph, "t_lstm/t_lstm_cell/Relu5", "Relu", "node_input");

  3168.   AddGraphNode(graph, "t_lstm/t_lstm_cell/Relu6", "Relu", "node_input");

  3169.   Status ret = model_parser.GetTensorflowGraphInOutMap(graph);

  3170.   EXPECT_EQ(ret, SUCCESS);

  3171.   delete graph;

  3172. }

  3173. 

  3174. TEST_F(STestTensorflowParser, tensorflow_RemoveIsolateNode_test)

  3175. {

  3176.   TensorFlowModelParser model_parser;

  3177.   tensorflow::GraphDef graph;

  3178.   CreateGraphDef(graph);

  3179.   Status ret = model_parser.RemoveIsolateNode(&graph);

  3180.   EXPECT_EQ(ret, FAILED);

  3181. }

  3182. 

  3183. TEST_F(STestTensorflowParser, tensorflow_AddNodeToGraphAndMarkFormat_test)

  3184. {

  3185.   TensorFlowModelParser model_parser;

  3186.   ComputeGraphPtr graph = make_shared<ge::ComputeGraph>("default");

  3187.   std::vector<std::string> op_node_name_list = {"Const", "placeholder0"};

  3188.   GenOriginNodeDef(&model_parser, op_node_name_list);

  3189.   Status ret = model_parser.AddNodeToGraphAndMarkFormat(graph, op_node_name_list);

  3190.   EXPECT_EQ(ret, INTERNAL_ERROR);

  3191. }

  3192. 

  3193. TEST_F(STestTensorflowParser, tensorflow_ParserNodeDef1_test)

  3194. {

  3195.   ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);

  3196. 

  3197.   ModelParserFactory* factory = ModelParserFactory::Instance();

  3198.   shared_ptr<ModelParser> model_parser= factory->CreateModelParser(domi::TENSORFLOW);

  3199.   ASSERT_TRUE(NULL != model_parser);

  3200.   TensorFlowModelParser tensorflow_parser;

  3201.   tensorflow_parser.adaptedOpTypeMap_["test_name"] = "POOLING";

  3202.   std::mutex graphMutex;

  3203.   tensorflow::GraphDef *graph = new tensorflow::GraphDef();

  3204.   ScopePassManager passmanager;

  3205.   shared_ptr<ScopeGraph> scope_graph = passmanager.BuildScopeGraph(graph);

  3206. 

  3207.   domi::tensorflow::NodeDef node_def;

  3208.   node_def.set_name("test_name");

  3209.   node_def.set_op("POOLING");

  3210.   error_message::Context error_context;

  3211.   Status ret = ge::TensorFlowModelParser::ParseNodeDef(&tensorflow_parser, compute_graph, &graphMutex, scope_graph, &node_def, error_context);

  3212.   EXPECT_EQ(FAILED, ret);

  3213.   delete graph;

  3214. }

  3215. 

  3216. TEST_F(STestTensorflowParser, tensorflow_ParserNodeDef2_test)

  3217. {

  3218.   ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);

  3219. 

  3220.   ModelParserFactory* factory = ModelParserFactory::Instance();

  3221.   shared_ptr<ModelParser> model_parser= factory->CreateModelParser(domi::TENSORFLOW);

  3222.   ASSERT_TRUE(NULL != model_parser);

  3223.   TensorFlowModelParser tensorflow_parser;

  3224.   tensorflow_parser.adaptedOpTypeMap_["Pooling"] = "Pooling";

  3225.   std::mutex graphMutex;

  3226.   tensorflow::GraphDef *graph = new tensorflow::GraphDef();

  3227.   ScopePassManager passmanager;

  3228.   shared_ptr<ScopeGraph> scope_graph = passmanager.BuildScopeGraph(graph);

  3229. 

  3230.   REGISTER_CUSTOM_OP("Pooling")

  3231.     .FrameworkType(domi::TENSORFLOW)

  3232.     .OriginOpType("Pooling")

  3233.     .ParseParamsFn(ParseParams)

  3234.     .ImplyType(ImplyType::TVM);

  3235.   register_tbe_op();

  3236.   domi::tensorflow::NodeDef node_def;

  3237.   node_def.set_name("Pooling");

  3238.   node_def.set_op("Pooling");

  3239.   error_message::Context error_context;

  3240.   Status ret = ge::TensorFlowModelParser::ParseNodeDef(&tensorflow_parser, compute_graph, &graphMutex, scope_graph, &node_def, error_context);

  3241.   EXPECT_EQ(FAILED, ret);

  3242.   delete graph;

  3243. }

  3244. 

  3245. TEST_F(STestTensorflowParser, tensorflow_AddExternalGraph_test)

  3246. {

  3247.   TensorFlowModelParser modelParser;

  3248.   ge::ComputeGraphPtr subGraph = std::make_shared<ge::ComputeGraph>("default");

  3249.   std::string inputNodeType = "DATA";

  3250.   MakeDagGraph(subGraph, inputNodeType);

  3251.   Status ret = modelParser.AddExternalGraph(subGraph);

  3252.   EXPECT_EQ(ret, SUCCESS);

  3253. }

  3254. 

  3255. TEST_F(STestTensorflowParser, tensorflow_AddFmkNode_test)

  3256. {

  3257.   TensorFlowModelParser model_parser;

  3258.   ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);

  3259.   tensorflow::GraphDef *graphDef = new (std::nothrow) tensorflow::GraphDef();

  3260.   ScopePassManager pass_manager;

  3261.   std::shared_ptr<ScopeGraph> scope_graph = pass_manager.BuildScopeGraph(graphDef);

  3262.   std::vector<std::string> op_node_name_list = {"Const", "placeholder0"};

  3263.   GenOriginNodeDef(&model_parser, op_node_name_list);

  3264.   Status ret = model_parser.AddFmkNode(compute_graph, scope_graph, op_node_name_list, false);

  3265.   EXPECT_EQ(ret, PARAM_INVALID);

  3266.   delete graphDef;

  3267. }

  3268. 

  3269. TEST_F(STestTensorflowParser, tensorflow_OptimizeConstNodes4CustomOp_test)

  3270. {

  3271.   TensorFlowModelParser model_parser;

  3272.   tensorflow::GraphDef graph_def;

  3273.   CreateGraphDef(graph_def);

  3274.   Status ret = model_parser.OptimizeConstNodes4CustomOp(&graph_def);

  3275.   EXPECT_EQ(ret, SUCCESS);

  3276. }

  3277. 

  3278. TEST_F(STestTensorflowParser, OptimizeConstNodes4CustomOp_success)

  3279. {

  3280.   GraphDef graph;

  3281.   auto bn = AddNode(graph, "FusedBatchNormV3", "FusedBatchNormV3_0");

  3282.   auto bn_grad = AddNode(graph, "FusedBatchNormGradV3", "FusedBatchNormGradV3_0");

  3283. 

  3284.   AddInput(bn, bn_grad, 0);

  3285.   AddInput(bn, bn_grad, 1);

  3286.   AddInput(bn, bn_grad, 2);

  3287.   AddInput(bn, bn_grad, 3);

  3288.   AddInput(bn, bn_grad, 5);

  3289.   AddInput(bn, bn_grad, 5);

  3290. 

  3291.   GraphDef* graphDef = &graph;

  3292.   int before_bn_grad_input_size = bn_grad->input_size();

  3293.   ASSERT_EQ(before_bn_grad_input_size, 6);

  3294. 

  3295.   ModelParserFactory* factory = ModelParserFactory::Instance();

  3296.   shared_ptr<domi::ModelParser> model_parser= factory->CreateModelParser(domi::TENSORFLOW);

  3297.   ge::TensorFlowModelParser tensorflow_parser;

  3298. 

  3299.   Status ret = tensorflow_parser.OptimizeConstNodes4CustomOp(graphDef);

  3300.   int after_bn_grad_input_size = bn_grad->input_size();

  3301.   ASSERT_EQ(after_bn_grad_input_size, 6);

  3302.   ASSERT_EQ(ret, domi::SUCCESS);

  3303. 

  3304.   REGISTER_CUSTOM_OP("BatchNormGrad")

  3305.       .FrameworkType(domi::TENSORFLOW)

  3306.       .OriginOpType({"FusedBatchNormGradV3", "FusedBatchNormGradV2", "FusedBatchNormGrad"})

  3307.       .ParseParamsFn(AutoMappingFn)

  3308.       .DelInputWithOriginalType(5, "FusedBatchNormGradV3")

  3309.       .ImplyType(ImplyType::TVM);

  3310.   register_tbe_op();

  3311. 

  3312.   ret = tensorflow_parser.OptimizeConstNodes4CustomOp(graphDef);

  3313.   after_bn_grad_input_size = bn_grad->input_size();

  3314.   ASSERT_EQ(after_bn_grad_input_size, 6);

  3315.   ASSERT_EQ(ret, domi::SUCCESS);

  3316. }

  3317. 

  3318. TEST_F(STestTensorflowParser, tensorflow_ParseOpParams_test)

  3319. {

  3320.   TensorFlowModelParser model_parser;

  3321.   tensorflow::NodeDef *node_def = initNodeDef();

  3322.   node_def->set_name("Pooling");

  3323.   node_def->set_op("Pooling");

  3324.   ge::OpDescPtr op = std::make_shared<ge::OpDesc>();

  3325.   std::shared_ptr<OpParserFactory> factory = OpParserFactory::Instance(domi::TENSORFLOW);

  3326.   std::shared_ptr<OpParser> op_parser = factory->CreateOpParser("Pooling");

  3327.   Status ret = model_parser.ParseOpParams(node_def, op, op_parser);

  3328.   EXPECT_EQ(ret, FAILED);

  3329. 

  3330.   node_def->set_name("TensorArrayWrite");

  3331.   node_def->set_op("TensorArrayWriteV3");

  3332.   op_parser = factory->CreateOpParser("TensorArrayWrite");

  3333.   ret = model_parser.ParseOpParams(node_def, op, op_parser);

  3334.   EXPECT_EQ(ret, SUCCESS);

  3335.   delete node_def;

  3336. }

  3337. 

  3338. TEST_F(STestTensorflowParser, tensorflow_AddFusionInnerNodeDef_test)

  3339. {

  3340.   TensorFlowModelParser model_parser;

  3341.   ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);

  3342.   tensorflow::GraphDef *graphDef = new (std::nothrow) tensorflow::GraphDef();

  3343.   ScopePassManager pass_manager;

  3344.   std::shared_ptr<ScopeGraph> scope_graph = pass_manager.BuildScopeGraph(graphDef);

  3345.   std::vector<std::string> op_node_name_list = {"Const", "placeholder0"};

  3346.   FusionScopesResult *fusion_scope_rlt = new (std::nothrow) FusionScopesResult();

  3347.   fusion_scope_rlt->Init();

  3348.   fusion_scope_rlt->SetName("FusionCustom");

  3349.   auto &impl_scope_graph = scope_graph->impl_;

  3350.   std::string scope_name = fusion_scope_rlt->Name();

  3351.   impl_scope_graph->fusion_results_.insert(std::make_pair(scope_name, fusion_scope_rlt));

  3352.   std::string fusion_op_name = "FusionCustom";

  3353.   GenOriginNodeDef(&model_parser, op_node_name_list);

  3354.   GenFusionScopesResult(scope_graph, fusion_scope_rlt, fusion_op_name);

  3355.   Status ret = model_parser.AddFusionInnerNodeDef(scope_graph, fusion_op_name, op_node_name_list);

  3356.   EXPECT_EQ(ret, INTERNAL_ERROR);

  3357.   delete graphDef;

  3358. }

  3359. 

  3360. TEST_F(STestTensorflowParser, Scope_pass_test)

  3361. {

  3362.   ScopePassManager passmanager;

  3363.   tensorflow::GraphDef *graph = new tensorflow::GraphDef();

  3364.   shared_ptr<ScopeGraph> scope_graph = passmanager.BuildScopeGraph(graph);

  3365.   EXPECT_NE(nullptr, scope_graph);

  3366. 

  3367.   unique_ptr<ScopeBasePass> pass;

  3368.   pass.reset(new ScopeTestPass());

  3369.   EXPECT_EQ(domi::SUCCESS, passmanager.AddPass(pass));

  3370.   scope_graph = passmanager.BuildScopeGraph(graph);

  3371.   EXPECT_NE(nullptr, scope_graph);

  3372.   delete graph;

  3373. }

  3374. 

  3375. TEST_F(STestTensorflowParser, operator_attr_set_and_get)

  3376. {

  3377.   TestOperator test_operator;

  3378.   test_operator.Name("test_op");

  3379.   EXPECT_EQ("test_op" , test_operator.GetName());

  3380. 

  3381.   test_operator.Input(test_operator, 0);

  3382.   test_operator.Input(test_operator, 1);

  3383.   test_operator.GetOpAttrs();

  3384. 

  3385.   int64_t pad = 1;

  3386.   test_operator.Attr("pad", pad);

  3387.   EXPECT_EQ(pad , test_operator.GetIntAttr("pad"));

  3388. 

  3389.   bool bool_value = true;

  3390.   test_operator.Attr("bool_value", bool_value);

  3391.   EXPECT_EQ(bool_value , test_operator.GetBoolAttr("bool_value"));

  3392. 

  3393.   float float_value = true;

  3394.   test_operator.Attr("float_value", float_value);

  3395.   EXPECT_EQ(float_value , test_operator.GetFloatAttr("float_value"));

  3396. 

  3397.   std::string str_value = "test_string";

  3398.   test_operator.Attr("str_value", str_value);

  3399.   EXPECT_EQ(str_value , test_operator.GetStringAttr("str_value"));

  3400. 

  3401.   BoolTuple boollist_value{true, false};

  3402.   test_operator.Attr("boollist_value", boollist_value);

  3403.   BoolTuple get_boollist_value = test_operator.GetBoolTupleAttr("boollist_value");

  3404.   EXPECT_EQ(boollist_value[0] , get_boollist_value[0]);

  3405. 

  3406.   StringTuple strlist_value{"a", "b"};

  3407.   test_operator.Attr("strlist_value", strlist_value);

  3408.   StringTuple get_strlist_value = test_operator.GetStringTupleAttr("strlist_value");

  3409.   EXPECT_EQ(strlist_value[0] , get_strlist_value[0]);

  3410. 

  3411.   int64_t num = 1;

  3412.   IntTuple intlist{num, num};

  3413.   test_operator.Attr("intlist", intlist);

  3414.   IntTuple get_intlist = test_operator.GetIntTupleAttr("intlist");

  3415.   EXPECT_EQ(intlist[0] , get_intlist[0]);

  3416. 

  3417.   FloatTuple floatlist{1.1, 1.1};

  3418.   test_operator.Attr("floatlist", floatlist);

  3419.   FloatTuple get_floatlist = test_operator.GetFloatTupleAttr("floatlist");

  3420.   EXPECT_EQ(floatlist[0] , get_floatlist[0]);

  3421. 

  3422.   ge::OpDescPtr op_desc = std::make_shared<ge::OpDesc>();

  3423.   ParserOperator *op = &test_operator;

  3424.   Status ret = ConvertToOpDesc(*op, op_desc);

  3425.   EXPECT_EQ(domi::SUCCESS , ret);

  3426. 

  3427.   TestOperator test_operator_1;

  3428.   ParserOperator *op_convert = &test_operator_1;

  3429.   ret = ConvertFromOpDesc(op_desc, *op_convert);

  3430.   EXPECT_EQ(domi::SUCCESS , ret);

  3431. 

  3432.   op_desc = nullptr;

  3433.   ret = ConvertFromOpDesc(op_desc, *op_convert);

  3434.   EXPECT_EQ(FAILED , ret);

  3435. 

  3436.   ret = ConvertToOpDesc(*op, op_desc);

  3437.   EXPECT_EQ(FAILED, ret);

  3438. }

  3439. 

  3440. TEST_F(STestTensorflowParser, success_frameworkop_get)

  3441. {

  3442.   FrameworkOpOperator *frameworkOp=new FrameworkOpOperator();

  3443.   int64_t index = 1;

  3444.   std::string opdef_string = "tensorflow_parser";

  3445.   frameworkOp->GetFrameworkType();

  3446.   frameworkOp->GetNodeDefPkg();

  3447.   frameworkOp->FuncDefPkg("func");

  3448.   frameworkOp->Index(index);

  3449.   frameworkOp->TfOpDef(opdef_string);

  3450.   EXPECT_EQ(SUCCESS, SUCCESS);

  3451.   delete frameworkOp;

  3452. }

  3453. 

  3454. TEST_F(STestTensorflowParser, op_set_get_success)

  3455. {

  3456.   ConstantOperator op;

  3457.   vector<int64_t> v;

  3458.   op.VectorAttr("key", v);

  3459.   op.GetDType();

  3460. }

  3461. 

  3462. TEST_F(STestTensorflowParser, success_argop_get)

  3463. {

  3464.   ArgOpOperator *argOp=new ArgOpOperator();

  3465.   int64_t index = 1;

  3466.   argOp->Index(index);

  3467.   argOp->GetIndex();

  3468.   EXPECT_EQ(domi::SUCCESS, SUCCESS);

  3469.   delete argOp;

  3470. }

  3471. 

  3472. TEST_F(STestTensorflowParser, success_operator)

  3473. {

  3474.   ParserOperator tfOperator;

  3475.   ParserOperator in_op;

  3476.   uint32_t index = 0;

  3477.   std::string type = "add";

  3478.   std::string key = "Add";

  3479.   std::vector<int64_t> value;

  3480.   int64_t tmp = 0;

  3481.   value.emplace_back(tmp);

  3482.   tfOperator.Input(in_op, index);

  3483.   tfOperator.Type(type);

  3484.   tfOperator.AttrVector(key, value);

  3485. }

  3486. 

  3487. TEST_F(STestTensorflowParser, success_shapen_get)

  3488. {

  3489.   ShapeNOperator *shapen =new ShapeNOperator();

  3490.   shapen->GetInType();

  3491.   shapen->GetInType();

  3492.   shapen->GetOutType();

  3493.   EXPECT_EQ(domi::SUCCESS, domi::SUCCESS);

  3494.   delete shapen;

  3495. }

  3496. 

  3497. TEST_F(STestTensorflowParser, success_VarIsInitializedOpOperator_get)

  3498. {

  3499.   VarIsInitializedOpOperator op;

  3500.   op.Name("x");

  3501.   std::vector<int64_t> value;

  3502.   op.VectorAttr("key", value);

  3503. }

  3504. 

  3505. TEST_F(STestTensorflowParser, success_variable_op_get)

  3506. {

  3507.   VariableOperator op;

  3508.   uint32_t mem_type = 1;

  3509.   op.Name("x");

  3510.   std::vector<int64_t> value;

  3511.   op.Placement("shared_name");

  3512.   op.MemType(mem_type);

  3513. }

  3514. 

  3515. TEST_F(STestTensorflowParser, param_success_get)

  3516. {

  3517.   FillOperator* fillOp=new FillOperator();

  3518.   fillOp->GetDataType();

  3519.   fillOp->GetAlpha();

  3520.   fillOp->GetBeta();

  3521.   EXPECT_EQ(domi::SUCCESS, domi::SUCCESS);

  3522.   delete fillOp;

  3523. }

  3524. 

  3525. TEST_F(STestTensorflowParser, tensorflow_Message2Operator_ParseOperatorAttrs_test)

  3526. {

  3527.   Message2Operator mess2Op;

  3528.   tensorflow::NodeDef *node_def = initNodeDef();

  3529.   int depth = 6;

  3530.   ge::OpDescPtr op_desc = std::make_shared<ge::OpDesc>();

  3531.   ge::Operator ops = ge::OpDescUtils::CreateOperatorFromOpDesc(op_desc);

  3532.   Status ret = mess2Op.ParseOperatorAttrs(node_def, depth, ops);

  3533.   EXPECT_EQ(ret, FAILED);

  3534. 

  3535.   depth = 4;

  3536.   ret = mess2Op.ParseOperatorAttrs(node_def, depth, ops);

  3537.   EXPECT_EQ(ret, SUCCESS);

  3538. }

  3539. 

  3540. TEST_F(STestTensorflowParser, tensorflow_Pb2Json_RepeatedEnum2Json_test)

  3541. {

  3542.   Pb2Json toJson;

  3543.   ProtobufEnumValueDescriptor *enum_value_desc = new google::protobuf::EnumValueDescriptor();

  3544.   bool enum2str = true;

  3545.   Json json;

  3546.   ProtobufFieldDescriptor *field = nullptr;

  3547.   toJson.RepeatedEnum2Json(enum_value_desc, enum2str, json);

  3548.   toJson.Enum2Json(enum_value_desc, field, enum2str, json);

  3549. 

  3550.   enum2str = false;

  3551.   toJson.RepeatedEnum2Json(enum_value_desc, enum2str, json);

  3552.   delete enum_value_desc;

  3553. }

  3554. 

  3555. TEST_F(STestTensorflowParser, tensorflow_Pb2Json_TypeBytes2String_test)

  3556. {

  3557.   Pb2Json toJson;

  3558.   std::string field_name = "offset";

  3559.   std::string type_bytes = "offset";

  3560.   toJson.TypeBytes2String(field_name, type_bytes);

  3561. 

  3562.   field_name = "test";

  3563.   toJson.TypeBytes2String(field_name, type_bytes);

  3564. }

  3565. 

  3566. TEST_F(STestTensorflowParser, tensorflow_Pb2Json_RepeatedMessage2Json_test)

  3567. {

  3568.   Pb2Json toJson;

  3569.   tensorflow::NodeDef *node_def = initNodeDef();

  3570.   ProtobufFieldDescriptor *field = new google::protobuf::FieldDescriptor();

  3571.   ProtobufReflection *reflection = nullptr;

  3572.   set<string> black_fields;

  3573.   black_fields.emplace("offset");

  3574.   Json json;

  3575.   bool enum2str = true;

  3576.   toJson.RepeatedMessage2Json((*node_def), field, reflection, black_fields, json, enum2str);

  3577.   delete field;

  3578. }

  3579. 

  3580. TEST_F(STestTensorflowParser, tensorflow_Pb2Json_OneField2Json_test)

  3581. {

  3582.   Pb2Json toJson;

  3583.   tensorflow::NodeDef *node_def = initNodeDef();

  3584.   ProtobufFieldDescriptor *field = new google::protobuf::FieldDescriptor();

  3585.   ProtobufReflection *reflection = nullptr;

  3586.   set<string> black_fields;

  3587.   black_fields.emplace("offset");

  3588.   Json json;

  3589.   bool enum2str = true;

  3590. 

  3591.   Message2Operator mess2Op;

  3592.   int depth = 4;

  3593.   ge::OpDescPtr op_desc = std::make_shared<ge::OpDesc>("FusionCustom", "FusionCustom");

  3594.   ge::Operator ops = ge::OpDescUtils::CreateOperatorFromOpDesc(op_desc);

  3595.   field->CppTypeName(google::protobuf::FieldDescriptor::CPPTYPE_ENUM);

  3596.   mess2Op.ParseField(reflection, node_def, field, depth, ops);

  3597.   toJson.OneField2Json((*node_def), field, reflection, black_fields, json, enum2str, 1);

  3598.   toJson.OneField2Json((*node_def), field, reflection, black_fields, json, enum2str, 5);

  3599.   delete field;

  3600. }

  3601. 

  3602. TEST_F(STestTensorflowParser, input_proto_real_path_success) {

  3603.   const char *caffe_proto_path = "./caffe/caffe.proto";

  3604.   const char *custom_proto_path = "./caffe/custom.proto";

  3605.   ProtoFileParser proto_file_parser;

  3606.   string fusion_proto_file;

  3607.   auto ret = proto_file_parser.CombineProtoFile(caffe_proto_path, custom_proto_path, fusion_proto_file);

  3608.   EXPECT_EQ(ret, FAILED);

  3609. 

  3610.   ret = proto_file_parser.RecordProtoMessage(caffe_proto_path);

  3611.   EXPECT_EQ(ret, FAILED);

  3612. 

  3613.   ret = proto_file_parser.WriteProtoFile(caffe_proto_path, custom_proto_path);

  3614.   EXPECT_EQ(ret, FAILED);

  3615. 

  3616.   std::cout << __FILE__ << std::endl;

  3617.   std::string caseDir = __FILE__;

  3618.   std::size_t idx = caseDir.find_last_of("/");

  3619.   caseDir = caseDir.substr(0, idx);

  3620.   std::string proto_file = caseDir + "/origin_models/caffe.proto";

  3621.   caffe_proto_path = proto_file.c_str();

  3622.   ret = proto_file_parser.CombineProtoFile(caffe_proto_path, caffe_proto_path, fusion_proto_file);

  3623.   EXPECT_EQ(ret, SUCCESS);

  3624. 

  3625.   ret = proto_file_parser.WriteProtoFile(caffe_proto_path, custom_proto_path);

  3626.   EXPECT_EQ(ret, FAILED);

  3627. 

  3628.   std::string dest_line = "test";

  3629.   ret = proto_file_parser.FindConflictLine(custom_proto_path, 0, dest_line);

  3630.   EXPECT_EQ(ret, FAILED);

  3631. 

  3632.   std::map<int, std::pair<string, string>> identifier_op_map;

  3633.   std::map<std::string, std::pair<int, string>> op_identifier_map;

  3634.   ret = proto_file_parser.ParseProtoFile(custom_proto_path, identifier_op_map, op_identifier_map);

  3635.   EXPECT_EQ(ret, FAILED);

  3636. 

  3637.   proto_file_parser.GetFusionProtoFile();

  3638. 

  3639.   std::ofstream write_tmp;

  3640.   ret = proto_file_parser.AddCustomAndConflictMessage(custom_proto_path, write_tmp);

  3641.   EXPECT_EQ(ret, FAILED);

  3642. }

  3643. 

  3644. TEST_F(STestTensorflowParser, all_success)

  3645. {

  3646.   PreChecker::OpId id1 = (void*)(intptr_t)1;

  3647.   PreChecker::OpId id2 = (void*)(intptr_t)2;

  3648.   PreChecker::OpId id3 = (void*)(intptr_t)3;

  3649.   PreChecker::OpId id4 = (void*)(intptr_t)4;

  3650.   PreChecker &checker = PreChecker::Instance();

  3651. 

  3652.   EXPECT_EQ(checker.AddOp(id1, "name1", "type1"), SUCCESS);

  3653.   EXPECT_EQ(checker.AddOp(id2, "name2", "type2"), SUCCESS);

  3654.   EXPECT_EQ(checker.AddOp(id3, "name1", "type3"), SUCCESS);

  3655.   EXPECT_EQ(checker.AddOp(id4, "name4", ge::parser::DETECTIONOUTPUT), SUCCESS);

  3656. 

  3657.   EXPECT_EQ(checker.CheckName(id1), SUCCESS);

  3658.   EXPECT_EQ(checker.CheckName(id2), SUCCESS);

  3659.   EXPECT_EQ(checker.CheckName(id3), SUCCESS);

  3660.   EXPECT_EQ(checker.CheckName(id4), SUCCESS);

  3661. 

  3662.   EXPECT_EQ(checker.CheckType(id1), SUCCESS);

  3663.   EXPECT_EQ(checker.CheckType(id2), SUCCESS);

  3664.   EXPECT_EQ(checker.CheckType(id3), SUCCESS);

  3665.   EXPECT_EQ(checker.CheckType(id4), SUCCESS);

  3666. 

  3667.   EXPECT_EQ(checker.AddCause(id1, PreChecker::ErrorCode::OK, "msg"), SUCCESS);

  3668.   EXPECT_EQ(checker.AddCause(id1, PreChecker::ErrorCode::PARAM_INVALID, "msg"), domi::SUCCESS);

  3669. 

  3670.   PreChecker::Cause cause;

  3671.   cause.code = PreChecker::ErrorCode::TYPE_AMBIGUOUS;

  3672.   cause.message = "msg";

  3673.   EXPECT_EQ(checker.AddCause(id1, cause), SUCCESS);

  3674.   EXPECT_EQ(checker.HasError(), true);

  3675.   EXPECT_EQ(checker.Save("check_result.json"), SUCCESS);

  3676. 

  3677.   std::string msg = "msg";

  3678.   Status ret = checker.Clear(id1, msg);

  3679.   EXPECT_EQ(ret, SUCCESS);

  3680. 

  3681.   checker.Clear();

  3682.   checker.RefreshErrorMessageByName("name1",PreChecker::ErrorCode::PARAM_INVALID,"node repeated in");

  3683. }

  3684. 

  3685. TEST_F(STestTensorflowParser, tensorflow_tbe_tfplugin_loader_test)

  3686. {

  3687.   TBEPluginLoader pluginLoad;

  3688.   vector<string> fileList = {};

  3689.   string caffeParserPath = "";

  3690.   string full_name = "dabc";

  3691.   string caffe_parser_so_suff = "abc";

  3692.   pluginLoad.ProcessSoFullName(fileList, caffeParserPath, full_name, caffe_parser_so_suff);

  3693.   ASSERT_EQ(caffeParserPath, full_name);

  3694. 

  3695.   pluginLoad.ClearHandles_();

  3696. 

  3697.   std::cout << __FILE__ << std::endl;

  3698.   std::string caseDir = __FILE__;

  3699.   std::size_t idx = caseDir.find_last_of("/");

  3700.   caseDir = caseDir.substr(0, idx);

  3701.   std::string proto_file = caseDir + "/origin_models/";

  3702.   std::string path = proto_file;

  3703.   std::string caffe_parser_path = path;

  3704.   pluginLoad.FindParserSo(path, fileList, caffe_parser_path);

  3705. 

  3706.   setenv("ASCEND_OPP_PATH", "aaa", 1);

  3707.   std::string customop_path = "";

  3708.   pluginLoad.GetCustomOpPath(customop_path);

  3709.   ASSERT_EQ(customop_path, "aaa/framework/custom/:aaa/framework/built-in/tensorflow/");

  3710. 

  3711.   Status ret = pluginLoad.Finalize();

  3712.   EXPECT_EQ(ret, SUCCESS);

  3713. }

  3714. 

  3715. TEST_F(STestTensorflowParser, tensorflow_data_op_parser_test)

  3716. {

  3717.   std::vector<int64_t> shape = {1, 1, 224, 224};

  3718.   ge::GeTensorDesc tensor_desc;

  3719.   DataOpParser opParser;

  3720.   Status ret = opParser.Init5DInputTensor(shape, tensor_desc);

  3721.   EXPECT_EQ(ret, SUCCESS);

  3722. 

  3723.   ret = opParser.Init5DOutputTensor(shape, tensor_desc);

  3724.   EXPECT_EQ(ret, SUCCESS);

  3725. 

  3726.   ge::OpDescPtr op = std::make_shared<ge::OpDesc>();

  3727.   ret = opParser.ParseShape(shape, op);

  3728. }

  3729. 

  3730. TEST_F(STestTensorflowParser, read_proto_from_mem_test)

  3731. {

  3732.   tensorflow::NodeDef *node_def = initNodeDef();

  3733.   const char *data = nullptr;

  3734.   int size = 3;

  3735.   bool ret = parser::ReadProtoFromMem(data, size, node_def);

  3736.   EXPECT_EQ(false, ret);

  3737. 

  3738.   data = "not file";

  3739.   ret = parser::ReadProtoFromMem(data, size, node_def);

  3740.   EXPECT_EQ(false, ret);

  3741. }

  3742. 

  3743. TEST_F(STestTensorflowParser, tensorflow_GetOriginalType_test)

  3744. {

  3745.   ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);

  3746.   ge::OpDescPtr op = std::make_shared<ge::OpDesc>("fusionCustom", parser::FRAMEWORKOP);

  3747.   ge::NodePtr node = std::make_shared<ge::Node>(op, graph);

  3748.   string type = parser::FRAMEWORKOP;

  3749.   Status ret = parser::GetOriginalType(node, type);

  3750.   EXPECT_EQ(ret, INTERNAL_ERROR);

  3751. }

  3752. 

  3753. TEST_F(STestTensorflowParser, tensorflow_ReadBytesFromBinaryFile_test)

  3754. {

  3755.   const char *file_name = nullptr;

  3756.   char *buffer = nullptr;

  3757.   int length = 1;

  3758.   bool ret = parser::ReadBytesFromBinaryFile(file_name, &buffer, length);

  3759.   EXPECT_EQ(ret, false);

  3760. 

  3761.   file_name = "./caffe.proto";

  3762.   ret = parser::ReadBytesFromBinaryFile(file_name, &buffer, length);

  3763.   EXPECT_EQ(ret, false);

  3764. 

  3765.   std::cout << __FILE__ << std::endl;

  3766.   std::string caseDir = __FILE__;

  3767.   std::size_t idx = caseDir.find_last_of("/");

  3768.   caseDir = caseDir.substr(0, idx);

  3769.   std::string proto_file = caseDir + "/origin_models/caffe.proto";

  3770.   file_name = proto_file.c_str();

  3771.   ret = parser::ReadBytesFromBinaryFile(file_name, &buffer, length);

  3772.   EXPECT_EQ(ret, true);

  3773. 

  3774.   char path[4096 + 1] = { 0 };

  3775.   memset(path, 'a', 4096);

  3776.   std::string realPath = parser::RealPath(path);

  3777.   EXPECT_EQ(realPath, "");

  3778. 

  3779.   const char *real_path = nullptr;

  3780.   realPath = parser::RealPath(real_path);

  3781.   EXPECT_EQ(realPath, "");

  3782. }

  3783. 

  3784. TEST_F(STestTensorflowParser, tensorflow_AclGraphParserUtil_ParseAclInputFp16Nodes_test)

  3785. {

  3786.   AclGraphParserUtil parserUtil;

  3787.   ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);

  3788.   std::string input_fp16_nodes = "Add";

  3789.   std::string is_input_adjust_hw_layout = "is_input_adjust_hw_layout";

  3790.   Status ret = parserUtil.ParseAclInputFp16Nodes(graph, input_fp16_nodes, is_input_adjust_hw_layout);

  3791.   EXPECT_EQ(ret, PARAM_INVALID);

  3792. 

  3793.   is_input_adjust_hw_layout = "true";

  3794.   ret = parserUtil.ParseAclInputFp16Nodes(graph, input_fp16_nodes, is_input_adjust_hw_layout);

  3795.   EXPECT_EQ(ret, PARAM_INVALID);

  3796. 

  3797.   vector<string> adjust_fp16_format_vec = {"true", "false"};

  3798.   uint32_t index = 1;

  3799.   ge::OpDescPtr op_desc = std::make_shared<ge::OpDesc>();

  3800.   parserUtil.AddAttrsForInputNodes(adjust_fp16_format_vec, input_fp16_nodes, index, op_desc);

  3801. 

  3802.   std::string is_output_fp16 = "is_output_fp16";

  3803.   ret = parserUtil.ParseAclOutputFp16NodesFormat(is_output_fp16);

  3804.   EXPECT_EQ(ret, PARAM_INVALID);

  3805. 

  3806.   is_output_fp16 = "false";

  3807.   ret = parserUtil.ParseAclOutputFp16NodesFormat(is_output_fp16);

  3808.   EXPECT_EQ(ret, SUCCESS);

  3809. 

  3810.   is_output_fp16 = "true";

  3811.   ret = parserUtil.ParseAclOutputFp16NodesFormat(is_output_fp16);

  3812.   EXPECT_EQ(ret, SUCCESS);

  3813. }

  3814. 

  3815. TEST_F(STestTensorflowParser, tensorflow_ModelSaver_test)

  3816. {

  3817.   const char *file_path = nullptr;

  3818.   const Json model = {{"a", "b"}};

  3819.   Status ret = ge::parser::ModelSaver::SaveJsonToFile(file_path, model);

  3820.   EXPECT_EQ(ret, FAILED);

  3821. 

  3822.   file_path = "./origin_models/";

  3823.   ret = ge::parser::ModelSaver::SaveJsonToFile(file_path, model);

  3824.   EXPECT_EQ(ret, FAILED);

  3825. 

  3826.   std::string caseDir = __FILE__;

  3827.   std::size_t idx = caseDir.find_last_of("/");

  3828.   caseDir = caseDir.substr(0, idx);

  3829.   std::string proto_file = caseDir + "/origin_models/caffe.proto";

  3830.   file_path = proto_file.c_str();

  3831.   ret = ge::parser::ModelSaver::SaveJsonToFile(file_path, model);

  3832. 

  3833.   char path[4096 + 1] = { 0 };

  3834.   memset(path, 'a', 4096);

  3835.   EXPECT_EQ(-1, ge::parser::ModelSaver::CreateDirectory(path));

  3836.   EXPECT_EQ(-1, ge::parser::ModelSaver::CheckPath(path));

  3837. }

  3838. 

  3839. TEST_F(STestTensorflowParser, create_weights_parser_failed)

  3840. {

  3841.   WeightsParserFactory* factory = WeightsParserFactory::Instance();

  3842.   shared_ptr<WeightsParser> weight_parser = factory->CreateWeightsParser(FRAMEWORK_RESERVED);

  3843.   ASSERT_TRUE(NULL == weight_parser);

  3844. 

  3845.   ModelParserFactory *modelFactory = ModelParserFactory::Instance();

  3846.   shared_ptr<ModelParser> model_parser = modelFactory->CreateModelParser(FRAMEWORK_RESERVED);

  3847.   ASSERT_TRUE(NULL == model_parser);

  3848. 

  3849.   std::shared_ptr<OpParserFactory> parserFactory = OpParserFactory::Instance(domi::FrameworkType::CAFFE);

  3850.   std::shared_ptr<OpParser> fusion_op_parser = parserFactory->CreateFusionOpParser(ge::parser::DATA);

  3851.   ASSERT_TRUE(NULL == fusion_op_parser);

  3852. 

  3853.   std::shared_ptr<OpParser> op_parser = parserFactory->CreateOpParser("10");

  3854.   ASSERT_TRUE(NULL == op_parser);

  3855. }

  3856. 

  3857. TEST_F(STestTensorflowParser, custom_parser_adapter_register)

  3858. {

  3859.   using PARSER_CREATOR_FN = std::function<std::shared_ptr<OpParser>(void)>;

  3860.   PARSER_CREATOR_FN func = CustomParserAdapterRegistry::Instance()->GetCreateFunc(domi::TENSORFLOW);

  3861.   CustomParserAdapterRegistry::Instance()->Register(domi::TENSORFLOW, func);

  3862.   CustomParserAdapterRegistry::Instance()->Register(domi::TENSORFLOW, func);

  3863. 

  3864.   func = CustomParserAdapterRegistry::Instance()->GetCreateFunc(domi::FRAMEWORK_RESERVED);

  3865.   ASSERT_EQ(nullptr, func);

  3866. }

  3867. 

  3868. TEST_F(STestTensorflowParser, tensorflow_parser_api_test)

  3869. {

  3870.   std::map<std::string, std::string> options = {{"ge.runFlag", "1"}};

  3871.   Status ret = ParserInitialize(options);

  3872.   EXPECT_EQ(ret, SUCCESS);

  3873. 

  3874.   ret = ParserInitialize(options);

  3875.   EXPECT_EQ(ret, SUCCESS);

  3876. 

  3877.   ret = ParserFinalize();

  3878.   EXPECT_EQ(ret, SUCCESS);

  3879. 

  3880.   ret = ParserFinalize();

  3881.   EXPECT_EQ(ret, SUCCESS);

  3882. }

  3883. 

  3884. TEST_F(STestTensorflowParser, tensorflow_FP16_parser_test)

  3885. {

  3886.   parser::fp16_t fp16;

  3887.   fp16.ToDouble();

  3888.   fp16.ToInt8();

  3889.   fp16.ToUInt8();

  3890.   fp16.ToInt16();

  3891.   fp16.ToUInt16();

  3892.   fp16.ToInt32();

  3893.   fp16.ToUInt32();

  3894.   fp16.IsInf();

  3895.   fp16.operator+(fp16);

  3896.   fp16.operator-(fp16);

  3897.   fp16.operator*(fp16);

  3898.   fp16.operator/(fp16);

  3899.   fp16.operator+=(fp16);

  3900.   fp16.operator-=(fp16);

  3901.   fp16.operator*=(fp16);

  3902.   fp16.operator/=(fp16);

  3903.   fp16.operator==(fp16);

  3904.   fp16.operator!=(fp16);

  3905.   fp16.operator>(fp16);

  3906.   fp16.operator>=(fp16);

  3907.   fp16.operator<(fp16);

  3908.   fp16.operator<=(fp16);

  3909.   fp16.operator=(fp16);

  3910. 

  3911.   float f_val = 0.1;

  3912.   fp16.operator=(f_val);

  3913. 

  3914.   double d_val = 0.2;

  3915.   fp16.operator=(d_val);

  3916. 

  3917.   int8_t i_val = 1;

  3918.   fp16.operator=(i_val);

  3919. 

  3920.   uint8_t ui_val = 2;

  3921.   fp16.operator=(ui_val);

  3922. 

  3923.   int16_t i_vals = 1;

  3924.   fp16.operator=(i_vals);

  3925. 

  3926.   uint16_t ui16_val = 1;

  3927.   fp16.operator=(ui16_val);

  3928.   ui16_val = 0;

  3929.   fp16.operator=(ui16_val);

  3930.   ui16_val = 1;

  3931.   fp16.operator=(ui16_val);

  3932. 

  3933.   int32_t i32_val = 0;

  3934.   fp16.operator=(i32_val);

  3935.   i32_val = 1;

  3936.   fp16.operator=(i32_val);

  3937. 

  3938.   uint32_t ui32_val = 0;

  3939.   fp16.operator=(ui32_val);

  3940.   ui32_val = 1;

  3941.   fp16.operator=(ui32_val);

  3942. 

  3943.  float f_val1= 2139095000.2;

  3944.   ge::parser::fp16_t fp16_1,fp16_2;

  3945.   fp16_1.operator=(fp16_2);

  3946.   fp16_1.operator=(f_val1);

  3947. 

  3948.   float f_val2= 0.0000112;

  3949.   fp16_1.operator=(f_val2);

  3950. 

  3951.   float f_val3= 0.0000000299;

  3952.   fp16_1.operator=(f_val3);

  3953. 

  3954.   float f_val4= 0.00000000299;

  3955.   fp16_1.operator=(f_val4);

  3956. 

  3957.   uint32_t  u_val1 = 4095;

  3958.   fp16_1.operator=(u_val1);

  3959. 

  3960.   uint16_t u16_val1 = 4095;

  3961.   fp16_1.operator=(u16_val1);

  3962. 

  3963.   int16_t int_val1 = 0;

  3964.   fp16_1.operator=(int_val1);

  3965. 

  3966.   int16_t int_val2 = -32767;

  3967.   fp16_1.operator=(int_val2);

  3968. 

  3969.   i_val = -0x7FFFFFFF;

  3970.   fp16_1.operator=(i_val);

  3971. 

  3972.   fp16.operator=(f_val1);

  3973.   float f = fp16; //float();

  3974.   double d = fp16;

  3975.   int8_t int8 = fp16;

  3976.   uint8_t uint8 = fp16;

  3977.   uint16_t uint16 = fp16;

  3978.   int32_t int32 = fp16;

  3979.   uint32_t uint32 = fp16;

  3980.   int64_t int64 = fp16;

  3981.   uint64_t uint64 = fp16;

  3982. 

  3983.   (void)f;

  3984.   (void)d;

  3985.   (void)int8;

  3986.   (void)uint8;

  3987.   (void)uint8;

  3988.   (void)uint16;

  3989.   (void)int32;

  3990.   (void)uint32;

  3991.   (void)int64;

  3992.   (void)uint64;

  3993. 

  3994.   parser::fp16_t val;

  3995.   val.val = 0x7C00;

  3996.   val.IsInf();

  3997. 

  3998.   val.val = 0xFC00;

  3999.   val.IsInf();

  4000. 

  4001.   parser::fp16_t fp16_3, fp16_4;

  4002.   fp16_3.val = 1;

  4003.   fp16_4.val = 2;

  4004.   fp16_4.operator/(fp16_3);

  4005. 

  4006.   fp16.val = 21504;

  4007.   int16_t int16 = fp16;

  4008.   int8 = fp16;

  4009. }

  4010. 

  4011. TEST_F(STestTensorflowParser, tensorflow_AclParserInitialize_test)

  4012. {

  4013.   AclGraphParserUtil parseUtil;

  4014.   std::map<std::string, std::string> options;

  4015.   Status ret = parseUtil.AclParserInitialize(options);

  4016.   EXPECT_EQ(ret, FAILED);

  4017. 

  4018.   options = {{ge::FRAMEWORK_TYPE, "2"}};

  4019.   ret = parseUtil.AclParserInitialize(options);

  4020.   EXPECT_EQ(ret, SUCCESS);

  4021. }

  4022. 

  4023. TEST_F(STestTensorflowParser, tensorflow_GetOutputLeaf_test)

  4024. {

  4025.   AclGraphParserUtil parseUtil;

  4026.   ge::ComputeGraphPtr compute_graph = build_graph(true);

  4027.   ge::NodePtr output_nodes_info = compute_graph->FindNode("Relu3");

  4028.   std::vector<std::pair<ge::NodePtr, int32_t>> output_nodes = {{output_nodes_info,0}};

  4029.   ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("default");

  4030.   ge::NodePtr node = AddNode(compute_graph, "K", parser::NETOUTPUT,1,1);

  4031.   Status ret = parseUtil.GetOutputLeaf(node, output_nodes);

  4032.   EXPECT_EQ(ret, FAILED);

  4033. }

  4034. 

  4035. TEST_F(STestTensorflowParser, graph_pass_error)

  4036. {

  4037.   ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");

  4038.   ErrorGraphPass pass;

  4039.   ge::parser::PassManager passManager;

  4040.   std::vector<std::pair<string, GraphPass*>> passes;

  4041.   passes.emplace_back("", &pass);

  4042.   Status status = passManager.Run(graph, passes);

  4043.   EXPECT_EQ(domi::FAILED, status);

  4044. }

  4045. 

  4046. TEST_F(STestTensorflowParser, parser_FindFmkNodeCluser_success)

  4047. {

  4048.   ComputeGraphPtr graph = std::make_shared<ComputeGraph>("FrameworkOp");

  4049.   ParserGraphOptimizer graphOptimizer(graph, domi::TENSORFLOW);

  4050.   ge::NodePtr node = AddNode(graph, "K", parser::FRAMEWORK_OP_TYPE, 1, 1);

  4051.   ge::NodePtr output_nodes_info = graph->FindNode("Relu3");

  4052.   std::unordered_map<string, vector<NodePtr>> node_cluser_Map({

  4053.     {"x", {node, output_nodes_info}},

  4054.   });

  4055.   Status ret = graphOptimizer.FindFmkNodeCluser(node_cluser_Map);

  4056.   EXPECT_EQ(ret, SUCCESS);

  4057. }

  4058. 

  4059. TEST_F(STestTensorflowParser, parser_RebuildOutputAnchors_test)

  4060. {

  4061.   ge::ComputeGraphPtr subGraph = std::make_shared<ge::ComputeGraph>("default");

  4062.   ParserGraphOptimizer graphOptimizer(subGraph, domi::TENSORFLOW);

  4063.   string inputNodeType = "DATA";

  4064.   MakeDagGraph(subGraph, inputNodeType);

  4065. 

  4066.   vector<ge::InDataAnchorPtr> in_anchor;

  4067.   vector<ge::OutDataAnchorPtr> out_anchor;

  4068.   for(ge::NodePtr node : subGraph->GetAllNodes()) {

  4069.     for(auto out : node->GetAllOutDataAnchors()) {

  4070.       for(auto in : node->GetAllInDataAnchors()) {

  4071.         if(in->GetPeerOutAnchor() != nullptr && in->GetPeerOutAnchor()->GetOwnerNode()->GetOpDesc()->GetType() == parser::DATA) {

  4072.             in_anchor.push_back(in);

  4073.         }

  4074.       }

  4075.       for(auto i : out->GetPeerInDataAnchors()) {

  4076.         if(i->GetOwnerNode()->GetOpDesc()->GetType() == parser::NETOUTPUT) {

  4077.             out_anchor.push_back(out);

  4078.         }

  4079.       }

  4080.     }

  4081.   }

  4082.   OpDescPtr fusion_op_desc = make_shared<ge::OpDesc>("FusionCustom", ge::parser::CONSTANT);

  4083.   Status ret = graphOptimizer.RebuildOutputAnchors(out_anchor, fusion_op_desc);

  4084.   EXPECT_EQ(domi::SUCCESS, ret);

  4085. 

  4086.   ret = graphOptimizer.RebuildInputAnchors(in_anchor, fusion_op_desc);

  4087.   EXPECT_EQ(domi::SUCCESS, ret);

  4088. }

  4089. 

  4090. TEST_F(STestTensorflowParser, parser_LinkInnerAnchor_test)

  4091. {

  4092.   ge::ComputeGraphPtr subGraph = std::make_shared<ge::ComputeGraph>("default");

  4093.   NodePtr node_a = AddNode(subGraph, "A", parser::NETOUTPUT, 1, 1);

  4094.   NodePtr node_b = AddNode(subGraph, "B", parser::NETOUTPUT, 1, 1);

  4095.   unordered_map<string, ge::NodePtr> node_map;

  4096.   node_map.insert(pair<string, ge::NodePtr>("A", node_a));

  4097.   node_map.insert(pair<string, ge::NodePtr>("B", node_b));

  4098. 

  4099.   ParserGraphOptimizer graphOptimizer(subGraph, domi::TENSORFLOW);

  4100.   graphOptimizer.LinkInnerAnchor(node_map);

  4101. }

  4102. 

  4103. TEST_F(STestTensorflowParser, parser_MarkForFusion_test)

  4104. {

  4105.   ge::ComputeGraphPtr subGraph = std::make_shared<ge::ComputeGraph>("default");

  4106.   ParserGraphOptimizer graphOptimizer(subGraph, domi::TENSORFLOW);

  4107.   ge::NodePtr node = AddNode(subGraph, "K", parser::FRAMEWORK_OP_TYPE, 1, 1);

  4108.   ge::NodePtr output_nodes_info = subGraph->FindNode("Relu3");

  4109.   std::unordered_map<string, vector<NodePtr>> node_cluser_Map({

  4110.     {"x", {node, output_nodes_info}},

  4111.   });

  4112.   Status ret = graphOptimizer.MarkForFusion(node_cluser_Map);

  4113.   EXPECT_EQ(ret, INTERNAL_ERROR);

  4114. }

  4115. 

  4116. TEST_F(STestTensorflowParser, parser_UpdateGraph_test)

  4117. {

  4118.   std::vector<NodePtr> nodes;

  4119.   ge::ComputeGraphPtr subGraph = std::make_shared<ge::ComputeGraph>("default");

  4120.   ParserGraphOptimizer graphOptimizer(subGraph, domi::TENSORFLOW);

  4121.   NodePtr node_a = AddNode(subGraph, "A", parser::NETOUTPUT, 1, 1);

  4122.   NodePtr node_b = AddNode(subGraph, "B", parser::NETOUTPUT, 1, 1);

  4123.   nodes.emplace_back(node_a);

  4124.   nodes.emplace_back(node_b);

  4125.   Status ret = graphOptimizer.UpdateGraph(nodes);

  4126.   EXPECT_EQ(ret, PARAM_INVALID);

  4127. }

  4128. 

  4129. TEST_F(STestTensorflowParser, parser_RebuildFusionNode_test)

  4130. {

  4131.   ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);

  4132.   ParserGraphOptimizer graphOptimizer(graph, domi::TENSORFLOW);

  4133.   string inputNodeType = "DATA";

  4134.   MakeDagGraph(graph, inputNodeType);

  4135.   vector<ge::InDataAnchorPtr> input_anchors;

  4136.   vector<ge::OutDataAnchorPtr> output_anchors;

  4137.   for(ge::NodePtr node : graph->GetAllNodes()) {

  4138.     for(auto out : node->GetAllOutDataAnchors()) {

  4139.       for(auto in : node->GetAllInDataAnchors()) {

  4140.         if(in->GetPeerOutAnchor() != nullptr && in->GetPeerOutAnchor()->GetOwnerNode()->GetOpDesc()->GetType() == parser::DATA) {

  4141.             input_anchors.push_back(in);

  4142.         }

  4143.       }

  4144.       for(auto i : out->GetPeerInDataAnchors()) {

  4145.         if(i->GetOwnerNode()->GetOpDesc()->GetType() == parser::NETOUTPUT) {

  4146.             output_anchors.push_back(out);

  4147.         }

  4148.       }

  4149.     }

  4150.   }

  4151.   map<ge::OutDataAnchorPtr, vector<ge::InDataAnchorPtr>> output_in_map;

  4152.   vector<ge::InControlAnchorPtr> input_control_anchors;

  4153.   vector<ge::OutControlAnchorPtr> output_control_anchors;

  4154. 

  4155.   ge::OpDescPtr op = std::make_shared<ge::OpDesc>("dpop_123", "FrameworkOp");

  4156.   ge::NodePtr fusion_node = std::make_shared<ge::Node>(op, graph);

  4157.   Status ret = graphOptimizer.RebuildFusionNode(input_anchors, output_anchors, output_in_map, input_control_anchors, output_control_anchors, fusion_node);

  4158.   EXPECT_EQ(ret, FAILED);

  4159. }

  4160. 

  4161. TEST_F(STestTensorflowParser, parser_InsertNode_test)

  4162. {

  4163.   std::vector<NodePtr> nodes;

  4164.   ge::ComputeGraphPtr subGraph = std::make_shared<ge::ComputeGraph>("default");

  4165.   ParserGraphOptimizer graphOptimizer(subGraph, domi::TENSORFLOW);

  4166.   auto merge_node = AddNode(subGraph, "Merge", parser::MERGE, 1, 2);

  4167.   auto node1 = AddNode(subGraph, "Op1", parser::RELU, 1, 1);

  4168.   auto node2 = AddNode(subGraph, "Op2", parser::CONVOLUTION, 1, 1);

  4169.   auto node3 = AddNode(subGraph, "Op3", parser::CONVOLUTION, 1, 1);

  4170.   nodes.emplace_back(merge_node);

  4171.   nodes.emplace_back(node1);

  4172.   nodes.emplace_back(node2);

  4173.   nodes.emplace_back(node3);

  4174.   vector<ge::InDataAnchorPtr> in_anchor;

  4175.   vector<ge::OutDataAnchorPtr> out_anchor;

  4176.   map<ge::OutDataAnchorPtr, vector<ge::InDataAnchorPtr>> output_in_map;

  4177.   vector<ge::InControlAnchorPtr> input_control_anchors;

  4178.   vector<ge::OutControlAnchorPtr> output_control_anchors;

  4179.   unordered_map<string, ge::NodePtr> node_map;

  4180.   node_map.insert(pair<string, ge::NodePtr>("A", merge_node));

  4181.   node_map.insert(pair<string, ge::NodePtr>("B", node1));

  4182.   node_map.insert(pair<string, ge::NodePtr>("C", node2));

  4183.   node_map.insert(pair<string, ge::NodePtr>("D", node3));

  4184. 

  4185.   Status ret = graphOptimizer.InsertNode(subGraph, nodes, in_anchor, out_anchor, output_in_map, input_control_anchors, output_control_anchors, node_map);

  4186.   EXPECT_EQ(ret, PARAM_INVALID);

  4187. }

  4188. 

  4189. TEST_F(STestTensorflowParser, parser_GeStoi_test)

  4190. {

  4191.   TensorFlowModelParser model_parser;

  4192.   string input_node_name = "dynamic_rnn_node1";

  4193.   string index_str = "dynamic_rnn";

  4194.   int32_t index = 0;

  4195. 

  4196.   Status ret = model_parser.GeStoi(input_node_name, index_str, &index);

  4197.   EXPECT_EQ(ret, INTERNAL_ERROR);

  4198. }

  4199. 

  4200. TEST_F(STestTensorflowParser, parser_ConstOpNeedUpdate_test)

  4201. {

  4202.   ge::TensorFlowModelParser tensorflow_parser;

  4203.   NodeDef *op_node_def = new NodeDef();

  4204.   op_node_def->set_name("OP");

  4205.   op_node_def->add_input("OP/Input_1");

  4206.   op_node_def->set_op(TENSORFLOWF_NODE_OP_CONST);

  4207. 

  4208.   NodeDef *input_node = new NodeDef();

  4209.   input_node->set_op(TENSORFLOWF_NODE_OP_IDENTITY);

  4210.   input_node->add_input("OP/Input_1/Input_2");

  4211. 

  4212.   NodeDef *input_2 = new NodeDef();

  4213.   input_2->set_op(TENSORFLOWF_NODE_OP_IDENTITY);

  4214. 

  4215.   tensorflow_parser.nodedef_map_["OP"] = op_node_def;

  4216.   tensorflow_parser.nodedef_map_["OP/Input_1"] = input_node;

  4217.   tensorflow_parser.nodedef_map_["OP/Input_1/Input_2"] = input_2;

  4218. 

  4219.   std::string op_name = "OP/Input_1/Input_2";

  4220.   Status ret = tensorflow_parser.ConstOpNeedUpdate(op_name);

  4221.   EXPECT_EQ(ret, true);

  4222. 

  4223.   op_name = "OP";

  4224.   ret = tensorflow_parser.ConstOpNeedUpdate(op_name);

  4225.   EXPECT_EQ(ret, true);

  4226. 

  4227.   delete op_node_def;

  4228.   delete input_node;

  4229.   delete input_2;

  4230. }

  4231. 

  4232. TEST_F(STestTensorflowParser, parser_UppdateInputMap_test)

  4233. {

  4234.   ge::TensorFlowModelParser tensorflow_parser;

  4235.   ScopeFusionOpInfo info;

  4236.   ge::OpNodeContext normal_op_node_context;

  4237.   ge::OpNodeContext fusion_op_node_context;

  4238. 

  4239.   string fusion_op_name = "dropout";

  4240.   normal_op_node_context.input_map["dropout"].push_back({0, 0});

  4241.   normal_op_node_context.input_map["conv_conv5/BatchNorm/moving_variance"].push_back({0, 1});

  4242.   normal_op_node_context.output_map["dropout"].push_back({1, 0});

  4243.   normal_op_node_context.output_map["conv_conv5/BatchNorm/batchnorm/add/y"].push_back({-1, -1});

  4244. 

  4245.   tensorflow::GraphDef *graph = new tensorflow::GraphDef();

  4246.   ScopePassManager passmanager;

  4247.   shared_ptr<ScopeGraph> scope_graph = passmanager.BuildScopeGraph(graph);

  4248.   NodeDef *node1 = graph->add_node();

  4249.   node1->set_name("dropout");

  4250.   node1->set_op(TENSORFLOWF_NODE_OP_IDENTITY);

  4251.   node1->add_input("conv_conv5/BatchNorm/moving_variance");

  4252.   node1->add_input("conv_conv5/BatchNorm/batchnorm/add/y");

  4253. 

  4254.   NodeDef *node2 = graph->add_node();

  4255.   node2->set_name("conv_conv5/BatchNorm/moving_variance");

  4256.   node2->set_op(TENSORFLOWF_NODE_OP_IDENTITY);

  4257. 

  4258.   NodeDef *node3 = graph->add_node();

  4259.   node3->set_name("conv_conv5/BatchNorm/batchnorm/add/y");

  4260.   node3->set_op(TENSORFLOWF_NODE_OP_IDENTITY);

  4261. 

  4262.   info.fusion_node_name = "conv_conv5/BatchNorm/batchnorm";

  4263.   info.fusion_op_type = parser::FUSIONBATCHNORM;

  4264.   info.node_name = "conv_conv5/BatchNorm/batchnorm/add";

  4265.   info.description = "";

  4266.   info.scope_pass = true;

  4267. 

  4268.   tensorflow_parser.nodedef_map_["dropout"] = node1;

  4269.   tensorflow_parser.nodedef_map_["conv_conv5/BatchNorm/moving_variance"] = node2;

  4270.   tensorflow_parser.nodedef_map_["conv_conv5/BatchNorm/batchnorm/add/y"] = node3;

  4271. 

  4272.   Status ret = tensorflow_parser.UppdateInputMap(scope_graph, info, fusion_op_node_context, normal_op_node_context);

  4273.   EXPECT_EQ(ret, domi::SUCCESS);

  4274. 

  4275.   ret = tensorflow_parser.UppdateOutputMap(scope_graph, info, fusion_op_node_context, normal_op_node_context);

  4276. 

  4277.   TensorFlowWeightsParser weights_parser;

  4278.   std::string caseDir = __FILE__;

  4279.   std::size_t idx = caseDir.find_last_of("/");

  4280.   caseDir = caseDir.substr(0, idx);

  4281.   std::string proto_file = caseDir + "/origin_models/tf_add.pb";

  4282.   const char *file = proto_file.c_str();

  4283.   ge::Graph graphs;

  4284.   Status weightsRet = weights_parser.Parse(file, graphs);

  4285.   EXPECT_EQ(weightsRet, SUCCESS);

  4286.   delete graph;

  4287. }

  4288. 

  4289. TEST_F(STestTensorflowParser, tensorflow_optimizer_fmk_fusion_op) {

  4290.   std::string caseDir = __FILE__;

  4291.   std::size_t idx = caseDir.find_last_of("/");

  4292.   caseDir = caseDir.substr(0, idx);

  4293.   const std::string root_proto = caseDir + "/origin_models/test_getnext_dynamic_fusion.pbtxt";

  4294.   domi::tensorflow::GraphDef graphDef;

  4295. 

  4296.   bool protoRet = parser::ReadProtoFromText(root_proto.c_str(), &graphDef);

  4297.   ASSERT_EQ(protoRet, true);

  4298. 

  4299.   TensorFlowModelParser tensorflow_parser;

  4300.   ge::ComputeGraphPtr root_graph = ge::parser::MakeShared<ge::ComputeGraph>("tmp_graph");

  4301.   Status ret = tensorflow_parser.ParseProto(reinterpret_cast<google::protobuf::Message *>(&graphDef), root_graph);

  4302.   EXPECT_EQ(ret, SUCCESS);

  4303.   EXPECT_EQ(root_graph->GetDirectNode().size(), 3);

  4304. }

  4305. 

  4306. TEST_F(STestTensorflowParser, AddDumpOriginName_test)

  4307. {

  4308.   GeTensorDesc scalar_tensor(GeShape(), ge::FORMAT_NCHW, ge::DT_FLOAT);

  4309.   ge::ComputeGraphPtr parent_graph = std::make_shared<ge::ComputeGraph>("parent_graph");

  4310.   ge::OpDescPtr parent = std::make_shared<ge::OpDesc>();

  4311.   parent->SetType("Foo");

  4312.   parent->SetName("foo");

  4313.   ge::NodePtr foo = parent_graph->AddNode(parent);

  4314. 

  4315. 

  4316.   ge::ComputeGraphPtr sub_graph = std::make_shared<ge::ComputeGraph>("sub_graph");

  4317.   auto child = std::make_shared<ge::OpDesc>();

  4318.   child->SetType("Bar");

  4319.   child->SetName("bar");

  4320.   ge::NodePtr bar = sub_graph->AddNode(child);

  4321. 

  4322.   AddDumpOriginName(foo, "f", sub_graph);

  4323. 

  4324.   std::vector<std::string> original_names;

  4325.   (void)ge::AttrUtils::GetListStr(bar->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names);

  4326.   EXPECT_EQ(original_names.size(), 1U);

  4327.   EXPECT_EQ(original_names[0], "foo/f/bar");

  4328. 

  4329.   (void)ge::AttrUtils::SetListStr(foo->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names);

  4330.   AddDumpOriginName(foo, "f", sub_graph);

  4331. 

  4332.   original_names.clear();

  4333.   (void)ge::AttrUtils::GetListStr(bar->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names);

  4334.   EXPECT_EQ(original_names.size(), 1U);

  4335.   EXPECT_EQ(original_names[0], "foo/f/bar/f/bar");

  4336. 

  4337.   original_names.push_back("abc");

  4338.   (void)ge::AttrUtils::SetListStr(foo->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names);

  4339.   AddDumpOriginName(foo, "f", sub_graph);

  4340. 

  4341.   original_names.clear();

  4342.   (void)ge::AttrUtils::GetListStr(bar->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names);

  4343.   EXPECT_EQ(original_names.size(), 2U);

  4344.   EXPECT_EQ(original_names[0], "foo/f/bar/f/bar/f/bar");

  4345.   EXPECT_EQ(original_names[1], "abc");

  4346. }

  4347. 

  4348. TEST_F(STestTensorflowParser, test_plugin_manager_getopp_plugin_vendors_01) {

  4349.   std::string opp_path = __FILE__;

  4350.   opp_path = opp_path.substr(0, opp_path.rfind("/") + 1);

  4351.   setenv("ASCEND_OPP_PATH", opp_path.c_str(), 1);

  4352. 

  4353.   std::string path_vendors = opp_path + "vendors";

  4354.   std::string path_config = path_vendors + "/config.ini";

  4355.   system(("mkdir -p " + path_vendors).c_str());

  4356.   system(("echo 'load_priority=customize,mdc,lhisi' > " + path_config).c_str());

  4357. 

  4358.   std::vector<std::string> vendors;

  4359.   Status ret = TBEPluginLoader::GetOppPluginVendors(path_config, vendors);

  4360.   EXPECT_EQ(ret, SUCCESS);

  4361.   EXPECT_EQ(vendors[0], "customize");

  4362.   EXPECT_EQ(vendors[1], "mdc");

  4363.   EXPECT_EQ(vendors[2], "lhisi");

  4364. }

  4365. 

  4366. TEST_F(STestTensorflowParser, test_plugin_manager_getopp_plugin_vendors_02) {

  4367.   std::string opp_path = __FILE__;

  4368.   opp_path = opp_path.substr(0, opp_path.rfind("/") + 1);

  4369.   setenv("ASCEND_OPP_PATH", opp_path.c_str(), 1);

  4370. 

  4371.   std::string path_vendors = opp_path + "vendors";

  4372.   std::string path_config = path_vendors + "/config.ini";

  4373.   system(("mkdir -p " + path_vendors).c_str());

  4374.   system(("echo '' > " + path_config).c_str());

  4375. 

  4376.   std::vector<std::string> vendors;

  4377.   Status ret = TBEPluginLoader::GetOppPluginVendors(path_config, vendors);

  4378.   EXPECT_NE(ret, SUCCESS);

  4379. }

  4380. 

  4381. TEST_F(STestTensorflowParser, test_plugin_manager_getopp_plugin_vendors_03) {

  4382.   std::string opp_path = __FILE__;

  4383.   opp_path = opp_path.substr(0, opp_path.rfind("/") + 1);

  4384.   setenv("ASCEND_OPP_PATH", opp_path.c_str(), 1);

  4385. 

  4386.   std::string path_vendors = opp_path + "vendors";

  4387.   std::string path_config = path_vendors + "/config.ini";

  4388.   system(("mkdir -p " + path_vendors).c_str());

  4389.   system(("echo 'load_priority' > " + path_config).c_str());

  4390. 

  4391.   std::vector<std::string> vendors;

  4392.   Status ret = TBEPluginLoader::GetOppPluginVendors(path_config, vendors);

  4393.   EXPECT_NE(ret, SUCCESS);

  4394. }

  4395. 

  4396. TEST_F(STestTensorflowParser, test_plugin_manager_GetOpsProtoPath_01) {

  4397.   std::string opp_path = __FILE__;

  4398.   opp_path = opp_path.substr(0, opp_path.rfind("/") + 1);

  4399.   setenv("ASCEND_OPP_PATH", opp_path.c_str(), 1);

  4400. 

  4401.   std::string path_vendors = opp_path + "vendors";

  4402.   system(("rm -rf " + path_vendors).c_str());

  4403. 

  4404.   std::string opsproto_path;

  4405.   Status ret = TBEPluginLoader::GetOpsProtoPath(opsproto_path);

  4406.   EXPECT_EQ(ret, SUCCESS);

  4407.   EXPECT_EQ(opsproto_path,

  4408.       opp_path + "op_proto/custom/:" + opp_path + "op_proto/built-in/"

  4409.   );

  4410. }

  4411. 

  4412. TEST_F(STestTensorflowParser, test_plugin_manager_GetOpsProtoPath_02) {

  4413.   std::string opp_path = __FILE__;

  4414.   opp_path = opp_path.substr(0, opp_path.rfind("/") + 1);

  4415.   setenv("ASCEND_OPP_PATH", opp_path.c_str(), 1);

  4416. 

  4417.   std::string path_vendors = opp_path + "vendors";

  4418.   std::string path_config = path_vendors + "/config.ini";

  4419.   system(("mkdir -p " + path_vendors).c_str());

  4420.   system(("echo 'load_priority=customize,mdc,lhisi' > " + path_config).c_str());

  4421. 

  4422.   std::string opsproto_path;

  4423.   Status ret = TBEPluginLoader::GetOpsProtoPath(opsproto_path);

  4424.   EXPECT_EQ(ret, SUCCESS);

  4425.   EXPECT_EQ(opsproto_path,

  4426.     path_vendors + "/customize/op_proto/:" +

  4427.     path_vendors + "/mdc/op_proto/:" +

  4428.     path_vendors + "/lhisi/op_proto/:" +

  4429.     opp_path + "built-in/op_proto/"

  4430.   );

  4431. }

  4432. 

  4433. TEST_F(STestTensorflowParser, test_plugin_manager_GetCustomOpPath_01) {

  4434.   std::string opp_path = __FILE__;

  4435.   opp_path = opp_path.substr(0, opp_path.rfind("/") + 1);

  4436.   setenv("ASCEND_OPP_PATH", opp_path.c_str(), 1);

  4437. 

  4438.   std::string path_vendors = opp_path + "vendors";

  4439.   system(("rm -rf " + path_vendors).c_str());

  4440. 

  4441.   std::string customop_path;

  4442.   TBEPluginLoader::GetCustomOpPath(customop_path);

  4443.   EXPECT_EQ(customop_path.find(opp_path + "framework/custom/:" + opp_path + "framework/built-in/"), 0);

  4444. }

  4445. 

  4446. TEST_F(STestTensorflowParser, test_plugin_manager_GetCustomOpPath_02) {

  4447.   std::string opp_path = __FILE__;

  4448.   opp_path = opp_path.substr(0, opp_path.rfind("/") + 1);

  4449.   setenv("ASCEND_OPP_PATH", opp_path.c_str(), 1);

  4450. 

  4451.   std::string path_vendors = opp_path + "vendors";

  4452.   std::string path_config = path_vendors + "/config.ini";

  4453.   system(("mkdir -p " + path_vendors).c_str());

  4454.   system(("echo 'load_priority=customize,mdc,lhisi' > " + path_config).c_str());

  4455. 

  4456.   std::string customop_path;

  4457.   TBEPluginLoader::GetCustomOpPath(customop_path);

  4458.   EXPECT_EQ(customop_path.find(

  4459.     path_vendors + "/customize/framework/:" +

  4460.     path_vendors + "/mdc/framework/:" +

  4461.     path_vendors + "/lhisi/framework/:" +

  4462.     opp_path + "built-in/framework/"), 0);

  4463. }

  4464. } // namespace ge