Pre Merge pull request !517 from 韩健/hanjian

parser/caffe/caffe_parser.cc

@@ -1439,7 +1439,7 @@ Status CaffeModelParser::Parse(const char *model_path, ge::ComputeGraphPtr &grap
   bool has_error = false;
   GE_CHECK_NOTNULL(model_path);
   GE_CHECK_NOTNULL(graph);
-  GELOGI("Caffe Parse model file %s", model_path);
+  GELOGI("Caffe Parse model file [%s]", model_path);
 
   PreChecker::Instance().Clear();
 
@@ -1473,8 +1473,8 @@ Status CaffeModelParser::Parse(const char *model_path, ge::ComputeGraphPtr &grap
   GE_RETURN_IF_ERROR(PreCheck(proto_message));
 
   if (PreChecker::Instance().HasError()) {
-    REPORT_INNER_ERROR("E19999", "Precheck failed. Please read check report.");
-    GELOGE(INTERNAL_ERROR, "[Has][Error]Precheck failed. Please read check report.");
+    REPORT_INNER_ERROR("E19999", "Precheck failed. a report of json format will be create, Please read it.");
+    GELOGE(INTERNAL_ERROR, "[Has][Error]Precheck failed. a report of json format will be create, Please read it.");
     return FAILED;
   }
 

parser/common/pre_checker.cc

@@ -99,9 +99,9 @@ Status PreChecker::CheckName(OpId id) {
     if (id != v.first && info.name == v.second.name) {
       Cause cause;
       cause.code = ErrorCode::NAME_REPEATED;
-      cause.message = "The name is repeated.";
+      cause.message = "The name is repeated in the graph.";
 
-      GELOGI("Name %s repeated.", info.name.c_str());
+      GELOGE(FAILED, "opname %s repeated, same name op in the graph", info.name.c_str());
       ErrorManager::GetInstance().ATCReportErrMessage("E19009", {"opname"}, {info.name});
       GE_RETURN_WITH_LOG_IF_ERROR(AddCause(id, cause), "[Add][Cause] failed.");
       GE_RETURN_WITH_LOG_IF_ERROR(AddCause(v.first, cause), "[Add][Cause] failed.");
@@ -250,7 +250,7 @@ Status PreChecker::CheckTypeSupported(OpId id, const string &type, const string
       Cause cause;
       cause.code = ErrorCode::TYPE_UNSUPPORTED;
       cause.message = "The type is not supported.";
-      GELOGI("Check op[%s]'s type[%s] failed, it is not supported.", name.c_str(), type.c_str());
+      GELOGI("Check op[%s]'s type[%s] is not supported.", name.c_str(), type.c_str());
       if (!is_tensorflow) {
         ErrorManager::GetInstance().ATCReportErrMessage("E19010", {"opname", "optype"}, {name, type});
       }
@@ -265,9 +265,11 @@ Status PreChecker::CheckTypeSupported(OpId id, const string &type, const string
     cause.code = ErrorCode::TYPE_UNSUPPORTED;
     cause.message = "The type is not supported.";
 
-    GELOGI("Check op[%s]'s type[%s] failed, it is not supported.", name.c_str(), type.c_str());
     if (!is_tensorflow) {
       ErrorManager::GetInstance().ATCReportErrMessage("E19010", {"opname", "optype"}, {name, type});
+      GELOGE(FAILED, "Check op[%s]'s type[%s] failed, it is not supported.", name.c_str(), type.c_str());
+    } else {
+      GELOGI("Check op[%s]'s type[%s] is not supported.", name.c_str(), type.c_str());
     }
     GE_RETURN_WITH_LOG_IF_ERROR(AddCause(id, cause), "[Add][Cause] failed.");
   }

parser/tensorflow/tensorflow_parser.cc

@@ -1361,7 +1361,7 @@ Status TensorFlowModelParser::Parse(const char *model_path, ge::ComputeGraphPtr
   domi::tensorflow::GraphDef ori_def;
   bool read = ge::parser::ReadProtoFromBinaryFile(model_path, &ori_def);
   if (!read) {
-    GELOGE(FAILED, "read_proto_from_binary failed.");
+    GELOGE(FAILED, "read_proto_from_binary failed. --framework=3, file format should be tensorflow.");
     return INTERNAL_ERROR;
   }
 
@@ -3186,7 +3186,7 @@ Status TensorFlowModelParser::TrimGraphByOutput(const domi::tensorflow::GraphDef
       GE_CHK_BOOL_EXEC(node_lookup.count(current_input) > 0U,
                        ErrorManager::GetInstance().ATCReportErrMessage("E10016", {"parameter", "opname"},
                                                                        {"out_nodes", current_input});
-                       return FAILED, "Input op[%s] not found in graph.", current_input.c_str());
+                       return FAILED, "op[%s] not found in graph.", current_input.c_str());
       const NodeDef *current_node = node_lookup[current_input];
       GE_CHECK_NOTNULL(current_node);
       for (const string &input_name : current_node->input()) {
@@ -3442,7 +3442,10 @@ Status TensorFlowModelParser::AddControlEdgeAfterRemoveInputs(domi::tensorflow::
     if (input_node_def->op() == parser::SWITCH || input_node_def->op() == parser::REFSWITCH) {
       NodeDef *identity_node_def = graph_def->add_node();
       GE_CHECK_NOTNULL(identity_node_def);
-      input_node_name = input_node_name + "identity";
+      std::string remove_input_name = remove_input;
+      remove_input_name = remove_input_name.find(":") == std::string::npos ?
+          input_node_name : (remove_input_name.replace(remove_input_name.find(":"), 1, "_"));
+      input_node_name = remove_input_name + "_identity";
       identity_node_def->set_name(input_node_name);
       identity_node_def->set_op(parser::IDENTITY);
       identity_node_def->add_input(remove_input);

tests/st/testcase/test_caffe_parser.cc

@@ -36,6 +36,7 @@
 #include "parser/caffe/caffe_op_parser.h"
 #include "graph/operator_reg.h"
 #include "parser/common/acl_graph_parser_util.h"
+#include "common/op_map.h"
 #undef protected
 #undef private
 
@@ -223,6 +224,10 @@ TEST_F(STestCaffeParser, acl_caffe_parser) {
   EXPECT_EQ(ret, GRAPH_FAILED);
   ret = ge::aclgrphParseCaffe(model_file.c_str(), weight_file.c_str(), graph);
   EXPECT_EQ(ret, GRAPH_FAILED);
+
+  caffe_op_map.clear();
+  ret = ge::aclgrphParseCaffe(model_file.c_str(), weight_file.c_str(), parser_params, graph);
+  EXPECT_EQ(ret, GRAPH_FAILED);
 }
 
 TEST_F(STestCaffeParser, modelparser_parsefrommemory_success)

tests/st/testcase/test_tensorflow_parser.cc

@@ -2832,6 +2832,15 @@ TEST_F(STestTensorflowParser, tensorflow_AddControlEdgeAfterRemoveInputs_test)
   removed_inputs_vec.emplace_back("Add0");
   Status ret = tensorflow_parser.AddControlEdgeAfterRemoveInputs(&graph_def, node_def, all_node_map, removed_inputs_vec);
   EXPECT_EQ(ret, SUCCESS);
+    
+  tensorflow::NodeDef *node_swith = initNodeDef();
+  node_swith->set_name("switch_op");
+  node_swith->set_op(parser::SWITCH);
+  all_node_map.emplace("switch_op", node_swith);
+  removed_inputs_vec.clear();
+  removed_inputs_vec.emplace_back("switch_op");
+  ret = tensorflow_parser.AddControlEdgeAfterRemoveInputs(&graph_def, node_swith, all_node_map, removed_inputs_vec);
+  EXPECT_EQ(ret, SUCCESS);
 }
 
 TEST_F(STestTensorflowParser, tensorflow_GraphDefOptimizeIdentity_test)

tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc

@@ -39,6 +39,7 @@
 #include "graph/operator_reg.h"
 #include "parser/common/acl_graph_parser_util.h"
 #include "parser/caffe/caffe_reshape_parser.h"
+#include "common/op_map.h"
 #undef protected
 #undef private
 
@@ -266,6 +267,10 @@ TEST_F(UtestCaffeParser, acl_caffe_parser) {
   EXPECT_EQ(ret, GRAPH_FAILED);
   ret = ge::aclgrphParseCaffe(model_file.c_str(), weight_file.c_str(), graph);
   EXPECT_EQ(ret, GRAPH_FAILED);
+  
+  caffe_op_map.clear();
+  ret = ge::aclgrphParseCaffe(model_file.c_str(), weight_file.c_str(), parser_params, graph);
+  EXPECT_EQ(ret, GRAPH_FAILED);
 }
 
 TEST_F(UtestCaffeParser, ParseFromMemory_success)

tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc

@@ -34,6 +34,7 @@
 #include "parser/common/pass_manager.h"
 #include "parser/common/tbe_plugin_loader.h"
 #include "parser/common/parser_fp16_t.h"
+#include "parser/common/pre_checker.h"
 #undef protected
 #undef private
 
@@ -342,4 +343,15 @@ TEST_F(UtestAclGraphParser, test_operatoreq)
   int8 = fp16;
 }
 
+TEST_F(UtestAclGraphParser, test_pre_checker) {
+  PreChecker::Instance().fmk_op_types_ = nullptr;
+  const char* str = "iiii";
+  PreChecker::OpId id = str;
+  std::string type("ddd");
+  std::string name("lll");
+  Status ret = PreChecker::Instance().CheckTypeSupported(id, type, name, false);
+  EXPECT_EQ(ret, FAILED);
+  ret = PreChecker::Instance().CheckTypeSupported(id, type, name, true);
+  EXPECT_EQ(ret, FAILED);
+}
 } // namespace ge

tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc

@@ -3008,6 +3008,15 @@ TEST_F(UtestTensorflowParser, tensorflow_AddControlEdgeAfterRemoveInputs_test)
   removed_inputs_vec.emplace_back("Add0");
   Status ret = tensorflow_parser.AddControlEdgeAfterRemoveInputs(&graph_def, node_def, all_node_map, removed_inputs_vec);
   EXPECT_EQ(ret, SUCCESS);
+
+  tensorflow::NodeDef *node_swith = initNodeDef();
+  node_swith->set_name("switch_op");
+  node_swith->set_op(parser::SWITCH);
+  all_node_map.emplace("switch_op", node_swith);
+  removed_inputs_vec.clear();
+  removed_inputs_vec.emplace_back("switch_op");
+  ret = tensorflow_parser.AddControlEdgeAfterRemoveInputs(&graph_def, node_swith, all_node_map, removed_inputs_vec);
+  EXPECT_EQ(ret, SUCCESS);
 }
 
 TEST_F(UtestTensorflowParser, tensorflow_GraphDefOptimizeIdentity_test)