ge log optimize

ge/client/ge_api.cc

@@ -357,6 +357,7 @@ Session::~Session() {
   } catch (google::protobuf::FatalException &e) {
     GELOGE(GE_CLI_SESS_DESTROY_FAILED, "[Destruct][Session]Failed "
            "because get fatalException.");
+    REPORT_CALL_ERROR("E19999", "Destruct session failed, get fatal exception");
   }
 
   // check return status, return, update session id if success
@@ -486,9 +487,11 @@ Status Session::RemoveGraph(uint32_t graph_id) {
   std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
   if (!instance_ptr || !instance_ptr->InitFlag()) {
     GELOGE(GE_CLI_GE_NOT_INITIALIZED,
-           "[Remove][Graph]Failed, GELib instance is nullptr or is not InitFlag ");
+           "[Remove][Graph]Failed, GELib instance is nullptr or is not InitFlag,
+           session_id %lu, graph_id %lu", sessionId_, graph_id);
     REPORT_INNER_ERROR("E19999",
-                       "RemoveGraph Failed, GELib instance is nullptr or is not InitFlag.");
+                       "RemoveGraph Failed, GELib instance is nullptr or is not InitFlag,
+                       session_id %lu, graph_id %lu", sessionId_, graph_id);
     return FAILED;
   }
 
@@ -566,9 +569,11 @@ Status Session::RunGraph(uint32_t graph_id, const std::vector<Tensor> &inputs, s
   std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
     GELOGE(GE_CLI_GE_NOT_INITIALIZED,
-           "[Run][Graph]Failed, GELib instance is nullptr or is not InitFlag.");
+           "[Run][Graph]Failed, GELib instance is nullptr or is not InitFlag,
+           session_id %lu, graph_id %lu", sessionId_, graph_id);
     REPORT_INNER_ERROR("E19999",
-                       "RunGraph Failed, GELib instance is nullptr or is not InitFlag.");
+                       "RunGraph Failed, GELib instance is nullptr or is not InitFlag,
+                       session_id %lu, graph_id %lu", sessionId_, graph_id);
     return FAILED;
   }
   GELOGT(TRACE_RUNNING, "Running Graph");
@@ -615,9 +620,11 @@ Status Session::BuildGraph(uint32_t graph_id, const std::vector<InputTensorInfo>
   std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
     GELOGE(GE_CLI_GE_NOT_INITIALIZED,
-           "[Build][Graph]Failed, the GELib instance is nullptr or is not InitFlag.");
+           "[Build][Graph]Failed, the GELib instance is nullptr or is not InitFlag,
+           session_id %lu, graph_id %lu", sessionId_, graph_id);
     REPORT_INNER_ERROR("E19999",
-                       "Build graph failed, the GELib instance is nullptr or is not InitFlag.");
+                       "Build graph failed, the GELib instance is nullptr or is not InitFlag,
+                       session_id %lu, graph_id %lu", sessionId_, graph_id);
     return FAILED;
   }
   GELOGT(TRACE_RUNNING, "Building Graph");
@@ -641,9 +648,11 @@ Status Session::RunGraphAsync(uint32_t graph_id, const std::vector<InputTensorIn
   std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
     GELOGE(GE_CLI_GE_NOT_INITIALIZED,
-           "[Run][Graph]RunGraphAsyncFailed, the GELib instance is nullptr or is not InitFlag.");
+           "[Run][Graph]RunGraphAsyncFailed, the GELib instance is nullptr or is not InitFlag,
+           session_id %lu, graph_id %lu", sessionId_, graph_id);
     REPORT_INNER_ERROR("E19999",
-		       "RunGraphAsync Failed, the GELib instance is nullptr or is not InitFlag.");
+		       "RunGraphAsync Failed, the GELib instance is nullptr or is not InitFlag,
+                       session_id %lu, graph_id %lu", sessionId_, graph_id);
     return FAILED;
   }
   GELOGT(TRACE_RUNNING, "Run Graph Asynchronously");

ge/common/dump/dump_op.cc

@@ -239,9 +239,8 @@ Status DumpOp::LaunchDumpOp() {
   int32_t device_id = 0;
   rtError_t rt_ret = rtGetDevice(&device_id);
   if (rt_ret != RT_ERROR_NONE) {
-    GELOGE(rt_ret, "[Call][rtGetDevice]Failed, ret 0x%X, device_id %d.", rt_ret, device_id);
-    REPORT_CALL_ERROR("E19999", "[Call][rtGetDevice]Failed, ret 0x%X, device_id %d.",
-                      rt_ret, device_id);
+    GELOGE(rt_ret, "[Call][rtGetDevice]Failed, ret 0x%X", rt_ret);
+    REPORT_CALL_ERROR("E19999", "[Call][rtGetDevice]Failed, ret 0x%X", rt_ret);
     return RT_ERROR_TO_GE_STATUS(rt_ret);
   }
   if (device_id < 0) {

ge/common/dump/opdebug_register.cc

@@ -27,9 +27,9 @@ Status OpdebugRegister::RegisterDebugForModel(rtModel_t model_handle, uint32_t o
   GELOGD("Start to register debug for model in overflow");
   auto ret = MallocMemForOpdebug();
   if (ret != SUCCESS) {
-    GELOGE(ret, "[Malloc][MemForOpdebug]Failed in model overflow, ret:0x%X", ret);
-    REPORT_CALL_ERROR("E19999",  "Malloc memory for opdebug failed in model overflow, "
-                      "ret 0x%X", ret);
+    GELOGE(ret, "[Malloc][MemForOpdebug]Failed when debug for model overflow, ret:0x%X", ret);
+    REPORT_CALL_ERROR("E19999",  "Malloc memory for opdebug failed when debug "
+                      "for model in overflow, ret 0x%X", ret);
     return ret;
   }
   uint32_t debug_stream_id = 0;
@@ -76,9 +76,9 @@ Status OpdebugRegister::RegisterDebugForStream(rtStream_t stream, uint32_t op_de
   GELOGD("Start to register debug for stream in stream overflow");
   auto ret = MallocMemForOpdebug();
   if (ret != SUCCESS) {
-    GELOGE(ret, "[Malloc][MemForOpdebug]Failed in stream overflow, ret:0x%X", ret);
-    REPORT_CALL_ERROR("E19999", "Malloc memory for opdebug failed in model overflow, "
-                      "ret:0x%X", ret);
+    GELOGE(ret, "[Malloc][MemForOpdebug]Failed when debug for stream in overflow, ret:0x%X", ret);
+    REPORT_CALL_ERROR("E19999", "Malloc memory for opdebug failed when debug "
+                      "for stream in overflow, ret:0x%X", ret);
     return ret;
   }
 

ge/common/helper/model_helper.cc

@@ -119,8 +119,10 @@ Status ModelHelper::SaveModelDef(std::shared_ptr<OmFileSaveHelper> &om_file_save
   model_tmp->SetAttr(ge_model->MutableAttrMap());
   Status ret = SaveSizeToModelDef(ge_model);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[Save][SizeToModelDef]Failed, error_code %u", ret);
-    REPORT_CALL_ERROR("E19999", "Save SizeToModelDef failed, error_code %u", ret);
+    GELOGE(ret, "[Save][SizeToModelDef]Failed, model %s, error_code %u",
+           ge_model->GetName().c_str(), ret);
+    REPORT_CALL_ERROR("E19999", "Save SizeToModelDef failed, model %s, error_code %u",
+                      ge_model->GetName().c_str(), ret);
     return ret;
   }
 
@@ -129,10 +131,10 @@ Status ModelHelper::SaveModelDef(std::shared_ptr<OmFileSaveHelper> &om_file_save
   if (model_buffer.GetSize() > 0) {
     if (SaveModelPartition(om_file_save_helper, ModelPartitionType::MODEL_DEF, model_buffer.GetData(),
                            model_buffer.GetSize(), model_index) != SUCCESS) {
-      GELOGE(PARAM_INVALID, "[Add][ModelPartition]Failed, model_def size %zu, model_index %zu",
-             model_buffer.GetSize(), model_index);
-      REPORT_CALL_ERROR("E19999", "Add model graph partititon failed, model_def %zu, "
-                        "model_index %zu", model_buffer.GetSize(), model_index);
+      GELOGE(PARAM_INVALID, "[Add][ModelPartition]Failed, model %s, model_def size %zu, model_index %zu",
+             ge_model->GetName().c_str(), model_buffer.GetSize(), model_index);
+      REPORT_CALL_ERROR("E19999", "Add model graph partititon failed, model %s, model_def %zu, "
+                        "model_index %zu", ge_model->GetName().c_str(), model_buffer.GetSize(), model_index);
       return PARAM_INVALID;
     }
   }
@@ -187,24 +189,26 @@ Status ModelHelper::SaveModelTaskDef(std::shared_ptr<OmFileSaveHelper> &om_file_
                                      const GeModelPtr &ge_model, ge::Buffer &task_buffer, size_t model_index) {
   std::shared_ptr<ModelTaskDef> model_task_def = ge_model->GetModelTaskDefPtr();
   if (model_task_def == nullptr) {
-    GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "[Creat][ModelTaskDef]Failed, it is nullptr");
-    REPORT_CALL_ERROR("E19999", "Creat model task def failed, it is nullptr");
+    GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "[Creat][ModelTaskDef]Failed, it is nullptr, "
+           "model %s", ge_model->GetName().c_str());
+    REPORT_CALL_ERROR("E19999", "Creat model task def failed, it is nullptr, model %s",
+                      ge_model->GetName().c_str());
     return ACL_ERROR_GE_MEMORY_ALLOCATION;
   }
   size_t partition_task_size = model_task_def->ByteSizeLong();
   GE_IF_BOOL_EXEC(partition_task_size == 0 || partition_task_size > INT_MAX,
-                  GELOGE(FAILED, "[Check][ModelDefSize]Invalid, size %zu!",
-                         partition_task_size);
-                  REPORT_CALL_ERROR("E19999", "Model def size %zu check invalid,",
-                                    partition_task_size);
+                  GELOGE(FAILED, "[Check][ModelDefSize]Invalid, size %zu, model %s",
+                         partition_task_size, ge_model->GetName().c_str());
+                  REPORT_CALL_ERROR("E19999", "Model def size %zu check invalid, model %s",
+                                    partition_task_size, ge_model->GetName().c_str());
                       return FAILED);
 
   task_buffer = ge::Buffer(partition_task_size);
   if (task_buffer.GetSize() == 0) {
     GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "[Allocate][ModelTaskDefBuffer]Failed, "
-           "model def size %zu", partition_task_size);
-    REPORT_CALL_ERROR("E19999", "Allocate model task def buffer failed, model def size %zu",
-                      partition_task_size);
+           "model def size %zu, model %s", partition_task_size, ge_model->GetName().c_str());
+    REPORT_CALL_ERROR("E19999", "Allocate model task def buffer failed, model def size %zu "
+                      "model %s", partition_task_size, ge_model->GetName().c_str());
     return ACL_ERROR_GE_MEMORY_ALLOCATION;
   }
   (void)model_task_def->SerializePartialToArray(task_buffer.GetData(), static_cast<int>(partition_task_size));
@@ -215,9 +219,10 @@ Status ModelHelper::SaveModelTaskDef(std::shared_ptr<OmFileSaveHelper> &om_file_
   if (SaveModelPartition(om_file_save_helper, ModelPartitionType::TASK_INFO, task_buffer.GetData(),
                          partition_task_size, model_index) != SUCCESS) {
     GELOGE(PARAM_INVALID, "[Add][ModelTaskDefPartition]Failed, model def size %zu, "
-           "model_index %zu", partition_task_size, model_index);
+           "model_index %zu, model %s", partition_task_size, model_index, ge_model->GetName().c_str());
     REPORT_CALL_ERROR("E19999", "Add model task def partition failed, model def size %zu "
-                      "model_index %zu", partition_task_size, model_index);
+                      "model_index %zu, model %s",
+                      partition_task_size, model_index, ge_model->GetName().c_str());
     return PARAM_INVALID;
   }
   return SUCCESS;
@@ -237,11 +242,11 @@ Status ModelHelper::SaveModelHeader(std::shared_ptr<OmFileSaveHelper> &om_file_s
                  platform_version.size() + 1);
   if (err != EOK) {
     GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION,
-           "[Save][Model]Failed while allocating memory for platform_version %s, errno %d",
-            platform_version.c_str(), err);
-    REPORT_CALL_ERROR("E19999", "ModelHelper save model failed while "
+           "[Save][Model]Failed while allocating memory for platform_version %s, model %s, errno %d",
+            platform_version.c_str(), ge_model->GetName().c_str(), err);
+    REPORT_CALL_ERROR("E19999", "ModelHelper save model %s failed while "
                       "allocating memory for platform_version %s, errno %d",
-                      platform_version.c_str(), err);
+                      ge_model->GetName().c_str(), platform_version.c_str(), err);
     return ACL_ERROR_GE_MEMORY_ALLOCATION;
   }
   string version = reinterpret_cast<char *>(model_header.platform_version);
@@ -252,10 +257,10 @@ Status ModelHelper::SaveModelHeader(std::shared_ptr<OmFileSaveHelper> &om_file_s
   err = memcpy_s(model_header.name, MODEL_NAME_LENGTH, ge_model->GetName().c_str(), name_size);
   if (err != EOK) {
     GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION,
-           "[Save][Model]Failed while allocating memory for name %s, errno %d",
+           "[Save][Model]Failed while allocating memory for model %s, errno %d",
            ge_model->GetName().c_str(), err);
     REPORT_CALL_ERROR("E19999", "ModelHelper save model failed while allocating memory "
-                      "for name %s,errno %d", ge_model->GetName().c_str(), err);
+                      "for model %s,errno %d", ge_model->GetName().c_str(), err);
     return ACL_ERROR_GE_MEMORY_ALLOCATION;
   }
   string model_name = reinterpret_cast<char *>(model_header.name);
@@ -267,38 +272,43 @@ Status ModelHelper::SaveAllModelPartiton(std::shared_ptr<OmFileSaveHelper>& om_f
                                          const GeModelPtr &ge_model, ge::Buffer &model_buffer,
                                          ge::Buffer &task_buffer, size_t model_index) {
   if (SaveModelDef(om_file_save_helper, ge_model, model_buffer, model_index) != SUCCESS) {
-    GELOGE(FAILED, "[Save][ModelDef]Failed, model index %zu", model_index);
-    REPORT_INNER_ERROR("E19999", "ModelHelper save model def failed, model index %zu",
-                       model_index);
+    GELOGE(FAILED, "[Save][ModelDef]Failed, model %s, model index %zu",
+           ge_model->GetName().c_str(), model_index);
+    REPORT_CALL_ERROR("E19999", "ModelHelper save model def failed, model %s, model index %zu",
+                       ge_model->GetName().c_str(), model_index);
     return FAILED;
   }
 
   if (SaveModelWeights(om_file_save_helper, ge_model, model_index) != SUCCESS) {
-    GELOGE(FAILED, "[Save][ModelWeights]Failed, model index %zu", model_index);
-    REPORT_INNER_ERROR("E19999","ModelHelper save mode weights failed, mode index %zu",
-                       model_index);
+    GELOGE(FAILED, "[Save][ModelWeights]Failed, model %s, model index %zu",
+           ge_model->GetName().c_str(), model_index);
+    REPORT_CALL_ERROR("E19999","ModelHelper save mode weights failed, model %s, model index %zu",
+                       ge_model->GetName().c_str(), model_index);
     return FAILED;
   }
 
   if (SaveModelTbeKernel(om_file_save_helper, ge_model, model_index) != SUCCESS) {
-     GELOGE(FAILED, "[Save][ModelTbeKernel]Failed, model index %zu", model_index);
-     REPORT_INNER_ERROR("E19999", "ModelHelper save model tbe kernel failed, model index %zu",
-                        model_index);
+     GELOGE(FAILED, "[Save][ModelTbeKernel]Failed, model %s, model index %zu",
+            ge_model->GetName().c_str(), model_index);
+     REPORT_CALL_ERROR("E19999", "ModelHelper save model tbe kernel failed, model %s, model index %zu",
+                        ge_model->GetName().c_str(), model_index);
     return FAILED;
   }
 
   if (SaveModelCustAICPU(om_file_save_helper, ge_model, model_index) != SUCCESS) {
-    GELOGE(FAILED, "[Save][ModelCustAICPU]Failed, model index %zu", model_index);
-    REPORT_INNER_ERROR("E19999", "ModelHelper save model cust aicpu failed, "
-                       "model index %zu", model_index);
+    GELOGE(FAILED, "[Save][ModelCustAICPU]Failed, model %s, model index %zu",
+           ge_model->GetName().c_str(), model_index);
+    REPORT_CALL_ERROR("E19999", "ModelHelper save model cust aicpu failed, model %s "
+                       "model index %zu", ge_model->GetName().c_str(), model_index);
     return FAILED;
   }
 
 
   if (SaveModelTaskDef(om_file_save_helper, ge_model, task_buffer, model_index) != SUCCESS) {
-    GELOGE(FAILED, "[Save][TaskDef]Failed, model index %zu", model_index);
-    REPORT_INNER_ERROR("E19999", "ModelHelper save task def failed, model index %zu",
-                       model_index);
+    GELOGE(FAILED, "[Save][TaskDef]Failed, model %s, model index %zu",
+           ge_model->GetName().c_str(), model_index);
+    REPORT_CALL_ERROR("E19999", "ModelHelper save task def failed, model %s, model index %zu",
+                       ge_model->GetName().c_str(), model_index);
     return FAILED;
   }
   return SUCCESS;
@@ -309,8 +319,10 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
                                                                                    const std::string &output_file,
                                                                                    ModelBufferData& model) {
   if (output_file.empty()) {
-    GELOGE(FAILED, "[Save][Model]GraphBuilder SaveModel received invalid file name prefix");
-    REPORT_INNER_ERROR("E19999", "GraphBuilder SaveModel received invalid file name prefix");
+    GELOGE(FAILED, "[Save][Model]GraphBuilder SaveModel received invalid file name prefix, "
+           "model %s", ge_model->GetName().c_str());
+    REPORT_CALL_ERROR("E19999", "GraphBuilder SaveModel received invalid file name prefix, "
+                      "model %s", ge_model->GetName().c_str());
     return FAILED;
   }
 
@@ -322,25 +334,28 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
 
   auto ret = SaveAllModelPartiton(om_file_save_helper, ge_model, model_buffer, task_buffer);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[Save][AllModelPartition]Failed, error_code %u", ret);
-    REPORT_INNER_ERROR("E19999", "OmFileSaveHelper save all model partition failed, "
-                       "error_code %u", ret);
+    GELOGE(ret, "[Save][AllModelPartition]Failed, model %s, error_code %u",
+           ge_model->GetName().c_str(), ret);
+    REPORT_CALL_ERROR("E19999", "OmFileSaveHelper save all model partition failed, model %s "
+                       "error_code %u", ge_model->GetName().c_str(), ret);
     return ret;
   }
 
   ret = SaveModelHeader(om_file_save_helper, ge_model);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[Save][ModelHeader]Failed, error_code %u", ret);
-    REPORT_INNER_ERROR("E19999", "OmFileSaveHelper save model header failed, "
-                       "error_code %u", ret);
+    GELOGE(ret, "[Save][ModelHeader]Failed, model %s, error_code %u",
+           ge_model->GetName().c_str(), ret);
+    REPORT_CALL_ERROR("E19999", "OmFileSaveHelper save model header failed, model %s "
+                       "error_code %u", ge_model->GetName().c_str(), ret);
     return ret;
   }
 
   ret = om_file_save_helper->SaveModel(save_param, output_file.c_str(), model, is_offline_);
   if (ret != SUCCESS) {
-    GELOGE(FAILED, "[Save][Model]Failed, output file %s", output_file.c_str());
-    REPORT_INNER_ERROR("E19999", "OmFileSaveHelper save model failed, output file %s",
-                       output_file.c_str());
+    GELOGE(FAILED, "[Save][Model]Failed, model %s, output file %s",
+           ge_model->GetName().c_str(), output_file.c_str());
+    REPORT_INNER_ERROR("E19999", "OmFileSaveHelper save model failed, model %s, "
+                       "output file %s", ge_model->GetName().c_str(), output_file.c_str());
     return ret;
   }
   return SUCCESS;
@@ -413,7 +428,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmRoo
     if (ret != SUCCESS) {
       GELOGE(INTERNAL_ERROR, "[Save][AllModelPartition]Failed, model name %s, cur_index %zu",
              model_name.c_str(), cur_index);
-      REPORT_INNER_ERROR("E19999", "Save all model %s partition failed, cur_index %zu",
+      REPORT_CALL_ERROR("E19999", "Save all model %s partition failed, cur_index %zu",
                          model_name.c_str(), cur_index);
       return INTERNAL_ERROR;
     }
@@ -423,15 +438,15 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmRoo
   if (ret != SUCCESS) {
     GELOGE(INTERNAL_ERROR, "[Save][ModelHeader]Failed, model name %s",
            first_ge_model->GetName().c_str());
-    REPORT_INNER_ERROR("E19999", "Save model %s header failed", first_ge_model->GetName().c_str());
+    REPORT_CALL_ERROR("E19999", "Save model %s header failed", first_ge_model->GetName().c_str());
     return INTERNAL_ERROR;
   }
 
   ret = om_file_save_helper->SaveRootModel(save_param, output_file.c_str(), model, is_offline_);
   if (ret != SUCCESS) {
-    GELOGE(FAILED, "[Save][Model]OmFileSaveHelper save model return fail, output_file %s",
+    GELOGE(FAILED, "[Save][Model]OmFileSaveHelper save model eturn fail, output_file %s",
            output_file.c_str());
-    REPORT_INNER_ERROR("E19999", "OmFileSaveHelper save model return fail, output_file %s",
+    REPORT_CALL_ERROR("E19999", "OmFileSaveHelper save model return fail, output_file %s",
                        output_file.c_str());
     return FAILED;
   }
@@ -443,7 +458,7 @@ ModelHelper::SaveOriginalGraphToOmModel(const ge::Graph &graph, const std::strin
   if (output_file.empty()) {
     GELOGE(FAILED, "[Save][Model]Received invalid file name prefix, output_file %s",
            output_file.c_str());
-    REPORT_CALL_ERROR("E19999", "Save model received invalid file name prefix, output_file %s",
+    REPORT_INNER_ERROR("E19999", "Save model received invalid file name prefix, output_file %s",
                       output_file.c_str());
     return FAILED;
   }
@@ -451,7 +466,7 @@ ModelHelper::SaveOriginalGraphToOmModel(const ge::Graph &graph, const std::strin
   auto compute_graph = ge::GraphUtils::GetComputeGraph(graph);
   if (compute_graph == nullptr) {
     GELOGE(FAILED, "[Save][Model]Failed for compute_graph null");
-    REPORT_CALL_ERROR("E19999", "Save model failed for compute_graph null");
+    REPORT_INNER_ERROR("E19999", "Save model failed for compute_graph null");
     return FAILED;
   }
   GE_DUMP(compute_graph, "OriginalGraph");
@@ -473,8 +488,10 @@ ModelHelper::SaveOriginalGraphToOmModel(const ge::Graph &graph, const std::strin
   ge::Buffer model_buffer;
   ge::graphStatus status = model_ptr->Save(model_buffer);
   if (status != ge::GRAPH_SUCCESS) {
-    GELOGE(FAILED, "[Save][Model]Failed for save buffer fail");
-    REPORT_INNER_ERROR("E19999", "Save model failed for save buffer fail");
+    GELOGE(FAILED, "[Save][Model]Failed for save buffer fail, model %s",
+           model_ptr->GetName().c_str());
+    REPORT_CALL_ERROR("E19999", "Save model %s failed for save buffer fail",
+                      model_ptr->GetName().c_str());
     return FAILED;
   }
   std::shared_ptr<OmFileSaveHelper> om_file_save_helper = ge::MakeShared<OmFileSaveHelper>();
@@ -496,10 +513,10 @@ ModelHelper::SaveOriginalGraphToOmModel(const ge::Graph &graph, const std::strin
   errno_t err = memcpy_s(model_header.platform_version, PLATFORM_VERSION_LEN, platform_version.c_str(),
                          platform_version.size() + 1);
   if (err != EOK) {
-    GELOGE(FAILED, "[Save][Model]Failed for platform_version %s, errno %d",
-           platform_version.c_str(), err);
-    REPORT_CALL_ERROR("E19999", "Save model failed for platform_version %s, errno %d",
-                      platform_version.c_str(), err);
+    GELOGE(FAILED, "[Save][Model]Failed for platform_version %s, model %s, errno %d",
+           platform_version.c_str(), model_ptr->GetName().c_str(), err);
+    REPORT_CALL_ERROR("E19999", "Save model %s failed for platform_version %s, errno %d",
+                      model_ptr->GetName().c_str(), platform_version.c_str(), err);
     return FAILED;
   }
   size_t name_size = model_ptr->GetName().size();
@@ -599,7 +616,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadRootMod
   Status status = ModelParserBase::ParseModelContent(model_data, model_addr_tmp_, model_len_tmp_);
   if (status != SUCCESS) {
     GELOGE(ACL_ERROR_GE_PARAM_INVALID, "[Parse][RootModelContent]Failed!");
-    REPORT_INNER_ERROR("E19999", "Parse model content failed");
+    REPORT_CALL_ERROR("E19999", "Parse model content failed");
     return ACL_ERROR_GE_PARAM_INVALID;
   }
 
@@ -629,7 +646,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadRootMod
   status = GenerateGeRootModel(om_load_helper);
   if (status != SUCCESS) {
     GELOGE(status, "[Generate][GERootModel]Failed");
-    REPORT_INNER_ERROR("E19999", "Generate GE root model failed");
+    REPORT_CALL_ERROR("E19999", "Generate GE root model failed");
     return status;
   }
   GELOGD("in ModelHelper::LoadRootModel, is_assign_model_ is setted to true!");
@@ -770,7 +787,7 @@ Status ModelHelper::LoadWeights(OmFileLoadHelper &om_load_helper) {
   ModelPartition partition;
   if (om_load_helper.GetModelPartition(ModelPartitionType::WEIGHTS_DATA, partition) != SUCCESS) {
     GELOGE(FAILED, "[Get][ModelWeightPartition]Failed, GetWeight size:%u", partition.size);
-    REPORT_INNER_ERROR("E19999", "[Get][ModelPartition]Failed, GetWeight size:%u",
+    REPORT_CALL_ERROR("E19999", "[Get][ModelPartition]Failed, GetWeight size:%u",
                        partition.size);
     return FAILED;
   }
@@ -785,7 +802,7 @@ Status ModelHelper::LoadWeights(OmFileLoadHelper &om_load_helper, GeModelPtr &cu
   ModelPartition partition;
   if (om_load_helper.GetModelPartition(ModelPartitionType::WEIGHTS_DATA, partition, mode_index) != SUCCESS) {
     GELOGE(FAILED, "[Get][ModelPartition]Failed, GetWeight size:%u", partition.size);
-    REPORT_INNER_ERROR("E19999", "[Get][ModelPartition]Failed, GetWeight size:%u",
+    REPORT_CALL_ERROR("E19999", "[Get][ModelPartition]Failed, GetWeight size:%u",
                        partition.size);
     return FAILED;
   }
@@ -800,7 +817,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadTask(Om
   ModelPartition task_partition;
   if (om_load_helper.GetModelPartition(ModelPartitionType::TASK_INFO, task_partition) != SUCCESS) {
     GELOGE(FAILED, "[Get][ModelTaskPartition]Failed, task_partition size:%u", task_partition.size);
-    REPORT_INNER_ERROR("E19999", "Get model task partition failed, task_partition size %u",
+    REPORT_CALL_ERROR("E19999", "Get model task partition failed, task_partition size %u",
                       task_partition.size);
     return FAILED;
   }
@@ -1017,7 +1034,8 @@ Status ModelTool::GetModelInfoFromOm(const char *model_file, ge::proto::ModelDef
     ErrorManager::GetInstance().ATCReportErrMessage("E10003",
       {"parameter", "value", "reason"}, {"om", model_file, "invalid om file"});
     GELOGE(ACL_ERROR_GE_PARAM_INVALID,
-           "[Parse][ModelContent]Failed because of invalid om file. Please check om param.");
+           "[Parse][ModelContent]Failed because of invalid om file %s, please check om param",
+           model_file);
     return ret;
   }
 
@@ -1025,7 +1043,7 @@ Status ModelTool::GetModelInfoFromOm(const char *model_file, ge::proto::ModelDef
   ret = om_load_helper.Init(model_data, model_len);
   if (ret != SUCCESS) {
     ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"Om file init failed"});
-    GELOGE(ge::FAILED, "[Init][OmFile]Failed.");
+    GELOGE(ge::FAILED, "[Init][OmFile]Failed, model_file %s", model_file);
     return ret;
   }
 
@@ -1033,7 +1051,7 @@ Status ModelTool::GetModelInfoFromOm(const char *model_file, ge::proto::ModelDef
   ret = om_load_helper.GetModelPartition(MODEL_DEF, ir_part);
   if (ret != SUCCESS) {
     ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"Get model part failed"});
-    GELOGE(ge::FAILED, "[Get][ModelPart]Failed.");
+    GELOGE(ge::FAILED, "[Get][ModelPart]Failed, model_file %s", model_file);
     return ret;
   }
 
@@ -1041,7 +1059,7 @@ Status ModelTool::GetModelInfoFromOm(const char *model_file, ge::proto::ModelDef
   if (!flag) {
     ret = INTERNAL_ERROR;
     ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"ReadProtoFromArray failed"});
-    GELOGE(ret, "[Read][ProtoFromArray]Failed.");
+    GELOGE(ret, "[Read][ProtoFromArray]Failed, model_file %s", model_file);
     return ret;
   }
   modeldef_size = ir_part.size;
@@ -1073,7 +1091,7 @@ Status ModelTool::GetModelInfoFromPbtxt(const char *model_file, ge::proto::Model
     if (!flag) {
       free_model_data(&model.model_data);
       ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"ParseFromString failed"});
-      GELOGE(FAILED, "[Parse][ModelInfo]Failed from string.");
+      GELOGE(FAILED, "[Parse][ModelInfo]Failed from string, model_file %s", model_file);
       return FAILED;
     }
     free_model_data(&model.model_data);
@@ -1082,7 +1100,8 @@ Status ModelTool::GetModelInfoFromPbtxt(const char *model_file, ge::proto::Model
     free_model_data(&model.model_data);
     ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"ParseFromString failed, exception message["
                                                     + std::string(e.what()) + "]"});
-    GELOGE(FAILED, "[Parse][ModelInfo]Failed from string, exception message : %s", e.what());
+    GELOGE(FAILED, "[Parse][ModelInfo]Failed from string, exception message %s, model_file %s",
+           e.what(), model_file);
     return FAILED;
   }
 }