From 54ca11a7e49fe8cc86d951ccf47a3da65816626a Mon Sep 17 00:00:00 2001
From: "liyihan2@huawei.com" <liyihan2@huawei.com>
Date: Wed, 10 Mar 2021 17:32:43 +0800
Subject: [PATCH 1/7] client log optimize

---
 ge/client/ge_api.cc | 77 +++++++++++++++++++++++++--------------------
 1 file changed, 43 insertions(+), 34 deletions(-)

diff --git a/ge/client/ge_api.cc b/ge/client/ge_api.cc
index f0cf9e03..9c17e2b5 100644
--- a/ge/client/ge_api.cc
+++ b/ge/client/ge_api.cc
@@ -69,7 +69,7 @@ Status CheckOptionsValid(const std::map<string, string> &options) {
   auto job_id_iter = options.find(OPTION_EXEC_JOB_ID);
   if (job_id_iter != options.end()) {
     if (job_id_iter->second.length() > kMaxStrLen) {
-      GELOGE(PARAM_INVALID, "CheckOptionsValid job_id failed, string len > %d", kMaxStrLen);
+      GELOGE(PARAM_INVALID, "[Check][Job_id]Before execution, check job_id failed,the job_id string length:%d > max string length:%d", kMaxStrLen, job_id_iter);
       return FAILED;
     }
   }
@@ -84,7 +84,7 @@ Status GEInitializeImpl(const std::map<string, string> &options) {
   std::string path_base = ge::GELib::GetPath();
   auto ret = ErrorManager::GetInstance().Init(path_base);
   if (ret != SUCCESS) {
-    GELOGE(GE_CLI_INIT_FAILED, "ErrorManager init fail");
+    GELOGE(GE_CLI_INIT_FAILED, "[Check][Path_base]GELib init fail because GELib path_base:%s is invalid", path_base);
     return ret;
   }
 
@@ -104,7 +104,7 @@ Status GEInitializeImpl(const std::map<string, string> &options) {
   bool is_proto_init = manager->Initialize(option_tmp);
   GE_TIMESTAMP_END(GEInitialize, "GEInitialize::ManagerInitialize");
   if (!is_proto_init) {
-    GELOGE(GE_CLI_INIT_FAILED, "geInitialize failed, ops proto path is invalid.");
+    GELOGE(GE_CLI_INIT_FAILED, "[LoadOpsProtoLibPlugin][OpsProtoPath]Loading OpsProto lib plugin failed because ops proto path:%s is invalid.", opsproto_path);
     return FAILED;
   }
 
@@ -127,7 +127,7 @@ Status GEInitializeImpl(const std::map<string, string> &options) {
   ret = ge::GELib::Initialize(options);
   GE_TIMESTAMP_END(GELibInitialize, "GEInitialize::GELibInitialize");
   if (ret != SUCCESS) {
-    GELOGE(GE_CLI_INIT_FAILED, "geInitialize failed, error code = %u", ret);
+    GELOGE(GE_CLI_INIT_FAILED, "[GELibInit][GELib]GELib init failed because the options are invalid, error code = %u", ret);
     return FAILED;
   }
 
@@ -155,7 +155,7 @@ Status GEInitialize(const std::map<AscendString, AscendString> &options) {
   std::map<std::string, std::string> str_options;
   for (auto &option : options) {
     if (option.first.GetString() == nullptr || option.second.GetString() == nullptr) {
-      GELOGE(FAILED, "GEInitialize options is nullptr.");
+      GELOGE(FAILED, "[GELibInit][GELib]GELib init failed because the options are nullptr, first option and second option are both nullptr.");
       return FAILED;
     }
     std::string key = option.first.GetString();
@@ -237,13 +237,13 @@ Session::Session(const std::map<string, string> &options) {
   // check init status
   sessionId_ = 0;
   if (!g_ge_initialized) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "GE is not initialized.");
+    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[SessionConstruct][Session]GE session constructor init failed because the init status(g_ge_initialized) is false.");
     return;
   }
   // call Initialize
   std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "Session Constructor failed");
+    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[SessionConstruct][Session]GE session constructor init failed because instance_ptr is nullptr");
     return;
   }
 
@@ -256,7 +256,7 @@ Session::Session(const std::map<string, string> &options) {
   if (ret == SUCCESS) {
     sessionId_ = session_id;
   } else {
-    GELOGE(ret, "Session constructor failed, session Id not initialized");
+    GELOGE(ret, "[SessionConstruct][Session]GE session constructor init failed because return status is failed.");
     return;
   }
   GELOGT(TRACE_STOP, "Session Constructor finished");
@@ -270,13 +270,13 @@ Session::Session(const std::map<AscendString, AscendString> &options) {
   // check init status
   sessionId_ = 0;
   if (!g_ge_initialized) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "GE is not initialized.");
+    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[SessionConstruct][Session]GE session constructor init failed because the init status(g_ge_initialized) is false.");
     return;
   }
   // call Initialize
   std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "Session Constructor failed");
+    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[SessionConstruct][Session]GE session constructor init failed because the instance_ptr is nullptr");
     return;
   }
 
@@ -284,7 +284,7 @@ Session::Session(const std::map<AscendString, AscendString> &options) {
   std::map<std::string, std::string> str_options;
   for (auto &option : options) {
     if (option.first.GetString() == nullptr || option.second.GetString() == nullptr) {
-      GELOGE(FAILED, "Session options is nullptr.");
+      GELOGE(FAILED, "[SessionConstruct][Session]Creating GE session failed because the options are nullptr.");
       return;
     }
     std::string key = option.first.GetString();
@@ -299,7 +299,7 @@ Session::Session(const std::map<AscendString, AscendString> &options) {
   if (ret == SUCCESS) {
     sessionId_ = session_id;
   } else {
-    GELOGE(ret, "Session constructor failed, session Id not initialized");
+    GELOGE(ret, "[SessionConstruct][Session]GE session constructor init failed because return status is failed.");
     return;
   }
   GELOGT(TRACE_STOP, "Session Constructor finished");
@@ -331,17 +331,18 @@ Session::~Session() {
 
     ret = instance_ptr->SessionManagerObj().DestroySession(session_id);
   } catch (google::protobuf::FatalException &e) {
-    GELOGE(GE_CLI_SESS_DESTROY_FAILED, "SessionDestructor throws FatalException");
+    GELOGE(GE_CLI_SESS_DESTROY_FAILED, "[SessionDestruct][Session]GE session destructor throws FatalException");
   }
 
   // check return status, return, update session id if success
   if (ret != SUCCESS) {
-    GELOGE(ret, "Session Destructor failed");
+    GELOGE(ret, "[SessionDestruct][Session]GE session destructor init failed because the return status is failed.");
   }
 
   GELOGT(TRACE_STOP, "Session Destructor finished");
 }
 
+//Add Graph
 Status Session::AddGraph(uint32_t graph_id, const Graph &graph) {
   ErrorManager::GetInstance().SetStage(ErrorMessage::kModelCompile, ErrorMessage::kOther);
   std::map<std::string, std::string> options;
@@ -355,19 +356,20 @@ Status Session::AddGraph(uint32_t graph_id, const Graph &graph, const std::map<s
   ErrorManager::GetInstance().GenWorkStreamIdBySessionGraph(sessionId_, graph_id);
   std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "AddGraph failed in Session.");
+    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[AddGraph][Graph]AddGraph to session failed because instance_ptr is nullptr.");
     return FAILED;
   }
   GELOGD("Adding graph to session");
   Status ret = instance_ptr->SessionManagerObj().AddGraph(sessionId_, graph_id, graph, options);
   if (ret != SUCCESS) {
-    GELOGE(ret, "AddGraph failed in Session.");
+    GELOGE(ret, "[AddGraph][Graph]AddGraph to session failed because graph info(session_id, graph_id, graph, options) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
     return FAILED;
   }
   GELOGD("AddGraph finished in Session.");
   return ret;
 }
 
+//Add Graph
 Status Session::AddGraph(uint32_t graph_id, const Graph &graph,
                          const std::map<AscendString, AscendString> &options) {
   ErrorManager::GetInstance().SetStage(ErrorMessage::kModelCompile, ErrorMessage::kOther);
@@ -375,14 +377,14 @@ Status Session::AddGraph(uint32_t graph_id, const Graph &graph,
   ErrorManager::GetInstance().GenWorkStreamIdBySessionGraph(sessionId_, graph_id);
   std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "AddGraph failed in Session.");
+    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[AddGraph][Graph]AddGraph to session failed because instance_ptr is nullptr.");
     return FAILED;
   }
   GELOGD("Adding graph to session");
   std::map<std::string, std::string> str_options;
   for (auto &option : options) {
     if (option.first.GetString() == nullptr || option.second.GetString() == nullptr) {
-      GELOGE(FAILED, "AddGraph options is nullptr.");
+      GELOGE(FAILED, "[AddGraph][Graph]AddGraph to session failed because the options is nullptr.");
       return FAILED;
     }
     std::string key = option.first.GetString();
@@ -391,13 +393,14 @@ Status Session::AddGraph(uint32_t graph_id, const Graph &graph,
   }
   Status ret = instance_ptr->SessionManagerObj().AddGraph(sessionId_, graph_id, graph, str_options);
   if (ret != SUCCESS) {
-    GELOGE(ret, "AddGraph failed in Session.");
+    GELOGE(ret, "[Check][AddGraphObj]AddGraph to session failed because graph info(session_id, graph_id, graph, str_options) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
     return FAILED;
   }
   GELOGD("AddGraph finished in Session.");
   return ret;
 }
 
+//Add Graph With Copy
 Status Session::AddGraphWithCopy(uint32_t graph_id, const Graph &graph) {
   ErrorManager::GetInstance().SetStage(ErrorMessage::kModelCompile, ErrorMessage::kOther);
   ErrorManager::GetInstance().GenWorkStreamIdBySessionGraph(sessionId_, graph_id);
@@ -412,7 +415,7 @@ Status Session::AddGraphWithCopy(uint32_t graph_id, const Graph &graph,
   ErrorManager::GetInstance().GenWorkStreamIdBySessionGraph(sessionId_, graph_id);
   std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "AddGraph failed in Session.");
+    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[AddGraphWithCopy][Graph]AddGraph to session failed because the instance_ptr is nullptr.");
     return FAILED;
   }
   std::map<std::string, std::string> str_options;
@@ -422,13 +425,14 @@ Status Session::AddGraphWithCopy(uint32_t graph_id, const Graph &graph,
   GELOGD("Adding graph to session");
   Status ret = instance_ptr->SessionManagerObj().AddGraphWithCopy(sessionId_, graph_id, graph, str_options);
   if (ret != SUCCESS) {
-    GELOGE(ret, "AddGraph failed in Session.");
+    GELOGE(ret, "[AddGraphWithCopy][Graph]AddGraph to session failed because graph info(session_id, graph_id, graph, str_options) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
     return FAILED;
   }
   GELOGD("AddGraph finished in Session.");
   return ret;
 }
 
+//Remove Graph
 Status Session::RemoveGraph(uint32_t graph_id) {
   ErrorManager::GetInstance().SetStage(ErrorMessage::kModelCompile, ErrorMessage::kOther);
   GELOGT(TRACE_INIT, "Session RemoveGraph start");
@@ -437,7 +441,7 @@ Status Session::RemoveGraph(uint32_t graph_id) {
   // call RemoveGraph
   std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
   if (!instance_ptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "Session RemoveGraph failed");
+    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[RemoveGraph][Graph]RemoveGraph out of session failed because instance_ptr is nullptr.");
     return FAILED;
   }
 
@@ -445,7 +449,7 @@ Status Session::RemoveGraph(uint32_t graph_id) {
   Status ret = instance_ptr->SessionManagerObj().RemoveGraph(sessionId_, graph_id);
   // check return status, return
   if (ret != SUCCESS) {
-    GELOGE(ret, "session RemoveGraph failed");
+    GELOGE(ret, "[RemoveGraph][Graph]RemoveGraph out of session failed because remove graph info(session_id, graph_id) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
     return FAILED;
   }
   GELOGT(TRACE_STOP, "Session RemoveGraph finished");
@@ -499,6 +503,7 @@ void PrintOutputResult(std::vector<Tensor> &outputs) {
   }
 }
 
+//Run Graph
 Status Session::RunGraph(uint32_t graph_id, const std::vector<Tensor> &inputs, std::vector<Tensor> &outputs) {
   ErrorManager::GetInstance().SetStage(ErrorMessage::kModelCompile, ErrorMessage::kOther);
   GELOGT(TRACE_INIT, "Session RunGraph start");
@@ -508,14 +513,14 @@ Status Session::RunGraph(uint32_t graph_id, const std::vector<Tensor> &inputs, s
   // call RunGraph
   std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "Session RunGraph failed");
+    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[RunGraph][Graph]Session RunGraph failed because the instance_ptr is nullptr.");
     return FAILED;
   }
   GELOGT(TRACE_RUNNING, "Running Graph");
   Status ret = instance_ptr->SessionManagerObj().RunGraph(sessionId_, graph_id, graph_inputs, outputs);
   // check return status
   if (ret != SUCCESS) {
-    GELOGE(ret, "Session RunGraph failed");
+    GELOGE(ret, "[RunGraph][Graph]Session RunGraph failed because run graph info(session_id, graph_id, graph_inputs, outputs) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
     return FAILED;
   }
 
@@ -543,30 +548,32 @@ Status Session::RegisterCallBackFunc(const char *key, const session::pCallBackFu
   return ge::GELib::GetInstance()->SessionManagerObj().RegisterCallBackFunc(sessionId_, str_key, callback);
 }
 
+//Build Graph
 Status Session::BuildGraph(uint32_t graph_id, const std::vector<InputTensorInfo> &inputs) {
   ErrorManager::GetInstance().SetStage(ErrorMessage::kModelCompile, ErrorMessage::kOther);
   ErrorManager::GetInstance().GenWorkStreamIdBySessionGraph(sessionId_, graph_id);
   std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "SessionConstructor failed");
+    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[BuildGraph][Graph]Session BuildGraph failed because the instance_ptr is nullptr.");
     return FAILED;
   }
   GELOGT(TRACE_RUNNING, "Building Graph");
   Status ret = instance_ptr->SessionManagerObj().BuildGraph(sessionId_, graph_id, inputs);
   if (ret != SUCCESS) {
-    GELOGE(ret, "Session BuildGraph failed");
+    GELOGE(ret, "[BuildGraph][Graph]Session BuildGraph failed because build graph info(session_id, graph_id, inputs) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
     return FAILED;
   }
   return SUCCESS;
 }
 
+//Run Graph Asynchronously
 Status Session::RunGraphAsync(uint32_t graph_id, const std::vector<InputTensorInfo> &inputs,
                               RunAsyncCallback callback) {
   ErrorManager::GetInstance().SetStage(ErrorMessage::kModelExecute, ErrorMessage::kModelExecute);
   ErrorManager::GetInstance().GenWorkStreamIdBySessionGraph(sessionId_, graph_id);
   std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "SessionConstructor failed");
+    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[RunGraphAsync][Graph]Session RunGraphAsync failed because the instance_ptr is nullptr.");
     return FAILED;
   }
   GELOGT(TRACE_RUNNING, "Run Graph Asynchronously");
@@ -575,49 +582,51 @@ Status Session::RunGraphAsync(uint32_t graph_id, const std::vector<InputTensorIn
 
   Status ret = ge::GELib::GetInstance()->SessionManagerObj().RunGraphAsync(sessionId_, graph_id, inputs, callback);
   if (ret != SUCCESS) {
-    GELOGE(ret, "SessionManager RunGraphAsync failed");
+    GELOGE(ret, "[RunGraphAsync][Graph]Session RunGraphAsync failed beccause asnchronously running graph info(session_id, graph_id, inputs, callback) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
     return FAILED;
   }
   return SUCCESS;
 }
 
+//Get Variables
 Status Session::GetVariables(const std::vector<std::string> &var_names, std::vector<Tensor> &var_values) {
   ErrorManager::GetInstance().SetStage(ErrorMessage::kModelExecute, ErrorMessage::kModelExecute);
   ErrorManager::GetInstance().GenWorkStreamIdDefault();
   auto instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "SessionConstructor failed");
+    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[GetVariables][Variables]Session GetVariables failed because the instance_ptr is nullptr.");
     return FAILED;
   }
   GELOGT(TRACE_RUNNING, "Get Variables");
   Status ret = ge::GELib::GetInstance()->SessionManagerObj().GetVariables(sessionId_, var_names, var_values);
   if (ret != SUCCESS) {
-    GELOGE(ret, "SessionManager RunGraphAsync failed");
+    GELOGE(ret, "[GetVariables][Variables]Session GetVariables failed because getting variables info(session_id, var_names, var_values) is invalid, session_id:%lu." sessionId_);
     return FAILED;
   }
   return SUCCESS;
 }
 
+//Get Variables
 Status Session::GetVariables(const std::vector<AscendString> &var_names, std::vector<Tensor> &var_values) {
   ErrorManager::GetInstance().SetStage(ErrorMessage::kModelExecute, ErrorMessage::kModelExecute);
   ErrorManager::GetInstance().GenWorkStreamIdDefault();
   auto instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "SessionConstructor failed");
+    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[GetVariables][Variables]Session GetVariables failed because the instance_ptr is nullptr.");
     return FAILED;
   }
   GELOGT(TRACE_RUNNING, "Get Variables");
   std::vector<ge::string> str_var_names;
   for (auto &var_name : var_names) {
     if (var_name.GetString() == nullptr) {
-      GELOGE(FAILED, "GetVariables name is nullptr.");
+      GELOGE(FAILED, "[GetVariablesName][VariablesName]GetVariables name(var_name) is nullptr.");
       return FAILED;
     }
     str_var_names.emplace_back(var_name.GetString());
   }
   Status ret = ge::GELib::GetInstance()->SessionManagerObj().GetVariables(sessionId_, str_var_names, var_values);
   if (ret != SUCCESS) {
-    GELOGE(ret, "SessionManager RunGraphAsync failed");
+    GELOGE(ret, "[GetVariables][Variables]Session GetVariables failed because getting variables info(session_id, str_var_names, var_values) is invalid, session_id:%lu." sessionId_);
     return FAILED;
   }
   return SUCCESS;

From 50f4754cf310d03a36c86ca036879269870da49d Mon Sep 17 00:00:00 2001
From: "liyihan2@huawei.com" <liyihan2@huawei.com>
Date: Thu, 11 Mar 2021 10:53:59 +0800
Subject: [PATCH 2/7] client log optimize

---
 ge/client/ge_api.cc | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/ge/client/ge_api.cc b/ge/client/ge_api.cc
index 9c17e2b5..223f9ef9 100644
--- a/ge/client/ge_api.cc
+++ b/ge/client/ge_api.cc
@@ -362,7 +362,7 @@ Status Session::AddGraph(uint32_t graph_id, const Graph &graph, const std::map<s
   GELOGD("Adding graph to session");
   Status ret = instance_ptr->SessionManagerObj().AddGraph(sessionId_, graph_id, graph, options);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[AddGraph][Graph]AddGraph to session failed because graph info(session_id, graph_id, graph, options) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
+    GELOGE(ret, "[AddGraph][Graph]AddGraph to session failed because graph info(session_id, graph_id, graph, options) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
     return FAILED;
   }
   GELOGD("AddGraph finished in Session.");
@@ -393,7 +393,7 @@ Status Session::AddGraph(uint32_t graph_id, const Graph &graph,
   }
   Status ret = instance_ptr->SessionManagerObj().AddGraph(sessionId_, graph_id, graph, str_options);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[Check][AddGraphObj]AddGraph to session failed because graph info(session_id, graph_id, graph, str_options) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
+    GELOGE(ret, "[Check][AddGraphObj]AddGraph to session failed because graph info(session_id, graph_id, graph, str_options) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
     return FAILED;
   }
   GELOGD("AddGraph finished in Session.");
@@ -425,7 +425,7 @@ Status Session::AddGraphWithCopy(uint32_t graph_id, const Graph &graph,
   GELOGD("Adding graph to session");
   Status ret = instance_ptr->SessionManagerObj().AddGraphWithCopy(sessionId_, graph_id, graph, str_options);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[AddGraphWithCopy][Graph]AddGraph to session failed because graph info(session_id, graph_id, graph, str_options) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
+    GELOGE(ret, "[AddGraphWithCopy][Graph]AddGraph to session failed because graph info(session_id, graph_id, graph, str_options) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
     return FAILED;
   }
   GELOGD("AddGraph finished in Session.");
@@ -449,7 +449,7 @@ Status Session::RemoveGraph(uint32_t graph_id) {
   Status ret = instance_ptr->SessionManagerObj().RemoveGraph(sessionId_, graph_id);
   // check return status, return
   if (ret != SUCCESS) {
-    GELOGE(ret, "[RemoveGraph][Graph]RemoveGraph out of session failed because remove graph info(session_id, graph_id) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
+    GELOGE(ret, "[RemoveGraph][Graph]RemoveGraph out of session failed because remove graph info(session_id, graph_id) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
     return FAILED;
   }
   GELOGT(TRACE_STOP, "Session RemoveGraph finished");
@@ -520,7 +520,7 @@ Status Session::RunGraph(uint32_t graph_id, const std::vector<Tensor> &inputs, s
   Status ret = instance_ptr->SessionManagerObj().RunGraph(sessionId_, graph_id, graph_inputs, outputs);
   // check return status
   if (ret != SUCCESS) {
-    GELOGE(ret, "[RunGraph][Graph]Session RunGraph failed because run graph info(session_id, graph_id, graph_inputs, outputs) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
+    GELOGE(ret, "[RunGraph][Graph]Session RunGraph failed because run graph info(session_id, graph_id, graph_inputs, outputs) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
     return FAILED;
   }
 
@@ -560,7 +560,7 @@ Status Session::BuildGraph(uint32_t graph_id, const std::vector<InputTensorInfo>
   GELOGT(TRACE_RUNNING, "Building Graph");
   Status ret = instance_ptr->SessionManagerObj().BuildGraph(sessionId_, graph_id, inputs);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[BuildGraph][Graph]Session BuildGraph failed because build graph info(session_id, graph_id, inputs) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
+    GELOGE(ret, "[BuildGraph][Graph]Session BuildGraph failed because build graph info(session_id, graph_id, inputs) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
     return FAILED;
   }
   return SUCCESS;
@@ -582,7 +582,7 @@ Status Session::RunGraphAsync(uint32_t graph_id, const std::vector<InputTensorIn
 
   Status ret = ge::GELib::GetInstance()->SessionManagerObj().RunGraphAsync(sessionId_, graph_id, inputs, callback);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[RunGraphAsync][Graph]Session RunGraphAsync failed beccause asnchronously running graph info(session_id, graph_id, inputs, callback) is invalid, session_id:%lu, graph_id:%lu." sessionId_, graph_id);
+    GELOGE(ret, "[RunGraphAsync][Graph]Session RunGraphAsync failed beccause asnchronously running graph info(session_id, graph_id, inputs, callback) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
     return FAILED;
   }
   return SUCCESS;
@@ -600,7 +600,7 @@ Status Session::GetVariables(const std::vector<std::string> &var_names, std::vec
   GELOGT(TRACE_RUNNING, "Get Variables");
   Status ret = ge::GELib::GetInstance()->SessionManagerObj().GetVariables(sessionId_, var_names, var_values);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[GetVariables][Variables]Session GetVariables failed because getting variables info(session_id, var_names, var_values) is invalid, session_id:%lu." sessionId_);
+    GELOGE(ret, "[GetVariables][Variables]Session GetVariables failed because getting variables info(session_id, var_names, var_values) is invalid, session_id:%lu.", sessionId_);
     return FAILED;
   }
   return SUCCESS;
@@ -626,7 +626,7 @@ Status Session::GetVariables(const std::vector<AscendString> &var_names, std::ve
   }
   Status ret = ge::GELib::GetInstance()->SessionManagerObj().GetVariables(sessionId_, str_var_names, var_values);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[GetVariables][Variables]Session GetVariables failed because getting variables info(session_id, str_var_names, var_values) is invalid, session_id:%lu." sessionId_);
+    GELOGE(ret, "[GetVariables][Variables]Session GetVariables failed because getting variables info(session_id, str_var_names, var_values) is invalid, session_id:%lu.", sessionId_);
     return FAILED;
   }
   return SUCCESS;

From a27b0a5d6863c251d0cf3823dc129d45c44f1f38 Mon Sep 17 00:00:00 2001
From: "liyihan2@huawei.com" <liyihan2@huawei.com>
Date: Thu, 11 Mar 2021 11:14:34 +0800
Subject: [PATCH 3/7] client log optimize

---
 ge/client/ge_api.cc | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/ge/client/ge_api.cc b/ge/client/ge_api.cc
index 223f9ef9..56655947 100644
--- a/ge/client/ge_api.cc
+++ b/ge/client/ge_api.cc
@@ -84,7 +84,7 @@ Status GEInitializeImpl(const std::map<string, string> &options) {
   std::string path_base = ge::GELib::GetPath();
   auto ret = ErrorManager::GetInstance().Init(path_base);
   if (ret != SUCCESS) {
-    GELOGE(GE_CLI_INIT_FAILED, "[Check][Path_base]GELib init fail because GELib path_base:%s is invalid", path_base);
+    GELOGE(GE_CLI_INIT_FAILED, "[Check][Path_base]GELib init fail because GELib path_base: %s is invalid", path_base);
     return ret;
   }
 
@@ -104,7 +104,7 @@ Status GEInitializeImpl(const std::map<string, string> &options) {
   bool is_proto_init = manager->Initialize(option_tmp);
   GE_TIMESTAMP_END(GEInitialize, "GEInitialize::ManagerInitialize");
   if (!is_proto_init) {
-    GELOGE(GE_CLI_INIT_FAILED, "[LoadOpsProtoLibPlugin][OpsProtoPath]Loading OpsProto lib plugin failed because ops proto path:%s is invalid.", opsproto_path);
+    GELOGE(GE_CLI_INIT_FAILED, "[LoadOpsProtoLibPlugin][OpsProtoPath]Loading OpsProto lib plugin failed because ops proto path: %s is invalid.", opsproto_path);
     return FAILED;
   }
 
@@ -362,7 +362,7 @@ Status Session::AddGraph(uint32_t graph_id, const Graph &graph, const std::map<s
   GELOGD("Adding graph to session");
   Status ret = instance_ptr->SessionManagerObj().AddGraph(sessionId_, graph_id, graph, options);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[AddGraph][Graph]AddGraph to session failed because graph info(session_id, graph_id, graph, options) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
+    GELOGE(ret, "[AddGraph][Graph]AddGraph to session failed because graph info(session_id, graph_id, graph, options) is invalid, session_id: %lu, graph_id: %u.", sessionId_, graph_id);
     return FAILED;
   }
   GELOGD("AddGraph finished in Session.");
@@ -393,7 +393,7 @@ Status Session::AddGraph(uint32_t graph_id, const Graph &graph,
   }
   Status ret = instance_ptr->SessionManagerObj().AddGraph(sessionId_, graph_id, graph, str_options);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[Check][AddGraphObj]AddGraph to session failed because graph info(session_id, graph_id, graph, str_options) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
+    GELOGE(ret, "[Check][AddGraphObj]AddGraph to session failed because graph info(session_id, graph_id, graph, str_options) is invalid, session_id: %lu, graph_id: %u.", sessionId_, graph_id);
     return FAILED;
   }
   GELOGD("AddGraph finished in Session.");
@@ -425,7 +425,7 @@ Status Session::AddGraphWithCopy(uint32_t graph_id, const Graph &graph,
   GELOGD("Adding graph to session");
   Status ret = instance_ptr->SessionManagerObj().AddGraphWithCopy(sessionId_, graph_id, graph, str_options);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[AddGraphWithCopy][Graph]AddGraph to session failed because graph info(session_id, graph_id, graph, str_options) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
+    GELOGE(ret, "[AddGraphWithCopy][Graph]AddGraph to session failed because graph info(session_id, graph_id, graph, str_options) is invalid, session_id: %lu, graph_id: %u.", sessionId_, graph_id);
     return FAILED;
   }
   GELOGD("AddGraph finished in Session.");
@@ -449,7 +449,7 @@ Status Session::RemoveGraph(uint32_t graph_id) {
   Status ret = instance_ptr->SessionManagerObj().RemoveGraph(sessionId_, graph_id);
   // check return status, return
   if (ret != SUCCESS) {
-    GELOGE(ret, "[RemoveGraph][Graph]RemoveGraph out of session failed because remove graph info(session_id, graph_id) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
+    GELOGE(ret, "[RemoveGraph][Graph]RemoveGraph out of session failed because remove graph info(session_id, graph_id) is invalid, session_id: %lu, graph_id: %u.", sessionId_, graph_id);
     return FAILED;
   }
   GELOGT(TRACE_STOP, "Session RemoveGraph finished");
@@ -520,7 +520,7 @@ Status Session::RunGraph(uint32_t graph_id, const std::vector<Tensor> &inputs, s
   Status ret = instance_ptr->SessionManagerObj().RunGraph(sessionId_, graph_id, graph_inputs, outputs);
   // check return status
   if (ret != SUCCESS) {
-    GELOGE(ret, "[RunGraph][Graph]Session RunGraph failed because run graph info(session_id, graph_id, graph_inputs, outputs) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
+    GELOGE(ret, "[RunGraph][Graph]Session RunGraph failed because run graph info(session_id, graph_id, graph_inputs, outputs) is invalid, session_id: %lu, graph_id: %u.", sessionId_, graph_id);
     return FAILED;
   }
 
@@ -560,7 +560,7 @@ Status Session::BuildGraph(uint32_t graph_id, const std::vector<InputTensorInfo>
   GELOGT(TRACE_RUNNING, "Building Graph");
   Status ret = instance_ptr->SessionManagerObj().BuildGraph(sessionId_, graph_id, inputs);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[BuildGraph][Graph]Session BuildGraph failed because build graph info(session_id, graph_id, inputs) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
+    GELOGE(ret, "[BuildGraph][Graph]Session BuildGraph failed because build graph info(session_id, graph_id, inputs) is invalid, session_id: %lu, graph_id: %u.", sessionId_, graph_id);
     return FAILED;
   }
   return SUCCESS;
@@ -582,7 +582,7 @@ Status Session::RunGraphAsync(uint32_t graph_id, const std::vector<InputTensorIn
 
   Status ret = ge::GELib::GetInstance()->SessionManagerObj().RunGraphAsync(sessionId_, graph_id, inputs, callback);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[RunGraphAsync][Graph]Session RunGraphAsync failed beccause asnchronously running graph info(session_id, graph_id, inputs, callback) is invalid, session_id:%lu, graph_id:%lu.", sessionId_, graph_id);
+    GELOGE(ret, "[RunGraphAsync][Graph]Session RunGraphAsync failed beccause asnchronously running graph info(session_id, graph_id, inputs, callback) is invalid, session_id:%lu, graph_id: %u.", sessionId_, graph_id);
     return FAILED;
   }
   return SUCCESS;
@@ -600,7 +600,7 @@ Status Session::GetVariables(const std::vector<std::string> &var_names, std::vec
   GELOGT(TRACE_RUNNING, "Get Variables");
   Status ret = ge::GELib::GetInstance()->SessionManagerObj().GetVariables(sessionId_, var_names, var_values);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[GetVariables][Variables]Session GetVariables failed because getting variables info(session_id, var_names, var_values) is invalid, session_id:%lu.", sessionId_);
+    GELOGE(ret, "[GetVariables][Variables]Session GetVariables failed because getting variables info(session_id, var_names, var_values) is invalid, session_id: %lu.", sessionId_);
     return FAILED;
   }
   return SUCCESS;
@@ -626,7 +626,7 @@ Status Session::GetVariables(const std::vector<AscendString> &var_names, std::ve
   }
   Status ret = ge::GELib::GetInstance()->SessionManagerObj().GetVariables(sessionId_, str_var_names, var_values);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[GetVariables][Variables]Session GetVariables failed because getting variables info(session_id, str_var_names, var_values) is invalid, session_id:%lu.", sessionId_);
+    GELOGE(ret, "[GetVariables][Variables]Session GetVariables failed because getting variables info(session_id, str_var_names, var_values) is invalid, session_id: %lu.", sessionId_);
     return FAILED;
   }
   return SUCCESS;

From 7800216cd37a4c23276fce337523683de691ae41 Mon Sep 17 00:00:00 2001
From: "liyihan2@huawei.com" <liyihan2@huawei.com>
Date: Thu, 11 Mar 2021 11:22:42 +0800
Subject: [PATCH 4/7] client log optimize

---
 ge/client/ge_api.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ge/client/ge_api.cc b/ge/client/ge_api.cc
index 56655947..2c9fe608 100644
--- a/ge/client/ge_api.cc
+++ b/ge/client/ge_api.cc
@@ -69,7 +69,7 @@ Status CheckOptionsValid(const std::map<string, string> &options) {
   auto job_id_iter = options.find(OPTION_EXEC_JOB_ID);
   if (job_id_iter != options.end()) {
     if (job_id_iter->second.length() > kMaxStrLen) {
-      GELOGE(PARAM_INVALID, "[Check][Job_id]Before execution, check job_id failed,the job_id string length:%d > max string length:%d", kMaxStrLen, job_id_iter);
+      GELOGE(PARAM_INVALID, "[Check][Job_id]Before execution, check job_id failed,the job_id string length: %d > max string length: %d", job_id_iter->second.length(), kMaxStrLen);
       return FAILED;
     }
   }

From a4d6b689f18070a69cd0b0330af9ed5067f4b102 Mon Sep 17 00:00:00 2001
From: "liyihan2@huawei.com" <liyihan2@huawei.com>
Date: Thu, 11 Mar 2021 15:11:41 +0800
Subject: [PATCH 5/7] client log optimize

---
 ge/client/ge_api.cc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ge/client/ge_api.cc b/ge/client/ge_api.cc
index 2c9fe608..b91d371c 100644
--- a/ge/client/ge_api.cc
+++ b/ge/client/ge_api.cc
@@ -69,7 +69,7 @@ Status CheckOptionsValid(const std::map<string, string> &options) {
   auto job_id_iter = options.find(OPTION_EXEC_JOB_ID);
   if (job_id_iter != options.end()) {
     if (job_id_iter->second.length() > kMaxStrLen) {
-      GELOGE(PARAM_INVALID, "[Check][Job_id]Before execution, check job_id failed,the job_id string length: %d > max string length: %d", job_id_iter->second.length(), kMaxStrLen);
+      GELOGE(PARAM_INVALID, "[Check][Job_id]Before execution, check job_id failed,the job_id string length: %u > max string length: %d", job_id_iter->second.length(), kMaxStrLen);
       return FAILED;
     }
   }
@@ -84,7 +84,7 @@ Status GEInitializeImpl(const std::map<string, string> &options) {
   std::string path_base = ge::GELib::GetPath();
   auto ret = ErrorManager::GetInstance().Init(path_base);
   if (ret != SUCCESS) {
-    GELOGE(GE_CLI_INIT_FAILED, "[Check][Path_base]GELib init fail because GELib path_base: %s is invalid", path_base);
+    GELOGE(GE_CLI_INIT_FAILED, "[Check][Path_base]GELib init fail because GELib path_base: %s is invalid", path_base.c_str());
     return ret;
   }
 
@@ -104,7 +104,7 @@ Status GEInitializeImpl(const std::map<string, string> &options) {
   bool is_proto_init = manager->Initialize(option_tmp);
   GE_TIMESTAMP_END(GEInitialize, "GEInitialize::ManagerInitialize");
   if (!is_proto_init) {
-    GELOGE(GE_CLI_INIT_FAILED, "[LoadOpsProtoLibPlugin][OpsProtoPath]Loading OpsProto lib plugin failed because ops proto path: %s is invalid.", opsproto_path);
+    GELOGE(GE_CLI_INIT_FAILED, "[LoadOpsProtoLibPlugin][OpsProtoPath]Loading OpsProto lib plugin failed because ops proto path: %s is invalid.", opsproto_path.c_str());
     return FAILED;
   }
 

From 3a3f9316a31ef8183fb1b27df7d785057ce26666 Mon Sep 17 00:00:00 2001
From: "liyihan2@huawei.com" <liyihan2@huawei.com>
Date: Thu, 11 Mar 2021 16:05:12 +0800
Subject: [PATCH 6/7] client log optimize

---
 ge/client/ge_api.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ge/client/ge_api.cc b/ge/client/ge_api.cc
index b91d371c..ef270ed5 100644
--- a/ge/client/ge_api.cc
+++ b/ge/client/ge_api.cc
@@ -69,7 +69,7 @@ Status CheckOptionsValid(const std::map<string, string> &options) {
   auto job_id_iter = options.find(OPTION_EXEC_JOB_ID);
   if (job_id_iter != options.end()) {
     if (job_id_iter->second.length() > kMaxStrLen) {
-      GELOGE(PARAM_INVALID, "[Check][Job_id]Before execution, check job_id failed,the job_id string length: %u > max string length: %d", job_id_iter->second.length(), kMaxStrLen);
+      GELOGE(PARAM_INVALID, "[Check][Job_id]Before execution, check job_id failed,the job_id string length > max string length: %d", kMaxStrLen);
       return FAILED;
     }
   }

From 1232a3365147b64f78d4d4e344f48ee2a9eb0279 Mon Sep 17 00:00:00 2001
From: "liyihan2@huawei.com" <liyihan2@huawei.com>
Date: Tue, 16 Mar 2021 11:19:10 +0800
Subject: [PATCH 7/7] analyzer log

---
 ge/analyzer/analyzer.cc | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/ge/analyzer/analyzer.cc b/ge/analyzer/analyzer.cc
index 1f733f28..d75da26e 100755
--- a/ge/analyzer/analyzer.cc
+++ b/ge/analyzer/analyzer.cc
@@ -221,7 +221,10 @@ ge::Status Analyzer::SaveAnalyzerDataToFile(uint64_t session_id, uint64_t graph_
   try {
     json_file_ << jsn.dump(kJsonDumpLevel) << std::endl;
   } catch (nlohmann::detail::type_error &e) {
-    GELOGE(FAILED, "[Json.dump][GraphInfo]json.dump to analyze file [%s] failed because [%s], session_id:%lu, graph_id:%lu", json_file_name_.c_str(), e.what(), session_id, graph_id);
+    GELOGE(FAILED, 
+           "[Json.dump][GraphInfo]json.dump to analyze file [%s] failed because [%s],
+           session_id:%lu, graph_id:%lu",
+           json_file_name_.c_str(), e.what(), session_id, graph_id);
     ret_failed = true;
   }
   json_file_.close();
@@ -241,7 +244,9 @@ ge::Status Analyzer::DoAnalyze(DataInfo &data_info) {
   GE_CHECK_NOTNULL(graph_info);
   auto status = SaveOpInfo(desc, data_info, graph_info);
   if (status != SUCCESS) {
-    GELOGE(status, "[Check][SaveOpInfo]save op info: desc_name [%s] desc_type [%s] failed!", desc->GetName().c_str(), desc->GetType().c_str());
+    GELOGE(status, 
+           "[Check][SaveOpInfo]save op info: desc_name [%s] desc_type [%s] failed!",
+           desc->GetName().c_str(), desc->GetType().c_str());
     return FAILED;
   }
   // create json file