display model info

ge/common/helper/model_helper.cc

@@ -87,7 +87,9 @@ 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());
@@ -105,6 +107,9 @@ 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,
@@ -119,6 +124,9 @@ 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,
@@ -135,6 +143,9 @@ 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,
@@ -167,6 +178,10 @@ 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,6 +279,8 @@ 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) {
@@ -489,6 +491,64 @@ bool GeGenerator::Impl::SetOppVersionInfo(AttrHolder &obj) {
   return true;
 }
 
+bool GeGenerator::Impl::SetOmSystemInfo(AttrHolder &obj) {
+  std::string soc_version;
+  Status ret = ge::GetContext().GetOption(ge::SOC_VERSION, soc_version);
+  GELOGI("SetOmSystemInfo soc_version: %s", soc_version.c_str());S
+  if (!ge::AttrUtils::SetStr(obj, "soc_version", soc_version)) {
+    GELOGW("SetStr of soc_version failed.");
+    return false;
+  }
+  std::string framework_type;
+  Status ret = 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) {
+  //
+  size_t memory_size;
+  (void)ge::AttrUtils::GetInt(obj, ATTR_MODEL_MEMORY_SIZE, memory_size);
+  size_t weight_size;
+  (void)ge::AttrUtils::GetInt(obj, ATTR_MODEL_WEIGHT_SIZE, weight_size);
+  size_t stream_num;
+  (void)ge::AttrUtils::GetInt(obj, ATTR_MODEL_STREAM_NUM, stream_num);
+  size_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;
+
+  //
+  size_t modeldef_size;
+  (void)ge::AttrUtils::GetInt(obj, "modeldef_size", modeldef_size);
+  size_t weight_data_size;
+  (void)ge::AttrUtils::GetInt(obj, "weight_data_size", weight_data_size);
+  size_t tbe_kernels_size;
+  (void)ge::AttrUtils::GetInt(obj, "tbe_kernels_size", tbe_kernels_size);
+  size_t cust_aicpu_kernel_store_size;
+  (void)ge::AttrUtils::GetInt(obj, "cust_aicpu_kernel_store_size", cust_aicpu_kernel_store_size);
+  size_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;
@@ -761,6 +821,9 @@ Status GeGenerator::Impl::SaveRootModel(const string &file_name_prefix, GeRootMo
   if (!SetOppVersionInfo(*(model_root.get()))) {
     GELOGW("SetPackageVersionInfo of ops failed!");
   }
+  if (!SetOmystemInfo(*(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);
@@ -768,6 +831,7 @@ 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;
 }