dump add origin shape

ge/common/helper/model_helper.cc

@@ -87,9 +87,7 @@ Status ModelHelper::SaveModelDef(std::shared_ptr<OmFileSaveHelper> &om_file_save
   model_tmp->SetGraph(ge_model->GetGraph());
   model_tmp->SetVersion(ge_model->GetVersion());
   model_tmp->SetAttr(ge_model->MutableAttrMap());
-  GE_CHK_BOOL_EXEC(ge::AttrUtils::SetInt(ge_model, "modeldef_size", model_buffer.GetSize()),
-                   GELOGE(FAILED, "SetInt of modeldef_size failed.");
-                   return FAILED);
+
 
   (void)model_tmp->Save(model_buffer);
   GELOGD("MODEL_DEF size is %zu", model_buffer.GetSize());
@@ -107,9 +105,6 @@ Status ModelHelper::SaveModelWeights(std::shared_ptr<OmFileSaveHelper> &om_file_
                                      const GeModelPtr &ge_model, size_t model_index) {
   auto ge_model_weight = ge_model->GetWeight();
   GELOGD("WEIGHTS_DATA size is %zu, %p", ge_model_weight.GetSize(), ge_model_weight.GetData());
-  GE_CHK_BOOL_EXEC(ge::AttrUtils::SetInt(ge_model, "weight_data_size", ge_model_weight.GetSize()),
-                   GELOGE(FAILED, "SetInt of weight_data_size failed.");
-                   return FAILED);
   // weight is not necessary
   if (ge_model_weight.GetSize() > 0) {
     GE_CHK_STATUS_RET(SaveModelPartition(om_file_save_helper,
@@ -124,9 +119,6 @@ Status ModelHelper::SaveModelTbeKernel(std::shared_ptr<OmFileSaveHelper> &om_fil
                                        const GeModelPtr &ge_model, size_t model_index) {
   TBEKernelStore tbe_kernel_store = ge_model->GetTBEKernelStore();
   GELOGD("TBE_KERNELS size is %zu", tbe_kernel_store.DataSize());
-  GE_CHK_BOOL_EXEC(ge::AttrUtils::SetInt(ge_model, "tbe_kernels_size", tbe_kernel_store.DataSize()),
-                   GELOGE(FAILED, "SetInt of tbe_kernels_size failed.");
-                   return FAILED);
   if (tbe_kernel_store.DataSize() > 0) {
     GE_CHK_STATUS_RET(
         SaveModelPartition(om_file_save_helper, ModelPartitionType::TBE_KERNELS,
@@ -143,9 +135,6 @@ Status ModelHelper::SaveModelCustAICPU(std::shared_ptr<OmFileSaveHelper> &om_fil
                                        const GeModelPtr &ge_model, size_t model_index) {
   CustAICPUKernelStore cust_aicpu_kernel_store = ge_model->GetCustAICPUKernelStore();
   GELOGD("cust aicpu kernels size is %zu", cust_aicpu_kernel_store.DataSize());
-  GE_CHK_BOOL_EXEC(ge::AttrUtils::SetInt(ge_model, "cust_aicpu_kernel_store_size", cust_aicpu_kernel_store.DataSize()),
-                   GELOGE(FAILED, "SetInt of tbe_kernels_size failed.");
-                   return FAILED);
   if (cust_aicpu_kernel_store.DataSize() > 0) {
     GE_CHK_STATUS_RET(SaveModelPartition(om_file_save_helper,
                                          ModelPartitionType::CUST_AICPU_KERNELS,
@@ -178,10 +167,6 @@ Status ModelHelper::SaveModelTaskDef(std::shared_ptr<OmFileSaveHelper> &om_file_
   GELOGD("TASK_INFO op_size:%d, stream_num:%u", model_task_def->op().size(), model_task_def->stream_num());
   GELOGD("TASK_INFO size is %zu", partition_task_size);
 
-  GE_CHK_BOOL_EXEC(ge::AttrUtils::SetInt(ge_model, "task_info_size", partition_task_size),
-                   GELOGE(FAILED, "SetInt of task_info_size failed.");
-                   return FAILED);
-
   if (SaveModelPartition(om_file_save_helper, ModelPartitionType::TASK_INFO, task_buffer.GetData(),
                          partition_task_size, model_index) != SUCCESS) {
     GELOGE(PARAM_INVALID, "Add model task def partition failed");

ge/generator/ge_generator.cc

@@ -279,8 +279,6 @@ class GeGenerator::Impl {
   bool GetVersionFromPath(const std::string &file_path, std::string &version);
   bool SetAtcVersionInfo(AttrHolder &obj);
   bool SetOppVersionInfo(AttrHolder &obj);
-  bool SetOmSystemInfo(AttrHolder &obj);
-  void DisplayModelInfo(AttrHolder &obj);
 };
 
 Status GeGenerator::Initialize(const map<string, string> &options) {
@@ -491,70 +489,6 @@ bool GeGenerator::Impl::SetOppVersionInfo(AttrHolder &obj) {
   return true;
 }
 
-bool GeGenerator::Impl::SetOmSystemInfo(AttrHolder &obj) {
-  std::string soc_version;
-  (void)ge::GetContext().GetOption(ge::SOC_VERSION, soc_version);
-  GELOGI("SetOmSystemInfo soc_version: %s", soc_version.c_str());
-  if (!ge::AttrUtils::SetStr(obj, "soc_version", soc_version)) {
-    GELOGW("SetStr of soc_version failed.");
-    return false;
-  }
-  std::string framework_type;
-  (void)ge::GetContext().GetOption(ge::FRAMEWORK_TYPE, framework_type);
-  GELOGI("SetOmSystemInfo framework_type: %s", framework_type.c_str());
-  if (!ge::AttrUtils::SetStr(obj, "framework_type", framework_type)) {
-    GELOGW("SetStr of framework_type failed.");
-    return false;
-  }
-  return true;
-}
-
-void GeGenerator::Impl::DisplayModelInfo(AttrHolder &obj) {
-  std::string display_model;
-  (void)ge::GetContext().GetOption(ge::DISPLAY_MODEL_INFO, display_model);
-  if (display_model != "1") {
-    GELOGD("display_model not 1");
-    return;
-  }
-  //
-  int64_t memory_size;
-  (void)ge::AttrUtils::GetInt(obj, ATTR_MODEL_MEMORY_SIZE, memory_size);
-  int64_t weight_size;
-  (void)ge::AttrUtils::GetInt(obj, ATTR_MODEL_WEIGHT_SIZE, weight_size);
-  int64_t stream_num;
-  (void)ge::AttrUtils::GetInt(obj, ATTR_MODEL_STREAM_NUM, stream_num);
-  int64_t event_num;
-  (void)ge::AttrUtils::GetInt(obj, ATTR_MODEL_EVENT_NUM, event_num);
-  std::cout << ATTR_MODEL_MEMORY_SIZE << "[" << memory_size << "], " << ATTR_MODEL_WEIGHT_SIZE << "[" << weight_size <<
-      "], " << ATTR_MODEL_STREAM_NUM << "[" << stream_num << "], " << ATTR_MODEL_EVENT_NUM << "[" << event_num << "]."
-            << std::endl;
-
-  //
-  std::string atc_version;
-  (void)ge::AttrUtils::GetStr(obj, ATTR_MODEL_ATC_VERSION, atc_version);
-  std::string soc_version;
-  (void)ge::AttrUtils::GetStr(obj, "soc_version", soc_version);
-  std::string framework_type;
-  (void)ge::AttrUtils::GetStr(obj, "framework_type", framework_type);
-  std::cout << ATTR_MODEL_ATC_VERSION << "[" << atc_version << "], " << "soc_version" << "[" << soc_version <<
-      "], " << "framework_type" << "[" << framework_type << "]." << std::endl;
-
-  //
-  int64_t modeldef_size;
-  (void)ge::AttrUtils::GetInt(obj, "modeldef_size", modeldef_size);
-  int64_t weight_data_size;
-  (void)ge::AttrUtils::GetInt(obj, "weight_data_size", weight_data_size);
-  int64_t tbe_kernels_size;
-  (void)ge::AttrUtils::GetInt(obj, "tbe_kernels_size", tbe_kernels_size);
-  int64_t cust_aicpu_kernel_store_size;
-  (void)ge::AttrUtils::GetInt(obj, "cust_aicpu_kernel_store_size", cust_aicpu_kernel_store_size);
-  int64_t task_info_size;
-  (void)ge::AttrUtils::GetInt(obj, "task_info_size", task_info_size);
-  std::cout << "modeldef_size" << "[" << modeldef_size << "], " << "weight_data_size" << "[" << weight_data_size <<
-      "], " << "tbe_kernels_size" << "[" << tbe_kernels_size << "], " << "cust_aicpu_kernel_store_size" << "[" <<
-      cust_aicpu_kernel_store_size << "], " << "task_info_size" << "[" << task_info_size << "]." << std::endl;
-}
-
 Status GeGenerator::GenerateModel(const Graph &graph, const string &file_name_prefix, const vector<GeTensor> &inputs,
                                   ModelBufferData &model, bool is_offline) {
   rtContext_t ctx = nullptr;
@@ -827,9 +761,6 @@ Status GeGenerator::Impl::SaveRootModel(const string &file_name_prefix, GeRootMo
   if (!SetOppVersionInfo(*(model_root.get()))) {
     GELOGW("SetPackageVersionInfo of ops failed!");
   }
-  if (!SetOmSystemInfo(*(model_root.get()))) {
-    GELOGW("SetOmsystemInfo failed!");
-  }
   ModelHelper model_helper;
   model_helper.SetSaveMode(is_offline_);
   ret = model_helper.SaveToOmRootModel(ge_root_model, save_param_, file_name_prefix, model_buff, is_unknown_shape);
@@ -837,7 +768,6 @@ Status GeGenerator::Impl::SaveRootModel(const string &file_name_prefix, GeRootMo
     GELOGE(ret, "Save to om model failed");
     return ret;
   }
-  DisplayModelInfo(*(model_root.get()));
   return SUCCESS;
 }
 

ge/offline/main.cc

@@ -202,8 +202,6 @@ DEFINE_string(mdl_bank_path, "", "Optional; model bank path");
 
 DEFINE_string(op_bank_path, "", "Optional; op bank path");
 
-DEFINE_string(display_model_info, "0", "Optional; display model info");
-
 class GFlagUtils {
  public:
   /**
@@ -309,8 +307,7 @@ class GFlagUtils {
         "  --op_compiler_cache_dir    Set the save path of operator compilation cache files.\n"
         "Default value: $HOME/atc_data/kernel_cache\n"
         "  --op_compiler_cache_mode   Set the operator compilation cache mode."
-        "Options are disable(default), enable and force(force to refresh the cache)"
-        "  --display_model_info     enable for display model inf; 0(default): close display, 1: open display");
+        "Options are disable(default), enable and force(force to refresh the cache)");
 
     gflags::ParseCommandLineNonHelpFlags(&argc, &argv, true);
     // Using gflags to analyze input parameters
@@ -892,16 +889,6 @@ static Status ConvertModelToJson(int fwk_type, const string &model_file, const s
   return ret;
 }
 
-static Status DisplayModelInfo(int fwk_type, const string &model_file) {
-  Status ret = ge::SUCCESS;
-  if (fwk_type == -1) {
-    ret = ge::DisplayModelInfo(model_file.c_str());
-    return ret;
-  }
-
-  return ret;
-}
-
 domi::Status GenerateModel(std::map<string, string> &options, std::string output) {
   ge::GeGenerator ge_generator;
   ge::Status geRet = ge::SUCCESS;
@@ -1175,8 +1162,6 @@ domi::Status GenerateOmModel() {
   options.insert(std::pair<string, string>(string(ge::MDL_BANK_PATH_FLAG), FLAGS_mdl_bank_path));
 
   options.insert(std::pair<string, string>(string(ge::OP_BANK_PATH_FLAG), FLAGS_op_bank_path));
-
-  options.insert(std::pair<string, string>(string(ge::DISPLAY_MODEL_INFO), FLAGS_display_model_info));
   // set enable scope fusion passes
   SetEnableScopeFusionPasses(FLAGS_enable_scope_fusion_passes);
   // print atc option map
@@ -1202,22 +1187,6 @@ domi::Status ConvertModelToJson() {
   return domi::SUCCESS;
 }
 
-domi::Status DisplayModelInfo() {
-  // No model path passed in
-  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(FLAGS_om == "",
-      ErrorManager::GetInstance().ATCReportErrMessage("E10004", {"parameter"}, {"om"});
-      return ge::FAILED,
-      "Input parameter[--om]'s value is empty!!");
-
-  // Check if the model path is valid
-  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(
-      FLAGS_om != "" && !ge::CheckInputPathValid(FLAGS_om, "--om"),
-      return ge::FAILED,
-      "model file path is invalid: %s.", FLAGS_om.c_str());
-
-  return DisplayModelInfo(FLAGS_framework, FLAGS_om);
-}
-
 bool CheckRet(domi::Status ret) {
   if (ret != domi::SUCCESS) {
     if (FLAGS_mode == ONLY_PRE_CHECK) {
@@ -1361,9 +1330,6 @@ int main(int argc, char* argv[]) {
     } else if (FLAGS_mode == ge::RunMode::PBTXT_TO_JSON) {
       GE_CHK_BOOL_EXEC(ConvertPbtxtToJson() == domi::SUCCESS, ret = domi::FAILED;
                        break, "ATC convert pbtxt to json execute failed!!");
-    } else if (FLAGS_mode == ge::RunMode::DISPLAY_OM_INFO) {
-      GE_CHK_BOOL_EXEC(DisplayModelInfo() == domi::SUCCESS, ret = domi::FAILED;
-        break, "ATC ConvertJson execute failed!!");
     } else {
       ErrorManager::GetInstance().ATCReportErrMessage(
           "E10001", {"parameter", "value", "reason"}, {"--mode", std::to_string(FLAGS_mode), kModeSupport});

ge/session/omg.cc

@@ -869,116 +869,6 @@ void GetGroupName(ge::proto::ModelDef &model_def) {
       });
 }
 
-FMK_FUNC_HOST_VISIBILITY void PrintModelInfo(ge::proto::ModelDef *model_def) {
-  auto model_attr_map = model_def->mutable_attr();
-  auto iter = model_attr_map->find(ATTR_MODEL_MEMORY_SIZE);
-  auto memory_size = (iter != model_attr_map->end()) ? iter->second.i() : -1;
-  iter = model_attr_map->find(ATTR_MODEL_WEIGHT_SIZE);
-  auto weight_size = (iter != model_attr_map->end()) ? iter->second.i() : -1;
-  iter = model_attr_map->find(ATTR_MODEL_STREAM_NUM);
-  auto stream_num = (iter != model_attr_map->end()) ? iter->second.i() : -1;
-  iter = model_attr_map->find(ATTR_MODEL_EVENT_NUM);
-  auto event_num = (iter != model_attr_map->end()) ? iter->second.i() : -1;
-  std::cout << ATTR_MODEL_MEMORY_SIZE << "[" << memory_size << "], " << ATTR_MODEL_WEIGHT_SIZE << "[" << weight_size <<
-      "], " << ATTR_MODEL_STREAM_NUM << "[" << stream_num << "], " << ATTR_MODEL_EVENT_NUM << "[" << event_num << "]."
-            << std::endl;
-
-  iter = model_attr_map->find(ATTR_MODEL_ATC_VERSION);
-  auto atc_version = (iter != model_attr_map->end()) ? iter->second.s() : "";
-  iter = model_attr_map->find("soc_version");
-  auto soc_version = (iter != model_attr_map->end()) ? iter->second.s() : "";
-  iter = model_attr_map->find("framework_type");
-  auto framework_type = (iter != model_attr_map->end()) ? iter->second.s() : "";
-  std::cout << ATTR_MODEL_ATC_VERSION << "[" << atc_version << "], " << "soc_version" << "[" << soc_version <<
-            "], " << "framework_type" << "[" << framework_type << "]." << std::endl;
-
-  iter = model_attr_map->find("modeldef_size");
-  auto modeldef_size = (iter != model_attr_map->end()) ? iter->second.i() : -1;
-  iter = model_attr_map->find("weight_data_size");
-  auto weight_data_size = (iter != model_attr_map->end()) ? iter->second.i() : -1;
-  iter = model_attr_map->find("tbe_kernels_size");
-  auto tbe_kernels_size = (iter != model_attr_map->end()) ? iter->second.i() : -1;
-  iter = model_attr_map->find("cust_aicpu_kernel_store_size");
-  auto cust_aicpu_kernel_store_size = (iter != model_attr_map->end()) ? iter->second.i() : -1;
-  iter = model_attr_map->find("task_info_size");
-  auto task_info_size = (iter != model_attr_map->end()) ? iter->second.i() : -1;
-
-  std::cout << "modeldef_size" << "[" << modeldef_size << "], " << "weight_data_size" << "[" << weight_data_size <<
-            "], " << "tbe_kernels_size" << "[" << tbe_kernels_size << "], " << "cust_aicpu_kernel_store_size" << "[" <<
-            cust_aicpu_kernel_store_size << "], " << "task_info_size" << "[" << task_info_size << "]." << std::endl;
-}
-
-FMK_FUNC_HOST_VISIBILITY Status DisplayModelInfo(const char *model_file) {
-  ge::proto::ModelDef model_def;
-  ge::ModelData model;
-  Status ret = GetModeldefFormFile(model_file, model, &model_def);
-  if (ret == SUCCESS) {
-    PrintModelInfo(&model_def);
-  }
-  if (model.model_data != nullptr) {
-    delete[] reinterpret_cast<char *>(model.model_data);
-    model.model_data = nullptr;
-  }
-  return ret;
-}
-
-FMK_FUNC_HOST_VISIBILITY Status GetModeldefFormFile(const char *model_file, ge::ModelData &model,
-                                                    ge::proto::ModelDef *model_def) {
-  GE_CHECK_NOTNULL(model_file);
-
-  // Mode 2 does not need to verify the priority, and a default value of 0 is passed
-  int32_t priority = 0;
-
-  // Load model from file
-  Status ret = ModelParserBase::LoadFromFile(model_file, "", priority, model);
-  if (ret != SUCCESS) {
-    GELOGE(ret, "LoadFromFile failed.");
-    return ret;
-  }
-
-  uint8_t *model_data = nullptr;
-  uint32_t model_len = 0;
-  try {
-    // Parse the contents of the file to get the modeldef object
-    ret = ModelParserBase::ParseModelContent(model, model_data, model_len);
-    if (ret == SUCCESS) {
-      OmFileLoadHelper omFileLoadHelper;
-      ge::graphStatus status = omFileLoadHelper.Init(model_data, model_len);
-      if (status != ge::GRAPH_SUCCESS) {
-        GELOGE(ge::FAILED, "Om file init failed.");
-        if (model.model_data != nullptr) {
-          delete[] reinterpret_cast<char *>(model.model_data);
-          model.model_data = nullptr;
-        }
-        return status;
-      }
-
-      ModelPartition ir_part;
-      status = omFileLoadHelper.GetModelPartition(MODEL_DEF, ir_part);
-      if (status != ge::GRAPH_SUCCESS) {
-        GELOGE(ge::FAILED, "Get model part failed.");
-        if (model.model_data != nullptr) {
-          delete[] reinterpret_cast<char *>(model.model_data);
-          model.model_data = nullptr;
-        }
-        return status;
-      }
-
-      // De serialization
-      if (ReadProtoFromArray(ir_part.data, ir_part.size, model_def)) {
-        return SUCCESS;
-      }
-      return FAILED;
-    } else {
-      GELOGE(PARAM_INVALID, "ParseModelContent failed because of invalid om file. Please check --om param.");
-      return FAILED;
-    }
-  } catch (const std::exception &e) {
-    GELOGE(FAILED, "get from file failed, exception message : %s.", e.what());
-    return FAILED;
-  }
-}
-
 FMK_FUNC_HOST_VISIBILITY Status ConvertOmModelToJson(const char *model_file, const char *json_file) {
   GE_CHECK_NOTNULL(model_file);
   GE_CHECK_NOTNULL(json_file);

inc/external/ge/ge_api_types.h

@@ -294,9 +294,6 @@ const std::string MDL_BANK_PATH_FLAG = "ge.mdl_bank_path";
 // Configure op bank path
 const std::string OP_BANK_PATH_FLAG = "ge.op_bank_path";
 
-// Configure display_model_info flag
-const std::string DISPLAY_MODEL_INFO = "ge.display_model_info";
-
 // Graph run mode
 enum GraphRunMode { PREDICTION = 0, TRAIN };
 

inc/framework/omg/omg.h

@@ -21,7 +21,6 @@
 #include <string>
 #include <unordered_map>
 #include <vector>
-#include "framework/common/ge_types.h"
 #include "framework/omg/omg_inner_types.h"
 #include "framework/omg/parser/parser_inner_ctx.h"
 #include "proto/ge_ir.pb.h"
@@ -104,12 +103,6 @@ void GetOutputNodesNameAndIndex(std::vector<std::pair<ge::NodePtr, int32_t>> &ou
 void UpdateOmgCtxWithParserCtx();
 
 void UpdateParserCtxWithOmgCtx();
-
-Status GetModeldefFormFile(const char *model_file, ge::ModelData &model, ge::proto::ModelDef *model_def);
-
-Status DisplayModelInfo(const char *model_file);
-
-void PrintModelInfo(ge::proto::ModelDef *model_def);
 }  // namespace ge
 
 namespace domi {

inc/framework/omg/omg_inner_types.h

@@ -43,11 +43,10 @@ namespace ge {
  * @brief run model
  */
 enum RunMode {
-  GEN_OM_MODEL = 0,   // generate offline model file
-  MODEL_TO_JSON = 1,  // convert to JSON file
-  ONLY_PRE_CHECK = 3, // only for pre-check
-  PBTXT_TO_JSON = 5,  // pbtxt to json
-  DISPLAY_OM_INFO = 6 // display model info
+  GEN_OM_MODEL = 0,    // generate offline model file
+  MODEL_TO_JSON = 1,   // convert to JSON file
+  ONLY_PRE_CHECK = 3,  // only for pre-check
+  PBTXT_TO_JSON = 5    // pbtxt to json
 };
 
 ///