Common log optimize

ge/analyzer/analyzer.cc

@@ -155,7 +155,7 @@ std::shared_ptr<GraphInfo> Analyzer::GetJsonObject(uint64_t session_id, uint64_t
   std::lock_guard<std::recursive_mutex> lg(mutex_);
   auto iter = graph_infos_.find(session_id);
   if (iter == graph_infos_.end()) {
-    GELOGE(PARAM_INVALID, "[Check][SessionId]session_id:%lu does not exist! graph_id:%lu.", session_id, graph_id);
+    GELOGE(PARAM_INVALID, "[Check][SessionId]session_id:%lu does not exist! graph_id:%lu", session_id, graph_id);
     return nullptr;
   } else {
     auto iter1 = (iter->second).find(graph_id);
@@ -200,7 +200,7 @@ ge::Status Analyzer::CreateAnalyzerFile() {
 }
 
 ge::Status Analyzer::SaveAnalyzerDataToFile(uint64_t session_id, uint64_t graph_id) {
-  GELOGD("start to save analyze file!");
+  GELOGD("start to save analyze file");
 
   auto graph_info = GetJsonObject(session_id, graph_id);
   GE_CHECK_NOTNULL(graph_info);
@@ -232,7 +232,7 @@ ge::Status Analyzer::SaveAnalyzerDataToFile(uint64_t session_id, uint64_t graph_
 }
 
 ge::Status Analyzer::DoAnalyze(DataInfo &data_info) {
-  GELOGD("start to do analyzer process!");
+  GELOGD("start to do analyzer process");
 
   auto pnode = data_info.node_ptr;
   GE_CHECK_NOTNULL(pnode);

ge/common/cust_aicpu_kernel_store.cc

@@ -25,7 +25,7 @@ void CustAICPUKernelStore::AddCustAICPUKernel(const CustAICPUKernelPtr &kernel)
 }
 
 void CustAICPUKernelStore::LoadCustAICPUKernelBinToOpDesc(const std::shared_ptr<ge::OpDesc> &op_desc) const {
-  GELOGD("LoadCustAICPUKernelBinToOpDesc in!");
+  GELOGD("LoadCustAICPUKernelBinToOpDesc in.");
   if (op_desc != nullptr) {
     auto kernel_bin = FindKernel(op_desc->GetName());
     if (kernel_bin != nullptr) {
@@ -34,6 +34,6 @@ void CustAICPUKernelStore::LoadCustAICPUKernelBinToOpDesc(const std::shared_ptr<
       GELOGI("Load cust aicpu kernel:%s, %zu", kernel_bin->GetName().c_str(), kernel_bin->GetBinDataSize());
     }
   }
-  GELOGD("LoadCustAICPUKernelBinToOpDesc success!");
+  GELOGD("LoadCustAICPUKernelBinToOpDesc success.");
 }
 }  // namespace ge

ge/common/dump/dump_manager.cc

@@ -56,8 +56,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status DumpManager::SetDumpConf
   dump_properties.SetDumpOpSwitch(dump_op_switch);
   if (dump_op_switch == kDumpoff && dump_config.dump_list.empty()) {
     dump_properties_map_.emplace(kInferSessionId, dump_properties);
-    GELOGE(PARAM_INVALID, "[Check][DumpList]Failed, dump_op_switch is %s.", dump_op_switch.c_str());
-    REPORT_INNER_ERROR("E19999", "Check dump list failed, dump_op_switch is %s.", dump_op_switch.c_str());
+    GELOGE(PARAM_INVALID, "Dump list is invalid, dump_op_switch is %s", dump_op_switch.c_str())
     return PARAM_INVALID;
   }
 
@@ -83,8 +82,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status DumpManager::SetDumpConf
 
   dump_path = dump_config.dump_path;
   if (dump_path.empty()) {
-    GELOGE(PARAM_INVALID, "[Check][DumpPath]Failed, it is empty.");
-    REPORT_INNER_ERROR("E19999", "Check dump path failed, it is empty.");
+    GELOGE(PARAM_INVALID, "Dump path is empty");
     return PARAM_INVALID;
   }
 

ge/common/dump/dump_op.cc

@@ -99,8 +99,7 @@ Status DumpOp::DumpOutput(aicpu::dump::Task &task) {
     }
     int64_t output_size = 0;
     if (TensorUtils::GetTensorSizeInBytes(output_descs.at(i), output_size) != SUCCESS) {
-      GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "[Get][Param]Get output size failed, output_size:%d.", output_size);
-      REPORT_INNER_ERROR("E19999", "Get output size failed, output_size:%d.", output_size);
+      GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "Get output size filed");
       return ACL_ERROR_GE_INTERNAL_ERROR;
     }
     GELOGD("Get output size in lanch dump op is %ld", output_size);
@@ -127,8 +126,7 @@ Status DumpOp::DumpInput(aicpu::dump::Task &task) {
     }
     int64_t input_size = 0;
     if (TensorUtils::GetTensorSizeInBytes(input_descs.at(i), input_size) != SUCCESS) {
-      GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "[Get][Param]Get input size failed, input_size:%d.", input_size);
-      REPORT_INNER_ERROR("E19999", "Get input size failed, input_size:%d.", input_size);
+      GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "Get output size filed");
       return ACL_ERROR_GE_INTERNAL_ERROR;
     }
     GELOGD("Get input size in lanch dump op is %ld", input_size);
@@ -153,31 +151,30 @@ Status DumpOp::ExecutorDumpOp(aicpu::dump::OpMappingInfo &op_mapping_info) {
   size_t proto_size = op_mapping_info.ByteSizeLong();
   bool ret = op_mapping_info.SerializeToString(&proto_msg);
   if (!ret || proto_size == 0) {
-    GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "[Serialize][Protobuf]Failed, proto_size:%zu.", proto_size);
-    REPORT_INNER_ERROR("E19999", "Serialize protobuf failed, proto_size:%zu.", proto_size);
+    GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "Protobuf serialize failed, proto_size is %zu", proto_size);
     return ACL_ERROR_GE_INTERNAL_ERROR;
   }
 
   rtError_t rt_ret = rtMalloc(&proto_dev_mem_, proto_size, RT_MEMORY_HBM);
   if (rt_ret != RT_ERROR_NONE) {
-    GELOGE(rt_ret, "[Malloc][ProtoDevMem]Failed, ret:0x%X", rt_ret);
+    GELOGE(rt_ret, "Call rtMalloc failed, ret:0x%X", rt_ret);
     return RT_ERROR_TO_GE_STATUS(rt_ret);
   }
 
   rt_ret = rtMemcpy(proto_dev_mem_, proto_size, proto_msg.c_str(), proto_size, RT_MEMCPY_HOST_TO_DEVICE);
   if (rt_ret != RT_ERROR_NONE) {
-    GELOGE(rt_ret, "[Copy][ProtoDevMem]Failed, ret:0x%X", rt_ret);
+    GELOGE(rt_ret, "Call rtMemcpy failed, ret:0x%X", rt_ret);
     return RT_ERROR_TO_GE_STATUS(rt_ret);
   }
 
   rt_ret = rtMalloc(&proto_size_dev_mem_, sizeof(size_t), RT_MEMORY_HBM);
   if (rt_ret != RT_ERROR_NONE) {
-    GELOGE(rt_ret, "[Malloc][ProtoSizeDevMem]Failed, ret:0x%X", rt_ret);
+    GELOGE(rt_ret, "Call rtMalloc failed, ret:0x%X", rt_ret);
     return RT_ERROR_TO_GE_STATUS(rt_ret);
   }
   rt_ret = rtMemcpy(proto_size_dev_mem_, sizeof(size_t), &proto_size, sizeof(size_t), RT_MEMCPY_HOST_TO_DEVICE);
   if (rt_ret != RT_ERROR_NONE) {
-    GELOGE(rt_ret, "[Copy][ProtoSizeDevMem]Failed, ret:0x%X", rt_ret);
+    GELOGE(rt_ret, "Call rtMemcpy failed, ret:0x%X", rt_ret);
     return RT_ERROR_TO_GE_STATUS(rt_ret);
   }
 
@@ -196,7 +193,7 @@ Status DumpOp::ExecutorDumpOp(aicpu::dump::OpMappingInfo &op_mapping_info) {
                              nullptr,  // no need smDesc
                              stream_);
   if (rt_ret != RT_ERROR_NONE) {
-    GELOGE(rt_ret, "[Call][rtCpuKernelLaunch]Failed, rt_ret:0x%X", rt_ret);
+    GELOGE(rt_ret, "Call rtCpuKernelLaunch failed,rt_ret:0x%X", rt_ret);
     return RT_ERROR_TO_GE_STATUS(rt_ret);
   }
   GELOGI("Kernel launch dump op success");
@@ -208,12 +205,12 @@ 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);
+    GELOGE(rt_ret, "Call rtGetDevice failed, ret = 0x%X, device_id = %d.", rt_ret, device_id);
     return RT_ERROR_TO_GE_STATUS(rt_ret);
   }
   if (device_id < 0) {
     GELOGE(ACL_ERROR_GE_INTERNAL_ERROR,
-           "[Check][DeviceId]Failed, device_id:%d, which should be not less than 0.",
+           "Check device_id failed, device_id = %d, which should be not less than 0.",
            device_id);
     return ACL_ERROR_GE_INTERNAL_ERROR;
   }
@@ -243,7 +240,7 @@ Status DumpOp::LaunchDumpOp() {
   if (dump_properties_.GetDumpMode() == kDumpOutput) {
     auto ret = DumpOutput(task);
     if (ret != SUCCESS) {
-      GELOGE(ret, "[Dump][Output]Failed, error_code:%u.", ret);
+      GELOGE(ret, "Dump output failed");
       return ret;
     }
     op_mapping_info.mutable_task()->Add(std::move(task));
@@ -251,7 +248,7 @@ Status DumpOp::LaunchDumpOp() {
   if (dump_properties_.GetDumpMode() == kDumpInput) {
     auto ret = DumpInput(task);
     if (ret != SUCCESS) {
-      GELOGE(ret, "[Dump][Input]Failed, error_code:%u.", ret);
+      GELOGE(ret, "Dump input failed");
       return ret;
     }
     op_mapping_info.mutable_task()->Add(std::move(task));
@@ -259,19 +256,19 @@ Status DumpOp::LaunchDumpOp() {
   if (dump_properties_.GetDumpMode() == kDumpAll || dump_properties_.IsOpDebugOpen()) {
     auto ret = DumpOutput(task);
     if (ret != SUCCESS) {
-      GELOGE(ret, "[Dump][Output]Failed when in dumping all, error_code:%u.", ret);
+      GELOGE(ret, "Dump output failed when in dumping all");
       return ret;
     }
     ret = DumpInput(task);
     if (ret != SUCCESS) {
-      GELOGE(ret, "[Dump][Input]Failed when in dumping all, error_code:%u.", ret);
+      GELOGE(ret, "Dump input failed when in dumping all");
       return ret;
     }
     op_mapping_info.mutable_task()->Add(std::move(task));
   }
   auto ret = ExecutorDumpOp(op_mapping_info);
   if (ret != SUCCESS) {
-    GELOGE(ret, "[Dump][Op]Failed, error_code:%u.", ret);
+    GELOGE(ret, "Executor dump op failed");
     return ret;
   }
   return SUCCESS;

ge/common/dump/opdebug_register.cc

@@ -27,20 +27,14 @@ 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][MemoryForOpdebug]Failed in model overflow, ret:0x%X, op_debug_mode:%u.",
-           ret, op_debug_mode);
-    REPORT_INNER_ERROR("E19999", "Malloc memory for opdebug failed in model overflow, ret:0x%X, op_debug_mode:%u.",
-                       ret, op_debug_mode);
+    GELOGE(ret, "Malloc memory for opdebug in model overflow failed, ret:0x%X", ret);
     return ret;
   }
   uint32_t debug_stream_id = 0;
   uint32_t debug_task_id = 0;
   auto rt_ret = rtDebugRegister(model_handle, op_debug_mode, op_debug_addr_, &debug_stream_id, &debug_task_id);
   if (rt_ret != RT_ERROR_NONE) {
-    GELOGE(RT_FAILED, "[Register][rtDebug]Failed in model overflow, ret: 0x%X, op_debug_mode:%u.",
-           rt_ret, op_debug_mode);
-    REPORT_INNER_ERROR("E19999", "Register rtDebug failed in model overflow, ret:0x%X, op_debug_mode:%u.",
-                       rt_ret, op_debug_mode);
+    GELOGE(RT_FAILED, "rtDebugRegister error, ret: 0x%X", rt_ret);
     return RT_ERROR_TO_GE_STATUS(rt_ret);
   }
   GELOGD("debug_task_id:%u, debug_stream_id:%u in model overflow", debug_task_id, debug_stream_id);
@@ -80,9 +74,7 @@ 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][MemoryForOpdebug]Failed in stream overflow, ret:0x%X, op_debug_mode:%u.",
-           ret, op_debug_mode);
-    REPORT_INNER_ERROR("E19999", "Malloc memory for opdebug failed in stream overflow, ret:0x%X, op_debug_mode:%u.",                       ret, op_debug_mode);
+    GELOGE(ret, "Malloc memory for opdebug in stream overflow, ret:0x%X", ret);
     return ret;
   }
 
@@ -90,10 +82,7 @@ Status OpdebugRegister::RegisterDebugForStream(rtStream_t stream, uint32_t op_de
   uint32_t debug_task_id = 0;
   auto rt_ret = rtDebugRegisterForStream(stream, op_debug_mode, op_debug_addr_, &debug_stream_id, &debug_task_id);
   if (rt_ret != RT_ERROR_NONE) {
-    GELOGE(RT_FAILED, "[Register][rtDebug]Failed in stream overflow, ret:0x%X, op_debug_mode:%u.",
-           rt_ret, op_debug_mode);
-    REPORT_INNER_ERROR("E19999", "Register rtDebug failed in stream overflow, ret:0x%X, op_debug_mode:%u.",
-                       rt_ret, op_debug_mode);
+    GELOGE(RT_FAILED, "rtDebugRegisterForStream error, ret:0x%X", rt_ret);
     return RT_ERROR_TO_GE_STATUS(rt_ret);
   }
   GELOGD("debug_task_id:%u, debug_stream_id:%u in stream overflow.", debug_task_id, debug_stream_id);
@@ -132,7 +121,7 @@ void OpdebugRegister::UnregisterDebugForStream(rtStream_t stream) {
 Status OpdebugRegister::MallocMemForOpdebug() {
   rtError_t rt_ret = rtMalloc(&op_debug_addr_, kOpDebugMemorySize, RT_MEMORY_DDR);
   if (rt_ret != RT_ERROR_NONE) {
-    GELOGE(RT_FAILED, "[Malloc][OpDebugMem]Failed, ret: 0x%X", rt_ret);
+    GELOGE(RT_FAILED, "rtMalloc error, ret: 0x%X", rt_ret);
     return RT_ERROR_TO_GE_STATUS(rt_ret);
   }
 
@@ -140,12 +129,12 @@ Status OpdebugRegister::MallocMemForOpdebug() {
   // For data dump, aicpu needs the pointer to pointer that save the real debug address.
   rt_ret = rtMalloc(&p2p_debug_addr_, kDebugP2pSize, RT_MEMORY_HBM);
   if (rt_ret != RT_ERROR_NONE) {
-    GELOGE(RT_FAILED, "[Malloc][P2PDebugMem]Failed, ret: 0x%X", rt_ret);
+    GELOGE(RT_FAILED, "rtMalloc error, ret: 0x%X", rt_ret);
     return RT_ERROR_TO_GE_STATUS(rt_ret);
   }
   rt_ret = rtMemcpy(p2p_debug_addr_, sizeof(uint64_t), &debug_addrs_tmp, sizeof(uint64_t), RT_MEMCPY_HOST_TO_DEVICE);
   if (rt_ret != RT_ERROR_NONE) {
-    GELOGE(RT_FAILED, "[Copy][P2PDebugMem]Failed, ret: 0x%X", rt_ret);
+    GELOGE(RT_FAILED, "rtMemcpy to p2p_addr, ret: 0x%X", rt_ret);
     return RT_ERROR_TO_GE_STATUS(rt_ret);
   }
 

ge/common/fmk_error_codes.cc

@@ -37,28 +37,28 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY std::string StatusFactory::GetE
   return iter_find->second;
 }
 // General error code
-DEF_ERRORNO(SUCCESS, "Success.");
-DEF_ERRORNO(FAILED, "Failed.");
+DEF_ERRORNO(SUCCESS, "Success");
+DEF_ERRORNO(FAILED, "Failed");
 
 // Common errocode
-DEF_ERRORNO(MEMALLOC_FAILED, "Failed to allocate memory.");  // 50331648
-DEF_ERRORNO(PARAM_INVALID, "Parameter's invalid.");          // 50331649
-DEF_ERRORNO(CCE_FAILED, "Failed to call CCE API.");          // 50331650
-DEF_ERRORNO(RT_FAILED, "Failed to call runtime API.");       // 50331651
-DEF_ERRORNO(INTERNAL_ERROR, "Internal errors.");              // 50331652
-DEF_ERRORNO(CSEC_ERROR, "Failed to call libc_sec API.");     // 50331653
-DEF_ERRORNO(TEE_ERROR, "Failed to call tee API.");           // 50331653
-DEF_ERRORNO(UNSUPPORTED, "Parameter's unsupported.");
-DEF_ERRORNO(OUT_OF_MEMORY, "Out of memory.");
+DEF_ERRORNO(MEMALLOC_FAILED, "Failed to allocate memory!");  // 50331648
+DEF_ERRORNO(PARAM_INVALID, "Parameter's invalid!");          // 50331649
+DEF_ERRORNO(CCE_FAILED, "Failed to call CCE API!");          // 50331650
+DEF_ERRORNO(RT_FAILED, "Failed to call runtime API!");       // 50331651
+DEF_ERRORNO(INTERNAL_ERROR, "Internal errors");              // 50331652
+DEF_ERRORNO(CSEC_ERROR, "Failed to call libc_sec API!");     // 50331653
+DEF_ERRORNO(TEE_ERROR, "Failed to call tee API!");           // 50331653
+DEF_ERRORNO(UNSUPPORTED, "Parameter's unsupported!");
+DEF_ERRORNO(OUT_OF_MEMORY, "Out of memory!");
 
 // errorcode
-DEF_ERRORNO(PARSE_MODEL_FAILED, "Failed to parse the model.");
-DEF_ERRORNO(PARSE_WEIGHTS_FAILED, "Failed to parse the weights.");
-DEF_ERRORNO(NOT_INITIALIZED, "It hasn't been initialized.");
-DEF_ERRORNO(TIMEOUT, "Running time out.");
+DEF_ERRORNO(PARSE_MODEL_FAILED, "Failed to parse the model!");
+DEF_ERRORNO(PARSE_WEIGHTS_FAILED, "Failed to parse the weights!");
+DEF_ERRORNO(NOT_INITIALIZED, "It hasn't been initialized!");
+DEF_ERRORNO(TIMEOUT, "Running time out!");
 
 // errorcode
-DEF_ERRORNO(MODEL_NOT_READY, "The model is not ready yet.");
-DEF_ERRORNO(PUSH_DATA_FAILED, "Failed to push data.");
-DEF_ERRORNO(DATA_QUEUE_ISFULL, "Data queue is full.");
+DEF_ERRORNO(MODEL_NOT_READY, "The model is not ready yet!");
+DEF_ERRORNO(PUSH_DATA_FAILED, "Failed to push data!");
+DEF_ERRORNO(DATA_QUEUE_ISFULL, "Data queue is full!");
 }  // namespace domi

ge/common/util.cc

@@ -113,11 +113,11 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromArray(const v
 
 // Get file length
 long GetFileLength(const std::string &input_file) {
-  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(input_file.empty(), return -1, "input_file path is null");
+  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(input_file.empty(), return -1, "input_file path is null.");
 
   std::string real_path = RealPath(input_file.c_str());
 
-  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(), return -1, "input_file path '%s' not valid.", input_file.c_str());
+  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(), return -1, "input_file path '%s' not valid", input_file.c_str());
   unsigned long long file_length = 0;
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(
     mmGetFileSize(input_file.c_str(), &file_length) != EN_OK,
@@ -318,7 +318,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY uint64_t GetCurrentTimestamp()
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY uint32_t GetCurrentSecondTimestap() {
   mmTimeval tv{};
   int ret = mmGetTimeOfDay(&tv, nullptr);
-  GE_LOGE_IF(ret != EN_OK, "Func gettimeofday may failed: ret=%d.", ret);
+  GE_LOGE_IF(ret != EN_OK, "Func gettimeofday may failed: ret=%d", ret);
   auto total_use_time = tv.tv_sec;  // seconds
   return static_cast<uint32_t>(total_use_time);
 }
@@ -349,7 +349,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool CheckInt64MulOverflow(int6
 }
 
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY std::string RealPath(const char *path) {
-  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(path == nullptr, return "", "path pointer is NULL");
+  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(path == nullptr, return "", "path pointer is NULL.");
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(strlen(path) >= MMPA_MAX_PATH,
                                  ErrorManager::GetInstance().ATCReportErrMessage("E19002", {"filepath", "size"},
                                                                                  {path, std::to_string(MMPA_MAX_PATH)});