update c76 parser code

.gitmodules

@@ -1,4 +1,4 @@
 [submodule "metadef"]
 	path = metadef
 	url = https://gitee.com/ascend/metadef.git
-	branch = development
+	branch = r1.2.0

CMakeLists.txt

@@ -36,8 +36,6 @@ if (ENABLE_OPEN_SRC)
         find_module(slog libslog.so ${GE_LIB_PATH})
         find_module(static_mmpa libmmpa.a ${GE_LIB_PATH})
         find_module(error_manager liberror_manager.so ${GE_LIB_PATH})
-    elseif(ENABLE_GE_COV OR ENABLE_GE_UT)
-        message(STATUS "Runing on llt mode, no need to depend other component")
     else()
         if(DEFINED ENV{ASCEND_CUSTOM_PATH})
             set(ASCEND_DIR $ENV{ASCEND_CUSTOM_PATH})

cmake/FindModule.cmake

@@ -7,7 +7,6 @@ function(find_module module name path)
     if (TARGET ${module})
         return()
     endif()
-    add_library(${module} INTERFACE)
     find_library(${module}_LIBRARY_DIR NAMES ${name} NAMES_PER_DIR PATHS ${path}
       PATH_SUFFIXES lib
     )
@@ -16,5 +15,9 @@ function(find_module module name path)
     if ("${${module}_LIBRARY_DIR}" STREQUAL "${module}_LIBRARY_DIR-NOTFOUND")
       message(FATAL_ERROR "${name} not found in ${path}")
     endif()
-    target_link_libraries(${module} INTERFACE ${${module}_LIBRARY_DIR})
+    
+    add_library(${module} SHARED IMPORTED)
+    set_target_properties(${module} PROPERTIES
+      IMPORTED_LOCATION ${${module}_LIBRARY_DIR}
+    )
 endfunction()

inc/external/parser/onnx_parser.h

@@ -17,17 +17,21 @@
 #ifndef INC_EXTERNAL_PARSER_ONNX_PARSER_H_
 #define INC_EXTERNAL_PARSER_ONNX_PARSER_H_
 
+#include <memory>
+#include <map>
+
 #include "graph/ascend_string.h"
 #include "graph/ge_error_codes.h"
-#include "graph/graph.h"
 #include "graph/types.h"
+#include "graph/graph.h"
 
 namespace ge {
 graphStatus aclgrphParseONNX(const char *model_file,
-                             const std::map<ge::AscendString, ge::AscendString> &parser_params, ge::Graph &graph);
+                             std::map<ge::AscendString, ge::AscendString> &parser_params,
+                             ge::Graph &graph);
 
-graphStatus aclgrphParseONNXFromMem(const char *buffer, size_t size,
-                                    const std::map<ge::AscendString, ge::AscendString> &parser_params,
+graphStatus aclgrphParseONNXFromMem(const char *buffer, size_t buffer_size,
+                                    std::map<ge::AscendString, ge::AscendString> &parser_params,
                                     ge::Graph &graph);
 }  // namespace ge
 

metadef

@@ -1 +1 @@
-Subproject commit c14d2be38171eed63416e71178774103faf1f5cd
+Subproject commit 5a1b0ab95e2d205ee9ee578ac4bcde4f4fbed6d8

parser/caffe/caffe_parser.h

@@ -56,20 +56,17 @@ class CaffeModelParser : public domi::ModelParser {
 
   /**
    * @ingroup domi_omg
-   * @brief Parse the relevant data from memory and save it to graph
-   * @param [in] memory buffer of model file
-   * @param [in] buffer size
+   * @brief Parse the relevant data from the memory and save it to graph
+   * @param [in] file Path of model file
    * @param [in|out] graph graph for saving model information
    * @return SUCCESS parse successfully
    * @return FAILED parse failed
    */
   Status ParseFromMemory(const char *data, uint32_t size, ge::ComputeGraphPtr &graph) override;
 
-#ifndef ONLY_COMPILE_OPEN_SRC
   Status ParseFromMemory(const char *data, uint32_t size, ge::Graph &graph) override {
-    return domi::SUCCESS;
+      return domi::SUCCESS;
   }
-#endif
 
   /**
    * @ingroup domi_omg

parser/caffe/proto/ge_ir.proto

@@ -30,7 +30,6 @@ enum DataType
     DT_RESOURCE  = 23;         // resource type
     DT_STRING_REF = 24;        // string_ref type
     DT_DUAL      = 25;              /**< dual output type */
-    DT_VARIANT = 26;           // variant type
 }
 
 message AttrDef

parser/common/acl_graph_parser_util.cc

@@ -784,7 +784,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromBinaryFile(co
   google::protobuf::io::CodedInputStream coded_stream(&istream);
 
   bool ret = ReadProtoFromCodedInputStream(coded_stream, proto);
-
   fs.close();
 
   if (!ret) {

parser/common/parser_api.cc

@@ -16,7 +16,6 @@
 
 #include "framework/omg/parser/parser_api.h"
 #include "common/debug/log.h"
-
 #include "tbe_plugin_loader.h"
 #include "framework/common/debug/ge_log.h"
 #include "parser/common/register_tbe.h"
@@ -41,7 +40,7 @@ Status ParserInitialize(const std::map<std::string, std::string> &options) {
   std::string fmk_type = std::to_string(domi::TENSORFLOW);
   auto it = options.find(ge::FRAMEWORK_TYPE);
   if (it != options.end()) {
-   fmk_type = it->second;
+    fmk_type = it->second;
   }
   std::vector<OpRegistrationData> registrationDatas = domi::OpRegistry::Instance()->registrationDatas;
   GELOGI("The size of registrationDatas in parser is: %zu", registrationDatas.size());

parser/common/proto/ge_ir.proto

@@ -30,7 +30,6 @@ enum DataType
     DT_RESOURCE  = 23;         // resource type
     DT_STRING_REF = 24;        // string_ref type
     DT_DUAL      = 25;              /**< dual output type */
-    DT_VARIANT = 26;           // variant type
 }
 
 message AttrDef

parser/onnx/CMakeLists.txt

@@ -115,7 +115,6 @@ target_include_directories(fmk_onnx_parser_stub PRIVATE
     ${PARSER_DIR}/parser
     ${PARSER_DIR}/../inc
     ${METADEF_DIR}/inc
-    ${METADEF_DIR}/inc/graph
     ${METADEF_DIR}/inc/external
     ${METADEF_DIR}/inc/external/graph
 )

parser/onnx/module.mk

@@ -52,7 +52,7 @@ LOCAL_SHARED_LIBRARIES := \
     libregister \
     liberror_manager \
 
-LOCAL_STATIC_LIBRARIES += libmmpa   
+LOCAL_STATIC_LIBRARIES += libmmpa
 
 LOCAL_LDFLAGS := -lrt -ldl
 
@@ -62,7 +62,6 @@ include $(BUILD_HOST_SHARED_LIBRARY)
 include $(CLEAR_VARS)
 
 LOCAL_C_INCLUDES := \
-    $(TOPDIR)inc \
     $(TOPDIR)metadef/inc \
     $(TOPDIR)parser/inc \
     $(TOPDIR)inc/external \
@@ -88,4 +87,3 @@ LOCAL_SHARED_LIBRARIES :=
 LOCAL_LDFLAGS := -lrt -ldl
 
 include $(BUILD_HOST_SHARED_LIBRARY)
-

parser/onnx/onnx_parser.cc

@@ -19,8 +19,8 @@
 #include <iostream>
 #include "common/convert/pb2json.h"
 #include "common/util.h"
-#include "common/ge_types.h"
 #include "common/util/error_manager/error_manager.h"
+#include "common/ge_types.h"
 #include "external/graph/operator_factory.h"
 #include "external/register/register_error_codes.h"
 #include "external/parser/onnx_parser.h"
@@ -39,17 +39,16 @@
 #include "register/op_registry.h"
 
 namespace ge {
-graphStatus PrepareBeforeParse(AclGrphParseUtil &acl_graph_parse_util,
-                               const std::map<AscendString, AscendString> &parser_params,
-                               ge::Graph &graph, std::shared_ptr<domi::ModelParser> &model_parser) {
+graphStatus aclgrphParseONNX(const char *model_file,
+                             std::map<AscendString, AscendString> &parser_params, ge::Graph &graph) {
+  GE_CHECK_NOTNULL(model_file);
   GetParserContext().type = domi::ONNX;
   std::map<string, string> options;
   options.insert(std::pair<string, string>(string(ge::FRAMEWORK_TYPE), to_string(ge::ONNX)));
 
-  if (acl_graph_parse_util.AclParserInitialize(options) != ge::SUCCESS) {
-    GELOGE(ge::FAILED, "Acl parser initialize failed.");
-    return ge::FAILED;
-  }
+  // load custom plugin so and proto
+  AclGrphParseUtil acl_graph_parse_util;
+  (void)acl_graph_parse_util.AclParserInitialize(options);
 
   string output_name;
   if (acl_graph_parse_util.ParseParamsBeforeGraph(parser_params, output_name) != ge::SUCCESS) {
@@ -62,40 +61,9 @@ graphStatus PrepareBeforeParse(AclGrphParseUtil &acl_graph_parse_util,
   GE_CHECK_NOTNULL(compute_graph);
 
   graph = ge::GraphUtils::CreateGraphFromComputeGraph(compute_graph);
-  model_parser = domi::ModelParserFactory::Instance()->CreateModelParser(domi::ONNX);
+  auto model_parser = domi::ModelParserFactory::Instance()->CreateModelParser(domi::ONNX);
   GE_CHECK_NOTNULL(model_parser);
-  return ge::SUCCESS;
-}
-
-graphStatus HandleAfterParse(AclGrphParseUtil &acl_graph_parse_util,
-                               const std::map<AscendString, AscendString> &parser_params,
-                               ge::Graph &graph) {
-  if (acl_graph_parse_util.ParseParamsAfterGraph(graph, parser_params) != ge::SUCCESS) {
-    GELOGE(ge::FAILED, "Parser params after graph failed.");
-    return ge::FAILED;
-  }
-
-  if (acl_graph_parse_util.SetOutputNodeInfo(graph, parser_params) != ge::SUCCESS) {
-    GELOGE(ge::FAILED, "Set graph %s default output node failed.", graph.GetName().c_str());
-    return ge::FAILED;
-  }
-  return ge::SUCCESS;
-}
-
-graphStatus aclgrphParseONNX(const char *model_file,
-                             const std::map<AscendString, AscendString> &parser_params, ge::Graph &graph) {
-#ifndef ONLY_COMPILE_OPEN_SRC								 
-  GE_CHECK_NOTNULL(model_file);
-  // load custom plugin so and proto
-  AclGrphParseUtil acl_graph_parse_util;
-  std::shared_ptr<domi::ModelParser> model_parser;
 
-  if (PrepareBeforeParse(acl_graph_parse_util, parser_params, graph, model_parser) != ge::SUCCESS) {
-    GELOGE(ge::FAILED, "Prepare before parse failed.");
-    return ge::FAILED;
-  }
-
-  GE_CHECK_NOTNULL(model_parser);
   // parse caffe model_file to GE graph
   ge::graphStatus ret = model_parser->Parse(model_file, graph);
   if (ret != ge::SUCCESS) {
@@ -104,44 +72,63 @@ graphStatus aclgrphParseONNX(const char *model_file,
   }
   GELOGI("Parser graph %s success.", graph.GetName().c_str());
 
-  if (HandleAfterParse(acl_graph_parse_util, parser_params, graph) != ge::SUCCESS) {
-    GELOGE(ge::FAILED, "Handle after parse failed.");
+  if (acl_graph_parse_util.ParseParamsAfterGraph(graph, parser_params) != ge::SUCCESS) {
+    GELOGE(ge::FAILED, "Parser params after graph failed.");
     return ge::FAILED;
   }
 
+  if (acl_graph_parse_util.SetOutputNodeInfo(graph, parser_params) != ge::SUCCESS) {
+    GELOGE(ge::FAILED, "Set graph %s default output node failed.", graph.GetName().c_str());
+    return ge::FAILED;
+  }
   GELOGI("AclgrphParse graph %s success.", graph.GetName().c_str());
-#endif
   return ge::SUCCESS;
 }
 
-graphStatus aclgrphParseONNXFromMem(const char *buffer, size_t size,
-                                    const std::map<AscendString, AscendString> &parser_params, ge::Graph &graph) {
-#ifndef ONLY_COMPILE_OPEN_SRC
+graphStatus aclgrphParseONNXFromMem(const char *buffer, size_t buffer_size,
+                                    std::map<AscendString, AscendString> &parser_params, ge::Graph &graph) {
   GE_CHECK_NOTNULL(buffer);
+  GetParserContext().type = domi::ONNX;
+  std::map<string, string> options;
+  options.insert(std::pair<string, string>(string(ge::FRAMEWORK_TYPE), to_string(ge::ONNX)));
+
   // load custom plugin so and proto
   AclGrphParseUtil acl_graph_parse_util;
-  std::shared_ptr<domi::ModelParser> model_parser;
+  (void)acl_graph_parse_util.AclParserInitialize(options);
 
-  if (PrepareBeforeParse(acl_graph_parse_util, parser_params, graph, model_parser)  != ge::SUCCESS) {
-    GELOGE(ge::FAILED, "Prepare before parse failed.");
+  string output_name;
+  if (acl_graph_parse_util.ParseParamsBeforeGraph(parser_params, output_name) != ge::SUCCESS) {
+    GELOGE(ge::FAILED, "Parser params before graph failed.");
     return ge::FAILED;
   }
+  // Create an empty computegraph
+  string graph_name = output_name.empty() ? "tmpGraph" : output_name;
+  ge::ComputeGraphPtr compute_graph = ge::parser::MakeShared<ge::ComputeGraph>(graph_name);
+  GE_CHECK_NOTNULL(compute_graph);
 
-  // parse caffe model_file to GE graph
-  ge::graphStatus ret = model_parser->ParseFromMemory(buffer, (uint32_t)size, graph);
+  graph = ge::GraphUtils::CreateGraphFromComputeGraph(compute_graph);
+  auto model_parser = domi::ModelParserFactory::Instance()->CreateModelParser(domi::ONNX);
+  GE_CHECK_NOTNULL(model_parser);
+
+  // parse caffe model_file and weights_file to GE graph
+  ge::graphStatus ret = model_parser->ParseFromMemory(buffer, (uint32_t)buffer_size, graph);
   if (ret != ge::SUCCESS) {
     GELOGE(ret, "Parser graph %s failed.", graph.GetName().c_str());
     return ge::FAILED;
   }
   GELOGI("Parser graph %s success.", graph.GetName().c_str());
 
-  if (HandleAfterParse(acl_graph_parse_util, parser_params, graph)  != ge::SUCCESS) {
-    GELOGE(ge::FAILED, "Handle after parse failed.");
+  if (acl_graph_parse_util.ParseParamsAfterGraph(graph, parser_params) != ge::SUCCESS) {
+    GELOGE(ge::FAILED, "Parser params after graph failed.");
+    return ge::FAILED;
+  }
+
+  if (acl_graph_parse_util.SetOutputNodeInfo(graph, parser_params) != ge::SUCCESS) {
+    GELOGE(ge::FAILED, "Set graph %s default output node failed.", graph.GetName().c_str());
     return ge::FAILED;
   }
-    GELOGI("AclgrphParse graph %s success.", graph.GetName().c_str());
-#endif
-    return ge::SUCCESS;
+  GELOGI("AclgrphParse graph %s success.", graph.GetName().c_str());
+  return ge::SUCCESS;
 }
 } // namespace ge
 
@@ -159,7 +146,6 @@ Status OnnxModelParser::ParseInput(ge::onnx::GraphProto &onnx_graph,
     GELOGE(FAILED, "Onnx graph has zero input");
     return FAILED;
   }
-
   // get input value info map
   std::map<std::string, ge::onnx::TensorProto> input_name_tensor;
   for (int i = 0; i < onnx_graph.input_size(); i++) {
@@ -173,7 +159,6 @@ Status OnnxModelParser::ParseInput(ge::onnx::GraphProto &onnx_graph,
       initializer_name_tensor.erase(initializer_iter);
       continue;
     }
-
     ge::onnx::TensorProto tensor_tmp;
     if (value_info.has_type()) {
       const ge::onnx::TypeProto type = value_info.type();
@@ -194,7 +179,6 @@ Status OnnxModelParser::ParseInput(ge::onnx::GraphProto &onnx_graph,
     }
     input_name_tensor[value_info.name()] = tensor_tmp;
   }
-
   // Construct node for input
   int64_t index = 0;
   for (auto it : input_name_tensor) {
@@ -511,11 +495,10 @@ Status OnnxModelParser::GetGraphInputs(std::vector<ge::Operator> &input_ops) {
     input_ops.emplace_back(in_op->second);
     GELOGI("Model assigned input node name: %s", in_op->second.GetName().c_str());
   }
-
   return SUCCESS;
 }
 
-Status OnnxModelParser::GetModelFromFile(const char *file, ge::onnx::ModelProto &onnx_model) {
+Status OnnxModelParser::GetModelFromfile(const char *file, ge::onnx::ModelProto &onnx_model) {
   GE_CHECK_NOTNULL(file);
   GELOGI("File path is %s.", file);
 
@@ -529,20 +512,18 @@ Status OnnxModelParser::GetModelFromFile(const char *file, ge::onnx::ModelProto
   return SUCCESS;
 }
 
-#ifndef ONLY_COMPILE_OPEN_SRC
 Status OnnxModelParser::GetModelFromMemory(const char *data, uint32_t size, ge::onnx::ModelProto &onnx_model) {
   GE_CHECK_NOTNULL(data);
 
-  // 1. Get graph from onnx model file.
-  if (!ge::parser::ReadProtoFromArray(data, size, &onnx_model)) {
+  // 1. Get graph from memory.
+  if (!ge::parser::ReadProtoFromArray(data, static_cast<int>(size), &onnx_model)) {
     ErrorManager::GetInstance().ATCReportErrMessage(
-        "E19021", {"reason"}, {"Read onnx model from memory failed."});
-    GELOGE(PARAM_INVALID, "Read onnx model from memory failed.");
+        "E19021", {"reason"}, {"Read onnx model file failed."});
+    GELOGE(PARAM_INVALID, "Read onnx model file failed.");
     return FAILED;
   }
   return SUCCESS;
 }
-#endif
 
 Status OnnxModelParser::ModelParseToGraph(const ge::onnx::ModelProto &onnx_model, ge::Graph &graph) {
   if (!onnx_model.has_graph()) {
@@ -551,13 +532,11 @@ Status OnnxModelParser::ModelParseToGraph(const ge::onnx::ModelProto &onnx_model
     return FAILED;
   }
   ge::onnx::GraphProto onnx_graph = onnx_model.graph();
-
   auto opset_import = onnx_model.opset_import();
   for (auto it : opset_import) {
     domain_verseion_[it.domain()] = it.version();
     GELOGI("Domain: %s, Version: %ld ", it.domain().c_str(), it.version());
   }
-
   // 2. Get all inializer.
   std::map<std::string, ge::onnx::TensorProto> initializer_name_tensor;
   for (int i = 0; i < onnx_graph.initializer_size(); i++) {
@@ -567,7 +546,6 @@ Status OnnxModelParser::ModelParseToGraph(const ge::onnx::ModelProto &onnx_model
       GELOGI("Initializer name: %s .", initializer_tensor.name().c_str());
     }
   }
-
   // 3. Parse Input from graph.
   GELOGI("The size of initializer_name_tensor is %zu ", initializer_name_tensor.size());
   Status ret = ParseInput(onnx_graph, initializer_name_tensor);
@@ -576,21 +554,18 @@ Status OnnxModelParser::ModelParseToGraph(const ge::onnx::ModelProto &onnx_model
     return ret;
   }
   GELOGI("The size of initializer_name_tensor is %zu after ParseInput", initializer_name_tensor.size());
-
   // 4. Parse Constant from graph.
   ret = ParseInitializer(onnx_graph, initializer_name_tensor);
   if (ret != SUCCESS) {
     GELOGE(ret, "Parse initializer for onnx failed.");
     return ret;
   }
-
   // 5. Update node name for node do not has name.
   ret = UpdateAllNodeName(onnx_graph);
   if (ret != SUCCESS) {
     GELOGE(ret, "Update all node name for onnx failed.");
     return ret;
   }
-
   // 6 Precheck.
   ret = Prechecker(onnx_graph);
   bool is_precheck_failed = (ret != SUCCESS) || (ge::PreChecker::Instance().HasError());
@@ -624,7 +599,6 @@ Status OnnxModelParser::ModelParseToGraph(const ge::onnx::ModelProto &onnx_model
 
   // 9. Construct graph.
   std::vector<ge::Operator> input_ops;
-
   ret = GetGraphInputs(input_ops);
   if (ret != SUCCESS) {
     GELOGE(ret, "Get graph inputs failed.");
@@ -642,35 +616,33 @@ Status OnnxModelParser::ModelParseToGraph(const ge::onnx::ModelProto &onnx_model
 
 Status OnnxModelParser::Parse(const char *file, ge::Graph &graph) {
   ge::onnx::ModelProto onnx_model;
-  Status ret = GetModelFromFile(file, onnx_model);
+  Status ret = GetModelFromfile(file, onnx_model);
   if (ret != SUCCESS) {
-    GELOGE(FAILED, "get model from file failed.");
-    return FAILED;
+    GELOGE(ret, "Get model from file failed.");
+    return ret;
   }
   ret = ModelParseToGraph(onnx_model, graph);
   if (ret != SUCCESS) {
-    GELOGE(FAILED, "parse model failed.");
-    return FAILED;
+    GELOGE(ret, "Parse model failed.");
+    return ret;
   }
   return SUCCESS;
 }
 
-#ifndef ONLY_COMPILE_OPEN_SRC
 Status OnnxModelParser::ParseFromMemory(const char *data, uint32_t size, ge::Graph &graph) {
   ge::onnx::ModelProto onnx_model;
   Status ret = GetModelFromMemory(data, size, onnx_model);
   if (ret != SUCCESS) {
-    GELOGE(FAILED, "get model from file failed.");
-    return FAILED;
+    GELOGE(ret, "Get model from memory failed.");
+    return ret;
   }
   ret = ModelParseToGraph(onnx_model, graph);
   if (ret != SUCCESS) {
-    GELOGE(FAILED, "parse model failed.");
-    return FAILED;
+    GELOGE(ret, "Parse model failed.");
+    return ret;
   }
   return SUCCESS;
 }
-#endif
 
 Status OnnxModelParser::ToJson(const char *model_file, const char *json_file) {
   if (model_file == nullptr) {

parser/onnx/onnx_parser.h

@@ -38,11 +38,11 @@ class OnnxModelParser : public domi::ModelParser {
 
   ge::DataType ConvertToGeDataType(const uint32_t type) override;
 
-  Status ParseFromMemory(const char *data, uint32_t size, ge::ComputeGraphPtr &graph) override { return domi::SUCCESS; }
-
-#ifndef ONLY_COMPILE_OPEN_SRC
   Status ParseFromMemory(const char *data, uint32_t size, ge::Graph &graph) override;
-#endif
+
+  Status ParseFromMemory(const char *data, uint32_t size, ge::ComputeGraphPtr &graph) override {
+    return domi::SUCCESS;
+  }
 
   Status ParseProto(const google::protobuf::Message *proto, ge::ComputeGraphPtr &graph) override {
     return domi::SUCCESS;
@@ -81,12 +81,10 @@ class OnnxModelParser : public domi::ModelParser {
   Status GetGraphInputs(std::vector<ge::Operator> &input_ops);
 
   Status Prechecker(ge::onnx::GraphProto &onnx_graph);
-  
-  Status GetModelFromFile(const char *file, ge::onnx::ModelProto &onnx_model);
 
-#ifndef ONLY_COMPILE_OPEN_SRC
+  Status GetModelFromfile(const char *file, ge::onnx::ModelProto &onnx_model);
+
   Status GetModelFromMemory(const char *data, uint32_t size, ge::onnx::ModelProto &onnx_model);
-#endif
 
   Status ModelParseToGraph(const ge::onnx::ModelProto &onnx_model, ge::Graph &graph);
 

parser/proto/ge_ir.proto

@@ -30,7 +30,6 @@ enum DataType
     DT_RESOURCE  = 23;         // resource type
     DT_STRING_REF = 24;        // string_ref type
     DT_DUAL      = 25;              /**< dual output type */
-    DT_VARIANT = 26;           // variant type
 }
 
 message AttrDef

parser/tensorflow/proto/ge_ir.proto

@@ -30,7 +30,6 @@ enum DataType
     DT_RESOURCE  = 23;         // resource type
     DT_STRING_REF = 24;        // string_ref type
     DT_DUAL      = 25;              /**< dual output type */
-    DT_VARIANT = 26;           // variant type
 }
 
 message AttrDef

parser/tensorflow/tensorflow_parser.h

@@ -86,26 +86,22 @@ class TensorFlowModelParser : public domi::ModelParser {
    * @param [in|out] graph save model information after parsing
    * @return SUCCESS parse successfully
    * @return FAILED parse failed
-
    */
   Status Parse(const char *file, ge::Graph &graph) override;
 
   /**
    * @ingroup domi_omg
-   * @brief Parse the relevant data from memory and save it to graph
-   * @param [in] memory buffer of model file
-   * @param [in] buffer size
-   * @param [in|out] graph graph for saving model information
+   * @brief Parse the relevant data from the memory and save it to graph
+   * @param [in] file Path of the model file
+   * @param [in|out] graph save model information after parsing
    * @return SUCCESS parse successfully
    * @return FAILED parse failed
    */
   Status ParseFromMemory(const char *data, uint32_t size, ge::ComputeGraphPtr &graph) override;
 
-#ifndef ONLY_COMPILE_OPEN_SRC
   Status ParseFromMemory(const char *data, uint32_t size, ge::Graph &graph) override {
     return domi::SUCCESS;
   }
-#endif
 
   /**
    * @ingroup domi_omg