log rectify

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 {
-  GELOGI("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());
     }
   }
-  GELOGI("LoadCustAICPUKernelBinToOpDesc success");
+  GELOGD("LoadCustAICPUKernelBinToOpDesc success");
 }
 }  // namespace ge

ge/common/helper/model_helper.cc

@@ -98,7 +98,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
 
   ge::Buffer model_buffer;
   (void)model_tmp->Save(model_buffer);
-  GELOGI("MODEL_DEF size is %zu", model_buffer.GetSize());
+  GELOGD("MODEL_DEF size is %zu", model_buffer.GetSize());
   if (model_buffer.GetSize() > 0) {
     if (SaveModelPartition(om_file_save_helper, ModelPartitionType::MODEL_DEF, model_buffer.GetData(),
                            model_buffer.GetSize()) != SUCCESS) {
@@ -107,7 +107,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
     }
   }
   auto ge_model_weight = ge_model->GetWeight();
-  GELOGI("WEIGHTS_DATA size is %zu, %p", ge_model_weight.GetSize(), ge_model_weight.GetData());
+  GELOGD("WEIGHTS_DATA size is %zu, %p", ge_model_weight.GetSize(), ge_model_weight.GetData());
   // weight is not necessary
   if (ge_model_weight.GetSize() > 0) {
     GE_CHK_STATUS_RET(SaveModelPartition(om_file_save_helper,
@@ -117,7 +117,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
   }
 
   TBEKernelStore tbe_kernel_store = ge_model->GetTBEKernelStore();
-  GELOGI("TBE_KERNELS size is %zu", tbe_kernel_store.DataSize());
+  GELOGD("TBE_KERNELS size is %zu", tbe_kernel_store.DataSize());
   if (tbe_kernel_store.DataSize() > 0) {
     GE_CHK_STATUS_RET(SaveModelPartition(om_file_save_helper,
                                          ModelPartitionType::TBE_KERNELS,
@@ -129,7 +129,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
   (void)tbe_kernel_store.Load(tbe_kernel_store.Data(), tbe_kernel_store.DataSize());
 
   CustAICPUKernelStore cust_aicpu_kernel_store = ge_model->GetCustAICPUKernelStore();
-  GELOGI("cust aicpu kernels size is %zu", cust_aicpu_kernel_store.DataSize());
+  GELOGD("cust aicpu kernels size is %zu", cust_aicpu_kernel_store.DataSize());
   if (cust_aicpu_kernel_store.DataSize() > 0) {
     GE_CHK_STATUS_RET(SaveModelPartition(om_file_save_helper,
                                          ModelPartitionType::CUST_AICPU_KERNELS,
@@ -155,8 +155,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
   }
   (void)model_task_def->SerializePartialToArray(task_buffer.GetData(), static_cast<int>(partition_task_size));
 
-  GELOGI("TASK_INFO op_size:%d, stream_num:%u", model_task_def->op().size(), model_task_def->stream_num());
-  GELOGI("TASK_INFO size is %zu", partition_task_size);
+  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);
 
   if (SaveModelPartition(om_file_save_helper, ModelPartitionType::TASK_INFO, task_buffer.GetData(),
                          partition_task_size) != SUCCESS) {
@@ -168,7 +168,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
   model_header.platform_type = ge_model->GetPlatformType();
   model_header.om_ir_version = ge_model->GetVersion();
   std::string platform_version = ge_model->GetPlatformVersion();
-  GELOGI("Platform version save: %s", platform_version.c_str());
 
   errno_t err;
   err = memcpy_s(model_header.platform_version, PLATFORM_VERSION_LEN, platform_version.c_str(),
@@ -178,7 +177,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
     return MEMALLOC_FAILED;
   }
   string version = reinterpret_cast<char *>(model_header.platform_version);
-  GELOGI("Platform version save: %s", version.c_str());
+  GELOGD("Platform version save: %s", version.c_str());
 
   size_t name_size = ge_model->GetName().size();
   name_size = name_size > (MODEL_NAME_LENGTH - 1) ? (MODEL_NAME_LENGTH - 1) : name_size;
@@ -188,7 +187,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
     return MEMALLOC_FAILED;
   }
   string model_name = reinterpret_cast<char *>(model_header.name);
-  GELOGI("Model name save:%s", model_name.c_str());
+  GELOGD("Model name save:%s", model_name.c_str());
 
   Status ret = om_file_save_helper->SaveModel(save_param, output_file.c_str(), model, is_offline_);
   if (ret != SUCCESS) {
@@ -346,7 +345,7 @@ Status ModelHelper::LoadModelData(OmFileLoadHelper &om_load_helper) {
   ModelPartition partition_model_def;
   // no need to check value, DATA->NetOutput
   om_load_helper.GetModelPartition(ModelPartitionType::MODEL_DEF, partition_model_def);
-  GELOGI("Model_def partition addr:%p,size:%u", partition_model_def.data, partition_model_def.size);
+  GELOGD("Model_def partition addr:%p,size:%u", partition_model_def.data, partition_model_def.size);
 
   ge::Model model;
   if (ge::Model::Load(partition_model_def.data, partition_model_def.size, model) != SUCCESS) {
@@ -376,7 +375,7 @@ Status ModelHelper::LoadWeights(OmFileLoadHelper &om_load_helper) {
   ge::Buffer weight = ge::Buffer::CopyFrom(partition.data, partition.size);
   model_->SetWeight(weight);
 
-  GELOGI("GetWeight size:%u", partition.size);
+  GELOGD("GetWeight size:%u", partition.size);
   return SUCCESS;
 }
 
@@ -393,7 +392,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadTask(Om
       GELOGE(INTERNAL_ERROR, "ReadProtoFromArray failed.");
       return INTERNAL_ERROR;
     }
-    GELOGI("TASK_INFO op_size:%d, stream_num:%u", task->op().size(), task->stream_num());
+    GELOGD("TASK_INFO op_size:%d, stream_num:%u", task->op().size(), task->stream_num());
   }
   model_->SetModelTaskDef(task);
   return SUCCESS;
@@ -404,9 +403,9 @@ Status ModelHelper::LoadTBEKernelStore(OmFileLoadHelper &om_load_helper) {
   ModelPartition partition_kernel_def;
   TBEKernelStore kernel_store;
   if (om_load_helper.GetModelPartition(ModelPartitionType::TBE_KERNELS, partition_kernel_def) == SUCCESS) {
-    GELOGI("Kernels partition size:%u", partition_kernel_def.size);
+    GELOGD("Kernels partition size:%u", partition_kernel_def.size);
     if (kernel_store.Load(partition_kernel_def.data, partition_kernel_def.size)) {
-      GELOGI("Load tbe kernels success");
+      GELOGD("Load tbe kernels success");
     } else {
       GELOGW("Load tbe kernels failed");
     }
@@ -420,11 +419,9 @@ Status ModelHelper::LoadCustAICPUKernelStore(OmFileLoadHelper &om_load_helper) {
   ModelPartition partition_kernel_def;
   CustAICPUKernelStore kernel_store;
   if (om_load_helper.GetModelPartition(ModelPartitionType::CUST_AICPU_KERNELS, partition_kernel_def) == SUCCESS) {
-    GELOGI("Kernels partition size:%u", partition_kernel_def.size);
+    GELOGD("Kernels partition size:%u", partition_kernel_def.size);
     if (kernel_store.Load(partition_kernel_def.data, partition_kernel_def.size)) {
       GELOGI("Load cust aicpu kernels success");
-    } else {
-      GELOGW("Load cust aicpu kernels failed");
     }
   }
   model_->SetCustAICPUKernelStore(kernel_store);

ge/common/helper/om_file_helper.cc

@@ -123,7 +123,7 @@ Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, const uint
     return ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID;
   }
   size_t mem_offset = SIZE_OF_MODEL_PARTITION_TABLE(*partition_table);
-  GELOGI("ModelPartitionTable num :%u, ModelFileHeader length :%zu, ModelPartitionTable length :%zu",
+  GELOGD("ModelPartitionTable num :%u, ModelFileHeader length :%zu, ModelPartitionTable length :%zu",
          partition_table->num, sizeof(ModelFileHeader), mem_offset);
   if (model_data_size <= mem_offset) {
     GELOGE(ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID, "invalid model data, partition_table->num:%u, model data size %u",
@@ -143,7 +143,7 @@ Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, const uint
       return ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID;
     }
     mem_offset += partition.size;
-    GELOGI("Partition, type:%d, size:%u", static_cast<int>(partition.type), partition.size);
+    GELOGD("Partition, type:%d, size:%u", static_cast<int>(partition.type), partition.size);
   }
   return SUCCESS;
 }
@@ -167,7 +167,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ModelPartitionTable *OmFileSave
     ModelPartition partition = context_.partition_datas_[i];
     partition_table->partition[i] = {partition.type, mem_offset, partition.size};
     mem_offset += partition.size;
-    GELOGI("Partition, type:%d, size:%u", static_cast<int>(partition.type), partition.size);
+    GELOGD("Partition, type:%d, size:%u", static_cast<int>(partition.type), partition.size);
   }
   return partition_table;
 }
@@ -191,7 +191,7 @@ Status OmFileSaveHelper::SaveModel(const SaveParam &save_param, const char *outp
   (void)save_param.pri_key_file;
   Status ret = SaveModelToFile(output_file, model, is_offline);
   if (ret == SUCCESS) {
-    GELOGI("Generate model with encrypt.");
+    GELOGD("Generate model with encrypt.");
   }
   return ret;
 }
@@ -213,7 +213,7 @@ Status OmFileSaveHelper::SaveModelToFile(const char *output_file, ModelBufferDat
   FMK_UINT32_ADDCHECK(size_of_table, model_data_len)
   model_header_.length = size_of_table + model_data_len;
 
-  GELOGI("Sizeof(ModelFileHeader):%zu,sizeof(ModelPartitionTable):%u, model_data_len:%u, model_total_len:%zu",
+  GELOGD("Sizeof(ModelFileHeader):%zu,sizeof(ModelPartitionTable):%u, model_data_len:%u, model_total_len:%zu",
          sizeof(ModelFileHeader), size_of_table, model_data_len, model_header_.length + sizeof(ModelFileHeader));
 
   std::vector<ModelPartition> partition_datas = context_.partition_datas_;
@@ -224,7 +224,7 @@ Status OmFileSaveHelper::SaveModelToFile(const char *output_file, ModelBufferDat
     ret = FileSaver::SaveToBuffWithFileHeader(model_header_, *partition_table, partition_datas, model);
   }
   if (ret == SUCCESS) {
-    GELOGI("Save model success without encrypt.");
+    GELOGD("Save model success without encrypt.");
   }
   return ret;
 #else

ge/common/kernel_store.cc

@@ -51,7 +51,7 @@ bool KernelStore::Build() {
     kernel_head.name_len = static_cast<uint32_t>(kernel->GetName().length());
     kernel_head.bin_len = static_cast<uint32_t>(kernel->GetBinDataSize());
 
-    GELOGI("get kernel bin name %s, addr %p, size %u",
+    GELOGD("get kernel bin name %s, addr %p, size %u",
            kernel->GetName().c_str(), kernel->GetBinData(), kernel->GetBinDataSize());
     mem_ret = memcpy_s(next_buffer, remain_len, &kernel_head, sizeof(kernel_head));
     GE_CHK_BOOL_EXEC_NOLOG(mem_ret == EOK, return false);
@@ -95,7 +95,7 @@ bool KernelStore::Load(const uint8_t *data, const size_t &len) {
     std::string name(next_buffer, kernel_head->name_len);
 
     next_buffer += kernel_head->name_len;
-    GELOGI("Load kernel from om:%s,%u,%u", name.c_str(), kernel_head->name_len, kernel_head->bin_len);
+    GELOGD("Load kernel from om:%s,%u,%u", name.c_str(), kernel_head->name_len, kernel_head->bin_len);
     std::vector<char> kernel_bin(next_buffer, next_buffer + kernel_head->bin_len);
     KernelBinPtr teb_kernel_ptr = ge::MakeShared<KernelBin>(name, std::move(kernel_bin));
     if (teb_kernel_ptr != nullptr) {

ge/common/model_parser/base.cc

@@ -106,7 +106,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelParserBase::ParseMo
 
     model_data = data;
     model_len = file_header->length;
-    GELOGI("Model_len is %u, model_file_head_len is %zu.", model_len, sizeof(ModelFileHeader));
+    GELOGD("Model_len is %u, model_file_head_len is %zu.", model_len, sizeof(ModelFileHeader));
   } else {
     GELOGE(ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION, "Invalid model. ModelEncryptType not supported.");
     res = ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION;

ge/common/profiling/profiling_manager.cc

@@ -558,7 +558,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::ReportPr
     GELOGE(rt_ret, "runtime get logic_device_id failed, current logic_device_id:%d", logic_device_id);
     return;
   }
-  GELOGI("current logic_device_id:%d", logic_device_id);
+  GELOGD("current logic_device_id:%d", logic_device_id);
   if (check_device) {
     auto ret = std::find(device_id_.begin(), device_id_.end(), logic_device_id);
     if (ret == device_id_.end()) {
@@ -566,11 +566,11 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::ReportPr
       return;
     }
   }
-  GELOGI("start ProfilingTaskDescInfo.");
+  GELOGD("start ProfilingTaskDescInfo.");
   ProfilingTaskDescInfo(model_id, task_desc_info, logic_device_id);
-  GELOGI("start ProfilingGraphDescInfo.");
+  GELOGD("start ProfilingGraphDescInfo.");
   ProfilingGraphDescInfo(model_id, compute_graph_desc_info, logic_device_id);
-  GELOGI("Report profiling data for GE end.");
+  GELOGD("Report profiling data for GE end.");
 #endif
 }
 
@@ -859,7 +859,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfSt
   for (int32_t i = 0; i < device_num; i++) {
     device_id_ptr[i] = static_cast<uint32_t>(device_list[i]);
   }
-  GELOGI("Runtime config param: 0x%llx, device num: %d.", module, device_num);
+  GELOGD("Runtime config param: 0x%llx, device num: %d.", module, device_num);
 
   rtError_t rt_ret = rtProfilerStart(module, device_num, device_id_ptr.get());
   if (rt_ret != RT_ERROR_NONE) {
@@ -878,7 +878,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfSt
     GELOGW("Prof start: load model module is invalid.");
   }
   UpdateDeviceIdModuleMap(kProfStart, module, device_list);
-  GELOGI("Prof start profiling success.");
+  GELOGD("Prof start profiling success.");
 #endif
   return SUCCESS;
 }
@@ -901,7 +901,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfSt
   for (int32_t i = 0; i < device_num; i++) {
     device_id_ptr[i] = static_cast<uint32_t>(device_list[i]);
   }
-  GELOGI("Prof stop: runtime config param: 0x%llx, device num: %d", module, device_num);
+  GELOGD("Prof stop: runtime config param: 0x%llx, device num: %d", module, device_num);
   rtError_t rt_ret = rtProfilerStop(module, device_num, device_id_ptr.get());
   if (rt_ret != RT_ERROR_NONE) {
     GELOGE(FAILED, "Prof stop: runtime profiler config proc failed.");
@@ -921,7 +921,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfSt
     GELOGW("Prof stop: load model module is invalid.");
   }
   UpdateDeviceIdModuleMap(kProfStop, module, device_list);
-  GELOGI("Prof stop profiling success.");
+  GELOGD("Prof stop profiling success.");
 #endif
   return SUCCESS;
 }
@@ -963,14 +963,14 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ProfilingManager::Profilin
   if (rt_ret != RT_ERROR_NONE) {
     GELOGE(rt_ret, "Runtime get logic_device_id failed, current logic_device_id:%d", logic_device_id);
   }
-  GELOGI("Current logic_device_id:%d", logic_device_id);
+  GELOGD("Current logic_device_id:%d", logic_device_id);
 
   bool execute_model_prof_on = false;
   auto iter = std::find(device_id_.begin(), device_id_.end(), logic_device_id);
   if (iter != device_id_.end()) {
     execute_model_prof_on = true;
   }
-  GELOGI("Flag is_execute_profiling: %d, execute_model_prof_on: %d", is_execute_profiling_, execute_model_prof_on);
+  GELOGD("Flag is_execute_profiling: %d, execute_model_prof_on: %d", is_execute_profiling_, execute_model_prof_on);
   return is_execute_profiling_ || execute_model_prof_on;
 }
 

ge/executor/ge_executor.cc

@@ -588,7 +588,7 @@ Status GeExecutor::LoadModel(uint32_t &model_id, const ModelData &model_data,
 }
 
 Status GeExecutor::UnloadModel(uint32_t model_id) {
-  GELOGI("unload model %u begin.", model_id);
+  GELOGD("unload model %u begin.", model_id);
   if (!isInit_) {
     GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!");
     return ACL_ERROR_GE_EXEC_NOT_INIT;
@@ -630,7 +630,6 @@ Status GeExecutor::RunModel(const ge::RunModelData &input_data, ge::RunModelData
 // Get input and output descriptor
 Status GeExecutor::GetModelDescInfo(uint32_t model_id, std::vector<ge::TensorDesc> &input_desc,
                                     std::vector<ge::TensorDesc> &output_desc, bool new_model_desc) {
-  GELOGI("get model desc info begin.");
   if (!isInit_) {
     GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!");
     return ACL_ERROR_GE_EXEC_NOT_INIT;
@@ -665,7 +664,6 @@ Status GeExecutor::GetModelDescInfo(uint32_t model_id, std::vector<ge::TensorDes
   GetGeTensorDescFromDomiInfo(input_desc, input_desc_infos, input_formats);
   GetGeTensorDescFromDomiInfo(output_desc, output_desc_infos, output_formats);
 
-  GELOGI("get model desc info end.");
   return ge::SUCCESS;
 }
 
@@ -679,7 +677,6 @@ Status GeExecutor::GetModelDescInfo(uint32_t model_id, std::vector<ge::TensorDes
 ///
 Status GeExecutor::GetDynamicBatchInfo(uint32_t model_id, std::vector<std::vector<int64_t>> &batch_info,
                                        int32_t &dynamic_type) {
-  GELOGI("Begin to get dynamic batch info.");
   if (!isInit_) {
     GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!");
     return ACL_ERROR_GE_EXEC_NOT_INIT;
@@ -690,8 +687,6 @@ Status GeExecutor::GetDynamicBatchInfo(uint32_t model_id, std::vector<std::vecto
     GELOGE(ret, "GetDynamicBatchInfo failed.");
     return ret;
   }
-
-  GELOGI("Get dynamic batch info succ.");
   return SUCCESS;
 }
 
@@ -727,7 +722,6 @@ Status GeExecutor::GetCombinedDynamicDims(uint32_t model_id, vector<vector<int64
 /// @return execute result
 ///
 Status GeExecutor::GetUserDesignateShapeOrder(uint32_t model_id, vector<string> &user_designate_shape_order) {
-  GELOGI("Begin to get user designate shape info.");
   if (!isInit_) {
     GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!");
     return ACL_ERROR_GE_EXEC_NOT_INIT;
@@ -739,7 +733,6 @@ Status GeExecutor::GetUserDesignateShapeOrder(uint32_t model_id, vector<string>
     return ret;
   }
 
-  GELOGI("Get user designate shape order succ.");
   return SUCCESS;
 }
 
@@ -782,7 +775,6 @@ Status GeExecutor::GetAippType(uint32_t model_id, uint32_t index, InputAippType
 }
 
 Status GeExecutor::GetModelAttr(uint32_t model_id, std::vector<std::string> &dynamic_output_shape_info) {
-  GELOGI("Begin to get dynamic batch output shape info");
   if (!isInit_) {
     GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!");
     return ACL_ERROR_GE_EXEC_NOT_INIT;
@@ -792,8 +784,6 @@ Status GeExecutor::GetModelAttr(uint32_t model_id, std::vector<std::string> &dyn
     GELOGE(ret, "Get dynamic batch output shape info failed.");
     return ret;
   }
-
-  GELOGI("Get dynamic batch output shape info succ.");
   return SUCCESS;
 }
 
@@ -835,8 +825,6 @@ Status GeExecutor::GetModelDescInfoForZeroCopy(uint32_t model_id, std::vector<ge
 }
 
 Status GeExecutor::CommandHandle(const Command &command) {
-  GELOGI("command handle begin.");
-
   Status ret = GraphLoader::CommandHandle(command);
   if (ret != SUCCESS) {
     GELOGE(ACL_ERROR_GE_COMMAND_HANDLE, "CommandHandle: Command Handle failed.");
@@ -904,7 +892,6 @@ Status GeExecutor::LoadDataFromFile(const std::string &path, ModelData &model_da
 */
 Status GeExecutor::LoadModelFromData(uint32_t &model_id, const ModelData &model_data, void *dev_ptr, size_t mem_size,
                                      void *weight_ptr, size_t weight_size) {
-  GELOGI("Load model from data begin.");
   if (!isInit_) {
     GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!");
     return ACL_ERROR_GE_EXEC_NOT_INIT;
@@ -945,7 +932,6 @@ Status GeExecutor::LoadModelWithQ(uint32_t &model_id, const ModelData &model_dat
 */
 Status GeExecutor::ExecModel(uint32_t model_id, void *stream, const ge::RunModelData &run_input_data,
                              ge::RunModelData &run_output_data, bool async_mode) {
-  GELOGI("Execute model begin.");
   if (!isInit_) {
     GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!");
     return ACL_ERROR_GE_EXEC_NOT_INIT;

ge/ge_local_engine/ops_kernel_store/ge_local_ops_kernel_builder.cc

@@ -111,7 +111,7 @@ Status GeLocalOpsKernelBuilder::CalcOpRunningParam(Node &ge_node) {
              TypeUtils::DataTypeToSerialString(data_type).c_str(), output_mem_size);
       return FAILED;
     }
-    GELOGI(
+    GELOGD(
         "Calc op[%s:%s] out[%zu] mem size is %ld,"
         " format=%s, data_type=%s.",
         node_name.c_str(), node_type.c_str(), i, output_mem_size, TypeUtils::FormatToSerialString(format).c_str(),
@@ -174,7 +174,7 @@ Status GeLocalOpsKernelBuilder::GenerateTask(const Node &node, RunContext &conte
     GELOGE(ret, "Node:%s(%s) op run failed.", name.c_str(), type.c_str());
     return ret;
   }
-  GELOGI("Ge local generate task for node:%s(%s) end, tasks.size()=%zu.", name.c_str(), type.c_str(), tasks.size());
+  GELOGD("Ge local generate task for node:%s(%s) end, tasks.size()=%zu.", name.c_str(), type.c_str(), tasks.size());
   return ret;
 }
 }  // namespace ge_local

ge/ge_local_engine/ops_kernel_store/op/no_op.cc

@@ -24,7 +24,7 @@ namespace ge_local {
 NoOp::NoOp(const Node &node, RunContext &run_context) : Op(node, run_context) {}
 
 Status NoOp::Run() {
-  GELOGI("Node:%s type is %s, no need generate task.", name_.c_str(), type_.c_str());
+  GELOGD("Node:%s type is %s, no need generate task.", name_.c_str(), type_.c_str());
   // Do nothing
   return SUCCESS;
 }

ge/generator/ge_generator.cc

@@ -200,7 +200,6 @@ static Status AddOutputs(const ComputeGraphPtr &graph, const NodePtr &node, cons
 }
 
 static void GetOpsProtoPath(string &opsproto_path) {
-  GELOGI("Start to get ops proto path schedule.");
   const char *path_env = std::getenv("ASCEND_OPP_PATH");
   if (path_env != nullptr) {
     string path = path_env;
@@ -383,7 +382,6 @@ bool GeGenerator::Impl::ParseVersion(const std::string &line, std::string &versi
   }
 
   version = temp.substr(pos + flag.size());
-  GELOGI("Version=%s", version.c_str());
 
   return true;
 }
@@ -425,7 +423,6 @@ bool GeGenerator::Impl::SetAtcVersionInfo(AttrHolder &obj) {
   path_base = path_base.substr(0, path_base.rfind('/') + 1);
 
   std::string version_path = path_base + "version.info";
-  GELOGI("version_path is %s", version_path.c_str());
   std::string version;
   if (!GetVersionFromPath(version_path, version)) {
     GELOGW("Get atc version information failed!");
@@ -436,7 +433,6 @@ bool GeGenerator::Impl::SetAtcVersionInfo(AttrHolder &obj) {
     GELOGW("Ge model set atc version failed!");
     return false;
   }
-  GELOGI("Ge model set atc version information success.");
   return true;
 }
 
@@ -449,7 +445,6 @@ bool GeGenerator::Impl::SetOppVersionInfo(AttrHolder &obj) {
   }
   std::string version_path = path_env;
   version_path += "/version.info";
-  GELOGI("version_path is %s", version_path.c_str());
   std::string version;
   if (!GetVersionFromPath(version_path, version)) {
     GELOGW("Get opp version information failed!");
@@ -460,7 +455,6 @@ bool GeGenerator::Impl::SetOppVersionInfo(AttrHolder &obj) {
     GELOGW("Ge model set opp version failed!");
     return false;
   }
-  GELOGI("Ge Model set opp version information success.");
   return true;
 }
 
@@ -469,7 +463,7 @@ Status GeGenerator::GenerateModel(const Graph &graph, const string &file_name_pr
   rtContext_t ctx = nullptr;
   auto rt = rtCtxGetCurrent(&ctx);
   if (rt != RT_ERROR_NONE) {
-    GELOGW("Current ctx is null.");
+    GELOGD("Current ctx is null.");
     ctx = nullptr;
   }
 
@@ -524,7 +518,6 @@ Status GeGenerator::GenerateModel(const Graph &graph, const string &file_name_pr
     (void)rtCtxSetCurrent(ctx);
   }
 
-  GELOGI("GenerateOfflineModel success.");
   return SUCCESS;
 }
 
@@ -713,7 +706,6 @@ Status GeGenerator::Impl::BuildModel(const Graph &graph, const vector<GeTensor>
     return GE_GENERATOR_GRAPH_MANAGER_ADD_GRAPH_FAILED;
   }
 
-  GELOGI("Model inputs size is %zu", inputs.size());
   graph_manager_.SetOptionsRunGraphFlag(false);
 
   static std::atomic<uint64_t> atomic_session_id(0);

ge/graph/build/graph_builder.cc

@@ -102,7 +102,6 @@ void GraphBuilder::SetOptions(const ge::GraphManagerOptions &options) {
 }
 
 Status GraphBuilder::CalcOpParam(const ge::ComputeGraphPtr &graph) {
-  GELOGI("Begin to calculate op running param.");
   GE_CHECK_NOTNULL(graph);
   auto instance_ptr = ge::GELib::GetInstance();
   if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
@@ -140,7 +139,6 @@ Status GraphBuilder::CalcOpParam(const ge::ComputeGraphPtr &graph) {
 
   auto parent_node = graph->GetParentNode();
   if (parent_node == nullptr) {
-    GELOGI("Graph[%s] do not have parent node, no need update parent node output size.", graph->GetName().c_str());
     return SUCCESS;
   }
 
@@ -189,7 +187,6 @@ Status GraphBuilder::UpdateParentNodeOutputSize(const ge::ComputeGraphPtr &graph
 
 Status GraphBuilder::Build(ComputeGraphPtr &comp_graph, std::vector<SubGraphInfoPtr> &subgraph_ptr_list,
                            GeRootModelPtr &ge_root_model_ptr, uint64_t session_id) {
-  GELOGI("Start to build model.");
   if (comp_graph == nullptr) {
     GELOGE(GE_GRAPH_PARAM_NULLPTR, "Graph build comp_graph is null.");
     return GE_GRAPH_PARAM_NULLPTR;
@@ -267,7 +264,7 @@ Status GraphBuilder::BuildForKnownShapeGraph(ComputeGraphPtr &comp_graph, std::v
   }
   GE_CHK_STATUS_RET(builder.SaveDataToModel(*model_ptr, *ge_model_ptr),
                     "Graph[%s] builder SaveDataToModel() return fail.", comp_graph->GetName().c_str());
-  GELOGI("Success to build graph[%s] model.", comp_graph->GetName().c_str());
+  GELOGD("Success to build graph[%s] model.", comp_graph->GetName().c_str());
   GE_TIMESTAMP_END(BuildSubgraph, "GraphBuilder::Build");
   return SUCCESS;
 }
@@ -306,7 +303,7 @@ Status GraphBuilder::BuildForUnknownShapeGraph(ComputeGraphPtr &comp_graph, GeMo
   }
   GE_CHK_STATUS_RET(builder.SaveDataToModel(*model_ptr, *ge_model_ptr),
                     "Graph[%s] builder SaveDataToModel() return fail.", comp_graph->GetName().c_str());
-  GELOGI("Success to build graph[%s] model.", comp_graph->GetName().c_str());
+  GELOGD("Success to build graph[%s] model.", comp_graph->GetName().c_str());
   return SUCCESS;
 }
 
@@ -542,7 +539,6 @@ Status GraphBuilder::CalcDynShapeRootGraphDataSize(const ge::OpDescPtr &op_desc)
 }
 
 Status GraphBuilder::SecondPartition(ge::ComputeGraphPtr &comp_graph, vector<ge::SubGraphInfoPtr> &subgraph_ptr_list) {
-  GELOGI("[SecondPartition] second partition.");
   GE_TIMESTAMP_START(GraphPartition2);
   auto ret = graph_partitioner_.Partition(comp_graph, GraphPartitioner::kSecondPartitioning);
   if (ret != SUCCESS) {

ge/graph/build/label_allocator.cc

@@ -33,7 +33,7 @@ Status LabelAllocator::AssignFunctionalLabels() {
   }
 
   // Add label task for sub graph.
-  GELOGI("AssignFunctionalLabels start: %s.", compute_graph_->GetName().c_str());
+  GELOGD("AssignFunctionalLabels start: %s.", compute_graph_->GetName().c_str());
   std::set<NodePtr> functional_nodes;
   for (auto graph : compute_graph_->GetAllSubgraphs()) {
     if (!CollectFunctionalNode(graph, functional_nodes)) {

ge/graph/build/logical_stream_allocator.cc

@@ -597,10 +597,10 @@ Status LogicalStreamAllocator::DoAssign(const ComputeGraphPtr &graph, const Grap
     return status;
   }
 
-  GELOGI("Subgraphs of graph %s:", graph->GetName().c_str());
+  GELOGD("Subgraphs of graph %s:", graph->GetName().c_str());
   for (const auto &subgraph : subgraphs) {
     if (subgraph != nullptr) {
-      GELOGI("subgraph: %s", subgraph->name.c_str());
+      GELOGD("subgraph: %s", subgraph->name.c_str());
     }
   }
 
@@ -664,9 +664,9 @@ Status LogicalStreamAllocator::RunPasses(const ComputeGraphPtr &graph, const vec
 
     Status status = pass->Run(graph, subgraphs, context_);
     if (status == SUCCESS) {
-      GELOGI("Stream pass %s return SUCCESS.", pass->GetName().c_str());
+      GELOGD("Stream pass %s return SUCCESS.", pass->GetName().c_str());
     } else if (status == NOT_CHANGED) {
-      GELOGI("Stream pass %s return NOT_CHANGED.", pass->GetName().c_str());
+      GELOGD("Stream pass %s return NOT_CHANGED.", pass->GetName().c_str());
     } else {
       GELOGE(status, "Stream pass %s failed.", pass->GetName().c_str());
       return status;

ge/graph/build/memory/binary_block_mem_assigner.cc

@@ -76,7 +76,7 @@ Status BinaryBlockMemAssigner::GetMemoryRanges(vector<int64_t> &range_ceils) {
   auto range_number = static_cast<size_t>(
     ceil(log(all_memory_size.back() / static_cast<double>(all_memory_size.front())) / log(kLogBase)));
   range_number = (range_number == 0) ? 1 : range_number;
-  GELOGI("Range number: %zu", range_number);
+  GELOGD("Range number: %zu", range_number);
 
   vector<vector<int64_t>> ranges(range_number);
   GE_CHK_BOOL_EXEC((range_number != 0), return PARAM_INVALID, "range_number can't be 0.");
@@ -114,7 +114,7 @@ Status BinaryBlockMemAssigner::GetMemoryRanges(vector<int64_t> &range_ceils) {
       range_ceils.push_back(range.back());
     }
   }
-  GELOGI("Range ceils: %s", ToString(range_ceils).c_str());
+  GELOGD("Range ceils: %s", ToString(range_ceils).c_str());
 
   return SUCCESS;
 }

ge/graph/build/memory/block_mem_assigner.cc

@@ -455,12 +455,11 @@ void BlockMemAssigner::GetOutAndWorkSpaceMem(vector<int64_t> &all_memory_size) {
     GetNodeWorkSpaceSize(n, temp);
     all_memory_size.insert(all_memory_size.end(), temp.begin(), temp.end());
   }
-  GELOGI("The last atomic_addr_clean node id: %ld", atomic_addr_clean_id_);
   for (const auto &pair : symbol_size_) {
     all_memory_size.emplace_back(pair.second);
   }
   sort(all_memory_size.begin(), all_memory_size.end());
-  GELOGI("All memory size: %s", ToString(all_memory_size).c_str());
+  GELOGD("All memory size: %s", ToString(all_memory_size).c_str());
 
   for (auto iter = all_memory_size.begin(); iter != all_memory_size.end();) {
     if (*iter == 0) {
@@ -495,7 +494,7 @@ size_t GetBlockSize(size_t size, const vector<int64_t> &ranges) {
 
 bool IsDirectOutputNode(const NodePtr &node, int idx) {
   if ((node != nullptr) && (node->GetOpDesc() != nullptr) && (node->GetOpDesc()->GetType() == NETOUTPUT)) {
-    GELOGI("This is netoutput node, the input node mem can not be reused");
+    GELOGD("This is netoutput node, the input node mem can not be reused");
     return true;
   }
   return false;
@@ -1219,7 +1218,7 @@ Status BlockMemAssigner::AssignOutputMemoryWithReuse(const NodePtr &node, vector
   int64_t stream_id = op_desc->GetStreamId();
   vector<int64_t> memorys_type;
   bool has_mem_type_attr = ge::AttrUtils::GetListInt(op_desc, ATTR_NAME_OUTPUT_MEM_TYPE_LIST, memorys_type);
-  GELOGI("Assign memory node[%s], output size[%zu], output memory type size[%zu]", op_desc->GetName().c_str(),
+  GELOGD("Assign memory node[%s], output size[%zu], output memory type size[%zu]", op_desc->GetName().c_str(),
          op_desc->GetOutputsSize(), memorys_type.size());
   if (has_mem_type_attr && (memorys_type.size() != op_desc->GetOutputsSize())) {
     GELOGE(INTERNAL_ERROR, "fusion: node[%s], output memory size err[outputsize:%zu, memorysize:%zu]",
@@ -1311,7 +1310,7 @@ Status BlockMemAssigner::AssignOutputMemoryWithReuse(const NodePtr &node, vector
 ///
 void BlockMemAssigner::AssignMemoryWithReuse(vector<int64_t> &ranges) {
   (void)ge::GetContext().GetOption(OPTION_EXEC_DISABLE_REUSED_MEMORY, ge_disable_reuse_mem_env_);
-  GEEVENT("Reuse memory %s", ge_disable_reuse_mem_env_ == "1" ? "close" : "open");
+  GELOGD("Reuse memory %s", ge_disable_reuse_mem_env_ == "1" ? "close" : "open");
   string op_no_reuse_mem_str;
   const char *op_no_reuse_mem = std::getenv(OP_NO_REUSE_MEM);
   GE_IF_BOOL_EXEC(op_no_reuse_mem != nullptr, op_no_reuse_mem_str = string(op_no_reuse_mem);
@@ -1337,7 +1336,7 @@ void BlockMemAssigner::AssignMemoryWithReuse(vector<int64_t> &ranges) {
     vector<bool> workspace_reuse_flag;
     GE_IF_BOOL_EXEC(!ge::AttrUtils::GetListBool(node_op_desc, kAttrNameWorkspaceReuseFlag, workspace_reuse_flag),
                     GELOGD("OP %s get workspace_reuse_flag attr failed", node_op_desc->GetName().c_str()));
-    GELOGI("Assign memory node[%s], size [temp:%zu, memory type size:%zu]", node_op_desc->GetName().c_str(),
+    GELOGD("Assign memory node[%s], size [temp:%zu, memory type size:%zu]", node_op_desc->GetName().c_str(),
            temp.size(), tvm_workspace_memory_type.size());
 
     if (has_tvm_workspace_mem_type_attr && (temp.size() != tvm_workspace_memory_type.size())) {
@@ -1628,7 +1627,7 @@ void BlockMemAssigner::ResizeMemoryBlocks() {
       memory_block->SetTailOffset(p2p_mem_offset_ - 1);
     }
   }
-  GELOGI("mem_offset_ exclude zero_copy_memory is %zu, p2p_mem_offset_ exclude zero_copy_memory is %zu.",
+  GELOGD("mem_offset_ exclude zero_copy_memory is %zu, p2p_mem_offset_ exclude zero_copy_memory is %zu.",
          mem_offset_, p2p_mem_offset_);
 }
 

ge/graph/build/memory/graph_mem_assigner.cc

@@ -117,7 +117,7 @@ Status GraphMemoryAssigner::AssignMemory() {
     return ge::FAILED;
   }
   int64_t var_size_assign = ge::VarManager::Instance(session_id)->GetVarMemSize(RT_MEMORY_HBM) - var_size_before_assign;
-  GELOGI("GraphMemoryAssigner::AssignMemory variable size = %ld", var_size_assign);
+  GELOGD("GraphMemoryAssigner::AssignMemory variable size = %ld", var_size_assign);
 
   mem_assigner_ = std::move(mem_assigner);
 
@@ -296,7 +296,6 @@ Status GraphMemoryAssigner::AssignZeroCopyMemory(map<int64_t, size_t> &mem_offse
     mem_offset[RT_MEMORY_HBM] += memory_block->Size();
     memory_block->SetTailOffset(mem_offset[RT_MEMORY_HBM] - 1);
   }
-  GELOGI("mem_offset_ include zero_copy_memory is %zu.", mem_offset[RT_MEMORY_HBM]);
 
   // set offset for zero copy nodes
   priority_assigner->SetOpMemOffset(true);
@@ -309,14 +308,13 @@ Status GraphMemoryAssigner::AssignZeroCopyMemory(map<int64_t, size_t> &mem_offse
   }
   iter->second.mem_offset_ = mem_offset[RT_MEMORY_HBM];
 
-  GELOGI("max_mem_offset:%zu, mem_offset:%zu, zero_mem_copy_size:%zu.", mem_offset[RT_MEMORY_HBM], mem_offset_tmp,
+  GELOGD("max_mem_offset:%zu, mem_offset:%zu, zero_mem_copy_size:%zu.", mem_offset[RT_MEMORY_HBM], mem_offset_tmp,
          zero_mem_copy_size);
 
   return SUCCESS;
 }
 
 Status GraphMemoryAssigner::ReAssignContinuousMemory(bool is_loop_graph) {
-  GELOGI("Begin to reassign continuous memory");
   Status ret;
   for (auto &node : compute_graph_->GetAllNodes()) {
     // Get the continuous input type of the node, default is false
@@ -387,7 +385,7 @@ Status GraphMemoryAssigner::ReAssignContinuousMemory(bool is_loop_graph) {
     }
   }
   for (auto pair : memory_offset_) {
-    GELOGI("After reassign continuous memory, memory type = %ld, memoffset = %zu.", pair.first,
+    GELOGD("After reassign continuous memory, memory type = %ld, memoffset = %zu.", pair.first,
            pair.second.mem_offset_);
   }
   return ge::SUCCESS;
@@ -834,7 +832,6 @@ Status GraphMemoryAssigner::ReAssignVirtualNodesMemory(map<string, vector<NodePt
   string max_batch_label;
   GE_CHK_STATUS_RET(GetMaxBatchLabel(mem_reuse_nodes_map, mem_reuse_model, max_batch_label),
                     "Get max batch label failed.");
-  GELOGI("The batch label of max batch virtual nodes is %s.", max_batch_label.c_str());
   PrintMemoryOffset();
   vector<size_t> nodes_mem_offset_list;
   for (auto &i_map : mem_reuse_nodes_map) {
@@ -1507,7 +1504,7 @@ ge::Status GraphMemoryAssigner::UpdateOpInputOffset(const NodePtr &node, vector<
         GE_CHK_STATUS(TensorUtils::GetDataOffset(tensor_desc, input_offset));
       }
 
-      GELOGI("%s node[%s] input[%d] is set from node[%s] out index[%lu] offset[%ld]",
+      GELOGD("%s node[%s] input[%d] is set from node[%s] out index[%lu] offset[%ld]",
              has_mem_type_attr == true ? "Fusion" : "",
              tmp_op_desc->GetName().c_str(),
              valid_input_index,

ge/graph/build/memory/hybrid_mem_assigner.cc

@@ -62,9 +62,9 @@ Status HybridMemAssigner::Assign() {
 
   std::unique_ptr<BlockMemAssigner> priority_assigner;
 
-  GELOGI("Binary-block memory size:%zu, max-block memory size:%zu", bin_mem_size, max_mem_size);
+  GELOGD("Binary-block memory size:%zu, max-block memory size:%zu", bin_mem_size, max_mem_size);
   if (bin_mem_size <= max_mem_size) {
-    GELOGI("Use binary-block memory assigner method");
+    GELOGD("Use binary-block memory assigner method");
     priority_assigner = std::move(binary_assigner);
   } else {
     GELOGI("Use max-block memory assigner method");

ge/graph/build/model_builder.cc

@@ -189,7 +189,6 @@ void ModelBuilder::SetInputIsConst(const ge::NodePtr &n) {
     GE_IF_BOOL_EXEC(peer_out_anchor == nullptr, continue);
     const auto &src_node = peer_out_anchor->GetOwnerNode();
     if (!NodeUtils::GetConstOpType(src_node, const_type)) {
-      GELOGI("Node %s:%zu, sorce node: %s Not Const", n->GetName().c_str(), index, src_node->GetName().c_str());
       continue;
     }
 
@@ -232,7 +231,6 @@ Status ModelBuilder::AdjustConstWeightSize(const ge::NodePtr &node, size_t &mem_
 
 Status ModelBuilder::SetInputOutputDesc() {
   Status ret;
-  GELOGI("Start to SetInputOutputDesc.");
 
   for (const ge::NodePtr &n : compute_graph_->GetNodes(compute_graph_->GetGraphUnknownFlag())) {
     auto node_op_desc = n->GetOpDesc();
@@ -245,7 +243,6 @@ Status ModelBuilder::SetInputOutputDesc() {
     // final graph.
     if ((GetLocalOmgContext().format == domi::DOMI_TENSOR_ND) && (!node_op_desc->HasAttr("_is_single_op")) &&
         ((node_op_desc->GetType() == DATA_TYPE) || (node_op_desc->GetType() == NETOUTPUT))) {
-      GELOGI("The node [%s] format should be set ND.", node_op_desc->GetName().c_str());
       auto inputDescsPtr = node_op_desc->GetAllInputsDescPtr();
       auto outputDescsPtr = node_op_desc->GetAllOutputsDescPtr();
       ge::Format format = ge::FORMAT_ND;
@@ -290,7 +287,7 @@ void ModelBuilder::AddNodeInputProperty() {
     vector<int64_t> src_index_list;
     for (const auto &in_data_anchor : node->GetAllInDataAnchors()) {
       auto peer_out_anchor = in_data_anchor->GetPeerOutAnchor();
-      GE_IF_BOOL_EXEC(peer_out_anchor == nullptr, GELOGW("peer_out_anchor is nullptr!"); continue);
+      GE_IF_BOOL_EXEC(peer_out_anchor == nullptr, continue);
       GE_IF_BOOL_EXEC(node_op_desc->HasAttr(MERGE_PRENODE_FLAG), continue);
 
       ge::NodePtr src_node = peer_out_anchor->GetOwnerNode();
@@ -347,7 +344,6 @@ void ModelBuilder::AddNodeInputProperty() {
 }
 
 Status ModelBuilder::AdjustInputTensorFlag() {
-  GELOGI("Start to AdjustInputTensorFlag.");
   for (const ge::NodePtr &n : compute_graph_->GetNodes(compute_graph_->GetGraphUnknownFlag())) {
     if ((n->GetType() == DATA_TYPE) || (n->GetType() == AIPP_DATA_TYPE)) {
       GELOGD("Data node: %s.", n->GetName().c_str());
@@ -441,7 +437,6 @@ Status ModelBuilder::BuildModelDef(ge::Model &model) {
                    return FAILED);
   const DumpProperties &dump_properties = PropertiesManager::Instance().GetDumpProperties(session_id_);
   bool is_op_debug = dump_properties.IsOpDebugOpen();
-  GELOGI("Get op debug:%d", is_op_debug);
   if (is_op_debug) {
     if (!ge::AttrUtils::SetBool(&model, ATTR_OP_DEBUG_FLAG, is_op_debug)) {
       GELOGE(FAILED, "SetBool of ATTR_OP_DEBUG_FLAG failed.");
@@ -608,7 +603,6 @@ Status ModelBuilder::SaveDataToModel(ge::Model &model, ge::GeModel &ge_model) {
     }
     tbe_name_set.insert(tbe_kernel->GetName());
     tbe_kernel_store_.AddTBEKernel(tbe_kernel);
-    GELOGI("Add tbe kernel bin %s", tbe_kernel->GetName().c_str());
   }
 
   for (const ge::NodePtr &n : compute_graph_->GetNodes(compute_graph_->GetGraphUnknownFlag())) {
@@ -678,7 +672,6 @@ Status ModelBuilder::PreBuildModel() {
     GELOGE(FAILED, "Graph_ is not valid.");
     return FAILED;
   }
-  GELOGI("BuildModel begin.");
 
   GE_CHK_STATUS_RET(SetInputOutputDesc(), "SetInputOutputDesc Failed!");
 

ge/graph/build/run_context.cc

@@ -140,7 +140,7 @@ void RunContextUtil::DestroyRtModelResources() noexcept {
 
 Status RunContextUtil::CreateRunContext(Model &model, const ComputeGraphPtr &graph, Buffer &buffer,
                                         const uint64_t session_id) {
-  GELOGI("Begin to Create RunContext, session_id = %lu", session_id);
+  GELOGD("Begin to Create RunContext, session_id = %lu", session_id);
   // check params
   if (graph == nullptr) {
     GELOGE(PARAM_INVALID, "CreateRunContext param graph is null. session_id=%lu", session_id);
@@ -152,21 +152,21 @@ Status RunContextUtil::CreateRunContext(Model &model, const ComputeGraphPtr &gra
     GELOGE(INTERNAL_ERROR, "Get stream_num attr from model_def failed. session_id=%lu", session_id);
     return INTERNAL_ERROR;
   }
-  GELOGI("Stream_num = %u", stream_num);
+  GELOGD("Stream_num = %u", stream_num);
 
   uint32_t event_num = 0;
   if (!AttrUtils::GetInt(&model, ATTR_MODEL_EVENT_NUM, event_num)) {
     GELOGE(INTERNAL_ERROR, "Get event_num attr from model failed. session_id=%lu", session_id);
     return INTERNAL_ERROR;
   }
-  GELOGI("Event_num = %u", event_num);
+  GELOGD("Event_num = %u", event_num);
 
   uint32_t label_num = 0;
   if (!AttrUtils::GetInt(&model, ATTR_MODEL_LABEL_NUM, label_num)) {
     GELOGE(INTERNAL_ERROR, "Get label_num attr from model failed. session_id=%lu", session_id);
     return INTERNAL_ERROR;
   }
-  GELOGI("Label_num = %u", label_num);
+  GELOGD("Label_num = %u", label_num);
 
   Status ret = CreateRtModelResources(stream_num, event_num, label_num);
   if (ret != SUCCESS) {
@@ -198,11 +198,11 @@ Status RunContextUtil::CreateRunContext(Model &model, const ComputeGraphPtr &gra
 
 void RunContextUtil::PrintMemInfo() {
   for (auto iter : mem_type_to_data_mem_base_) {
-    GELOGI("CreateRunContext: memory type = %ld, data memory base = %p", iter.first, iter.second);
+    GELOGD("CreateRunContext: memory type = %ld, data memory base = %p", iter.first, iter.second);
   }
 
   for (auto iter : mem_type_to_data_mem_size_) {
-    GELOGI("CreateRunContext: memory type = %ld, data memory size = %lu", iter.first, iter.second);
+    GELOGD("CreateRunContext: memory type = %ld, data memory size = %lu", iter.first, iter.second);
   }
 }
 

ge/graph/build/stream_allocator.cc

@@ -67,11 +67,10 @@ StreamAllocator::StreamAllocator(ComputeGraphPtr whole_graph, const Graph2SubGra
   }
 
   enable_single_stream_ = (single_stream_str == kTrueStr) ? true : false;
-  GELOGI("Enable single stream: %s.", enable_single_stream_ ? kTrueStr : kFalseStr);
+  GELOGD("Enable single stream: %s.", enable_single_stream_ ? kTrueStr : kFalseStr);
 }
 
 Status StreamAllocator::AssignLogicalStreams(const std::map<std::string, int> &max_parallel_num, bool hcom_parallel) {
-  GELOGI("Assign logical streams start.");
   GE_CHECK_NOTNULL(whole_graph_);
   GE_DUMP(whole_graph_, "BeforeAssignedLogicalStreams");
 
@@ -92,15 +91,12 @@ Status StreamAllocator::AssignLogicalStreams(const std::map<std::string, int> &m
     return status;
   }
   GE_DUMP(whole_graph_, "AfterAssignedLogicalStreams");
-  GELOGI("Assign logical streams success.");
-
   return SUCCESS;
 }
 
 // After allocating the logical stream in the graph, refresh the stream in the
 // graph and insert the synchronization node.
 Status StreamAllocator::RefreshRealStream(int64_t &stream_num, int64_t &event_num) {
-  GELOGI("RefreshRealStream start.");
   GE_CHECK_NOTNULL(whole_graph_);
   GE_DUMP(whole_graph_, "BeforeRefreshRealStream");
 
@@ -174,8 +170,7 @@ Status StreamAllocator::RefreshRealStream(int64_t &stream_num, int64_t &event_nu
     GELOGI("None of nodes need to assign stream, stream num is 0, it will cause error, so change it to 1");
     stream_num_ = 1;
   }
-  GELOGI("stream num: %ld, event num: %u.", stream_num_, event_num_);
-  GELOGI("RefreshRealStream successfully.");
+  GELOGD("stream num: %ld, event num: %u.", stream_num_, event_num_);
 
   stream_num = stream_num_;
   event_num = static_cast<int64_t>(event_num_);
@@ -1241,7 +1236,7 @@ void StreamAllocator::DumpEvents() {
 
   for (const auto &one_pair : after_refresh_stream_nodes) {
     int64_t stream_id = one_pair.first;
-    GELOGI("After RefreshRealStream: stream %ld.", stream_id);
+    GELOGD("After RefreshRealStream: stream %ld.", stream_id);
 
     for (const auto &node : one_pair.second) {
       string send_event_str;
@@ -1273,7 +1268,7 @@ Status StreamAllocator::GetMaxStreamAndTask(bool huge_stream, uint32_t &max_stre
     GELOGE(FAILED, "Get max stream and task count by rts failed.");
     return FAILED;
   }
-  GELOGI("Allowed max stream count: %u, max task count per stream: %u.", max_stream_count, max_task_count);
+  GELOGD("Allowed max stream count: %u, max task count per stream: %u.", max_stream_count, max_task_count);
 
   return SUCCESS;
 }

ge/graph/build/stream_graph_optimizer.cc

@@ -30,7 +30,7 @@ StreamGraphOptimizer::~StreamGraphOptimizer() {}
 
 void StreamGraphOptimizer::RefreshNodeId(const ComputeGraphPtr &comp_graph, Graph2SubGraphInfoList &subgraph_map) {
   size_t node_size = comp_graph->GetAllNodesSize();
-  GELOGI("Refresh placeholder and end nodeId start from node num: %zu", node_size);
+  GELOGD("Refresh placeholder and end nodeId start from node num: %zu", node_size);
   for (const auto &subgraph_pair : subgraph_map) {
     for (const auto &subgraph_info : subgraph_pair.second) {
       ComputeGraphPtr subgraph = subgraph_info->GetSubGraph();
@@ -74,8 +74,6 @@ bool StreamGraphOptimizer::IsSameStreamId(const ComputeGraphPtr &comp_graph) {
 Status StreamGraphOptimizer::OptimizeStreamedSubGraph(const ComputeGraphPtr &comp_graph,
                                                       Graph2SubGraphInfoList &subgraph_map,
                                                       struct RunContext &run_context) {
-  GELOGI("Optimize streamed subgraph start.");
-
   RefreshNodeId(comp_graph, subgraph_map);
 
   std::shared_ptr<GELib> instance = ge::GELib::GetInstance();
@@ -86,7 +84,7 @@ Status StreamGraphOptimizer::OptimizeStreamedSubGraph(const ComputeGraphPtr &com
       ComputeGraphPtr subgraph = subgraph_info->GetSubGraph();
       GE_CHECK_NOTNULL(subgraph);
 
-      GELOGI("Optimize subgraph %s", subgraph->GetName().c_str());
+      GELOGD("Optimize subgraph %s", subgraph->GetName().c_str());
 
       std::string engine_name = subgraph_info->GetEngineName();
 
@@ -128,7 +126,7 @@ Status StreamGraphOptimizer::OptimizeStreamedSubGraph(const ComputeGraphPtr &com
               subgraph->GetName().c_str(), engine_name.c_str(), graph_optimizers.size(), ret);
             return ret;
           }
-          GELOGI(
+          GELOGD(
             "[optimizeStreamedSubGraph]: optimize streamed subgraph success, subgraph: %s, engine_name: %s, graph "
             "Optimizer num: %zu!",
             subgraph->GetName().c_str(), engine_name.c_str(), graph_optimizers.size());
@@ -137,7 +135,7 @@ Status StreamGraphOptimizer::OptimizeStreamedSubGraph(const ComputeGraphPtr &com
     }
   }
 
-  GELOGI("Optimize streamed subgraph success.");
+  GELOGD("Optimize streamed subgraph success.");
   return SUCCESS;
 }
 }  // namespace ge

ge/graph/build/task_generator.cc

@@ -68,7 +68,7 @@ TaskGenerator::TaskGenerator(uint8_t *var_mem_base, uint64_t var_mem_size) {
 TaskGenerator::~TaskGenerator() {}
 
 Status TaskGenerator::GetTaskInfo(Model &model, ComputeGraphPtr &graph, uint64_t session_id, RunContext &run_context) {
-  GELOGI("Begin to Get TaskInfo. session_id=%lu", session_id);
+  GELOGD("Begin to Get TaskInfo. session_id=%lu", session_id);
   // Check params
   if (graph == nullptr) {
     GELOGE(PARAM_INVALID, "GetTaskInfo param graph is null. session_id=%lu", session_id);
@@ -120,7 +120,7 @@ Status TaskGenerator::GetTaskInfo(Model &model, ComputeGraphPtr &graph, uint64_t
     return ret;
   }
 
-  GELOGI("Get TaskInfo success. session_id=%lu", session_id);
+  GELOGD("Get TaskInfo success. session_id=%lu", session_id);
   return SUCCESS;
 }
 
@@ -232,7 +232,7 @@ Status TaskGenerator::SaveFusionNodes(map<int64_t, std::vector<NodePtr>> &fusion
       }
     }
   }
-  GELOGI("Fusion: get fusion group numbers [%zu].", fusion_nodes.size());
+  GELOGD("Fusion: get fusion group numbers [%zu].", fusion_nodes.size());
   return SUCCESS;
 }
 
@@ -575,7 +575,7 @@ Status TaskGenerator::MarkFirstAndLastOps(const vector<OpDescPtr> &ops, bool is_
       continuous_op_lists.back().emplace_back(op_desc);
     }
   }
-  GELOGI("Number of continuous node lists is %zu.", continuous_op_lists.size());
+  GELOGD("Number of continuous node lists is %zu.", continuous_op_lists.size());
 
   for (const auto &continuous_ops : continuous_op_lists) {
     map<string, std::pair<OpDescPtr, OpDescPtr>> first_and_last_ops;
@@ -846,13 +846,12 @@ Status TaskGenerator::GetFpBpIndex(const ComputeGraphPtr &graph, ProfilingPoint
 
 Status TaskGenerator::FindProfilingTaskIndex(const ComputeGraphPtr &graph, ProfilingPoint &profiling_point,
                                              vector<uint32_t> &all_reduce_nodes) const {
-  GELOGI("Start FindProfilingTaskIndex.");
   GE_CHECK_NOTNULL(graph);
   const char *profiling_mode = std::getenv(kProfilingMode);
   bool is_profiling = (profiling_mode != nullptr) || ProfilingManager::Instance().ProfilingOn() ||
                       ProfilingManager::Instance().ProfilingTrainingTraceOn();
   if (!is_profiling) {
-    GELOGW("Profiling is not open.");
+    GELOGD("Profiling is not open.");
     return SUCCESS;
   }
 

ge/graph/execute/graph_execute.cc

@@ -115,7 +115,7 @@ Status GraphExecutor::FreeInOutBuffer() {
     malloc_flag_ = false;
     return SUCCESS;
   } else {
-    GELOGI("[GraphManager] not malloc buffer.");
+    GELOGD("[GraphManager] not malloc buffer.");
     return SUCCESS;
   }
 }

ge/graph/load/graph_loader.cc

@@ -286,7 +286,7 @@ Status GraphLoader::ExecuteModel(uint32_t model_id, rtStream_t stream, bool asyn
     return ret;
   }
 
-  GELOGI("Execute model success, model_id:%u.", model_id);
+  GELOGD("Execute model success, model_id:%u.", model_id);
   return SUCCESS;
 }
 

ge/graph/load/new_model_manager/data_dumper.cc

@@ -159,7 +159,6 @@ void DataDumper::SetLoopAddr(void *global_step, void *loop_per_iter, void *loop_
 }
 
 void DataDumper::SaveDumpInput(const std::shared_ptr<Node> &node) {
-  GELOGI("Start to save data %s message", node->GetName().c_str());
   if (node != nullptr) {
     auto input_op_desc = node->GetOpDesc();
     if (input_op_desc == nullptr) {
@@ -180,7 +179,6 @@ void DataDumper::SaveDumpInput(const std::shared_ptr<Node> &node) {
             {op_desc->GetName(), {input_op_desc, dst_in_data_anchor->GetIdx(), out_data_anchor->GetIdx()}});
       }
     }
-    GELOGI("Save data message successfully");
   }
 }
 
@@ -218,7 +216,7 @@ void DataDumper::SaveDumpOpInfo(const RuntimeParam &model_param, const OpDescPtr
       GELOGW("Get input size failed");
       return;
     }
-    GELOGI("Save dump op info, the input size is %ld", input_size);
+    GELOGD("Save dump op info, the input size is %ld", input_size);
     op_desc_info.input_size.emplace_back(input_size);
   }
   for (size_t j = 0; j < op->GetOutputsSize(); ++j) {
@@ -234,7 +232,7 @@ void DataDumper::SaveDumpOpInfo(const RuntimeParam &model_param, const OpDescPtr
       GELOGW("Get input size failed");
       return;
     }
-    GELOGI("Save dump op info, the output size is %ld", output_size);
+    GELOGD("Save dump op info, the output size is %ld", output_size);
     op_desc_info.output_size.emplace_back(output_size);
   }
   op_desc_info.input_addrs = ModelUtils::GetInputDataAddrs(model_param, op);
@@ -301,22 +299,16 @@ static void SetOpMappingLoopAddr(uintptr_t step_id, uintptr_t loop_per_iter, uin
   if (step_id != 0) {
     GELOGI("step_id exists.");
     op_mapping_info.set_step_id_addr(static_cast<uint64_t>(step_id));
-  } else {
-    GELOGI("step_id is null.");
   }
 
   if (loop_per_iter != 0) {
     GELOGI("loop_per_iter exists.");
     op_mapping_info.set_iterations_per_loop_addr(static_cast<uint64_t>(loop_per_iter));
-  } else {
-    GELOGI("loop_per_iter is null.");
   }
 
   if (loop_cond != 0) {
     GELOGI("loop_cond exists.");
     op_mapping_info.set_loop_cond_addr(static_cast<uint64_t>(loop_cond));
-  } else {
-    GELOGI("loop_cond is null.");
   }
 }
 
@@ -672,7 +664,7 @@ Status DataDumper::LoadDumpInfo() {
   PrintCheckLog(dump_list_key);
 
   if (op_list_.empty()) {
-    GELOGW("op_list_ is empty");
+    GELOGD("op_list_ is empty");
   }
 
   aicpu::dump::OpMappingInfo op_mapping_info;
@@ -684,8 +676,6 @@ Status DataDumper::LoadDumpInfo() {
   op_mapping_info.set_flag(kAicpuLoadFlag);
   op_mapping_info.set_dump_step(dump_properties_.GetDumpStep());
   SetOpMappingLoopAddr(global_step_, loop_per_iter_, loop_cond_, op_mapping_info);
-  GELOGI("Dump step is %s and dump path is %s dump model is %s in load dump info",
-         dump_properties_.GetDumpStep().c_str(), dump_path.c_str(), dump_list_key.c_str());
   auto ret = BuildTaskInfo(op_mapping_info);
   if (ret != SUCCESS) {
     GELOGE(ret, "Build task info failed");
@@ -812,7 +802,6 @@ void DataDumper::SetOpDebugIdToAicpu(uint32_t task_id, uint32_t stream_id, void
 
 Status DataDumper::UnloadDumpInfo() {
   if (!load_flag_) {
-    GELOGI("No need to UnloadDumpInfo.");
     load_flag_ = false;
     return SUCCESS;
   }
@@ -838,7 +827,6 @@ Status DataDumper::UnloadDumpInfo() {
 void DataDumper::PrintCheckLog(string &dump_list_key) {
   std::set<std::string> model_list = dump_properties_.GetAllDumpModel();
   if (model_list.empty()) {
-    GELOGI("No model need dump.");
     return;
   }
 

ge/graph/load/new_model_manager/davinci_model.cc

@@ -202,7 +202,6 @@ DavinciModel::~DavinciModel() {
 
     OpDebugUnRegister();
 
-    GELOGI("do ReleaseTask");
     ReleaseTask();
     CleanTbeHandle();
 
@@ -333,7 +332,6 @@ Status DavinciModel::InitModelMem(void *dev_ptr, size_t mem_size, void *weight_p
     GELOGI("[IMAS]InitModelMem graph_%u MallocMemory type[W] memaddr[%p] mem_size[%zu]", runtime_param_.graph_id,
            weights_mem_base_, weights_size);
     GE_CHK_RT_RET(rtMemcpy(weights_mem_base_, weights_size, weights.GetData(), weights_size, RT_MEMCPY_HOST_TO_DEVICE));
-    GELOGI("copy weights data to device");
   }
 
   GE_CHK_STATUS_RET(InitVariableMem(), "Init variable memory failed.");
@@ -484,7 +482,7 @@ Status DavinciModel::SetTSDevice() {
   int64_t value = 0;
   bool ret = ge::AttrUtils::GetInt(ge_model_, ATTR_MODEL_CORE_TYPE, value);
   uint32_t core_type = ret ? static_cast<uint32_t>(value) : 0;
-  GELOGI("SetTSDevice: %u", core_type);
+  GELOGD("SetTSDevice: %u", core_type);
   rtError_t rt_ret = rtSetTSDevice(core_type);
   if (rt_ret != RT_ERROR_NONE) {
     GELOGE(RT_FAILED, "SetTSDevice failed, ret: 0x%X", rt_ret);
@@ -539,7 +537,6 @@ Status DavinciModel::OpDebugRegister() {
 }
 
 void DavinciModel::OpDebugUnRegister() {
-  GELOGI("OpDebugUnRegister, is_op_debug_reg_ = %d", is_op_debug_reg_);
   if (is_op_debug_reg_) {
     debug_reg_mutex_.unlock();
     rtError_t rt_ret = RT_ERROR_NONE;
@@ -644,7 +641,7 @@ Status DavinciModel::Init(void *dev_ptr, size_t mem_size, void *weight_ptr, size
   GE_CHK_STATUS_RET(TransVarDataUtils::CopyVarData(compute_graph, session_id_, device_id_), "copy var data failed.");
 
   GE_TIMESTAMP_START(InitModelMem);
-  GELOGI("Known node is %d", known_node_);
+  GELOGD("Known node is %d", known_node_);
   if (!known_node_) {
     GE_CHK_STATUS_RET_NOLOG(InitModelMem(dev_ptr, mem_size, weight_ptr, weight_size));
     data_inputer_ = new (std::nothrow) DataInputer();
@@ -704,7 +701,6 @@ Status DavinciModel::Init(void *dev_ptr, size_t mem_size, void *weight_ptr, size
   }
 
   Shrink();
-  GELOGI("Davinci model init success.");
   return ret;
 }
 
@@ -972,7 +968,7 @@ Status DavinciModel::InitDataOp(const NodePtr &node, uint32_t &data_op_index, ma
   }
   auto data_index = data_op_index;
   if (AttrUtils::GetInt(op_desc, ATTR_NAME_INDEX, data_index)) {
-    GELOGI("ge_train: get new index %u, old %u", data_index, data_op_index);
+    GELOGD("ge_train: get new index %u, old %u", data_index, data_op_index);
   }
   bool fusion_flag = false;
   ZeroCopyOffset zero_copy_offset;
@@ -995,7 +991,6 @@ Status DavinciModel::InitDataOp(const NodePtr &node, uint32_t &data_op_index, ma
     new_input_outside_addrs_[addr] = zero_copy_offset;
   }
 
-  GELOGI("SetInputOutsideAddr success.");
   data_op_index++;
   if (InitInputZeroCopyNodes(node) != SUCCESS) {
     GELOGE(PARAM_INVALID, "Input zero copy nodes init failed!");
@@ -1130,7 +1125,6 @@ Status DavinciModel::InitNetOutput(const NodePtr &node) {
       DisableZeroCopy(real_addr);
       real_virtual_addrs_.insert(real_addr);
     }
-    GELOGI("SetOutputOutsideAddr success.");
   }
 
   GE_IF_BOOL_EXEC(InitOutputZeroCopyNodes(node) != SUCCESS,
@@ -1146,8 +1140,6 @@ Status DavinciModel::InitNetOutput(const NodePtr &node) {
     GE_IF_BOOL_EXEC(GetGearAndRealOutShapeInfo(input_count, op_desc) != SUCCESS,
                     GELOGE(PARAM_INVALID, "Failed to get gear and real out shape info."); return PARAM_INVALID;);
   }
-
-  GELOGI("DavinciModel::InitNetoutput success.");
   return SUCCESS;
 }
 
@@ -1967,7 +1959,6 @@ void DavinciModel::GetModelAttr(std::vector<std::string> &dynamic_output_shape_i
     if (op->GetType() != NETOUTPUT) {
       continue;
     }
-    GELOGI("Start to get dynamic output dims attr");
     if (!AttrUtils::GetListStr(op, ATTR_NAME_DYNAMIC_OUTPUT_DIMS, dynamic_output_shape_info)) {
       GELOGD("Can not get dynamic output dims attr");
     }
@@ -2123,7 +2114,7 @@ void DavinciModel::CreateOutput(uint32_t index, OpDescPtr &op_desc, InputOutputD
 }
 
 Status DavinciModel::GetOutputDescInfo(vector<InputOutputDescInfo> &output_desc, std::vector<uint32_t> &formats) {
-  GELOGI("Output node size: %zu", output_op_list_.size());
+  GELOGD("Output node size: %zu", output_op_list_.size());
   for (size_t i = 0; i < output_op_list_.size(); i++) {
     auto &op_desc = output_op_list_[i];
     uint32_t out_size = static_cast<uint32_t>(op_desc->GetInputsSize());
@@ -2234,8 +2225,6 @@ Status DavinciModel::SinkModelProfile() {
   Msprof::Engine::Reporter *reporter = PluginImpl::GetPluginReporter();
   GE_IF_BOOL_EXEC(reporter == nullptr, GELOGI("Profiling report is nullptr!"); return SUCCESS);
 
-  GELOGI("Start collect model load profiling data.");
-
   Msprof::Engine::ReporterData reporter_data{};
   // report model data tag name
   std::string tag_name;
@@ -2293,7 +2282,6 @@ Status DavinciModel::SinkModelProfile() {
       uint32_t op_num = fusion_op_info->original_op_names.size();
       uint32_t task_id = task->GetTaskID();
       if (op_num > 0) {
-        GELOGI("task.id = %u, opNum = %u", task_id, op_num);
         op_id_map.insert(std::make_pair(fusion_op_info->op_index, task_id));
       }
     }
@@ -3155,7 +3143,6 @@ Status DavinciModel::DistributeTask() {
   }
 
   const auto &model_task_def = ge_model_->GetModelTaskDefPtr();
-  GELOGI("there are %zu task need to save.", task_list_.size());
   for (size_t task_index = 0; task_index < task_list_.size(); ++task_index) {
     auto &task = task_list_.at(task_index);
     GE_CHK_STATUS_RET(task->Distribute(), "Task[%zu] distribute fail", task_index);
@@ -3588,12 +3575,12 @@ Status DavinciModel::InitTbeHandle(const OpDescPtr &op_desc) {
   if (rtQueryFunctionRegistered(bin_file_key) != RT_ERROR_NONE) {
     void *bin_handle = nullptr;
     if (!kernel_store.FindTBEHandle(bin_file_key, bin_handle)) {
-      GELOGI("TBE: can't find the kernel_name[%s] in HandleMap", bin_file_key);
+      GELOGD("TBE: can't find the kernel_name[%s] in HandleMap", bin_file_key);
 
       rtDevBinary_t binary;
       std::string json_string;
       GE_IF_BOOL_EXEC(AttrUtils::GetStr(op_desc, TVM_ATTR_NAME_MAGIC, json_string),
-                      GELOGI("Get original type of session_graph_id."));
+                      GELOGD("Get original type of session_graph_id."));
       if (json_string == "RT_DEV_BINARY_MAGIC_ELF_AICPU") {
         binary.magic = RT_DEV_BINARY_MAGIC_ELF_AICPU;
       } else if (json_string == "RT_DEV_BINARY_MAGIC_ELF") {
@@ -3609,13 +3596,13 @@ Status DavinciModel::InitTbeHandle(const OpDescPtr &op_desc) {
       binary.data = tbe_kernel->GetBinData();
       binary.length = tbe_kernel->GetBinDataSize();
 
-      GELOGI("TBE: binary.length: %lu", binary.length);
+      GELOGD("TBE: binary.length: %lu", binary.length);
       GE_CHK_RT_RET(rtDevBinaryRegister(&binary, &bin_handle));
 
       std::string meta_data;
       GE_IF_BOOL_EXEC(AttrUtils::GetStr(op_desc, TVM_ATTR_NAME_METADATA, meta_data),
                       GELOGI("Get original type of json_string"));
-      GELOGI("TBE: meta data: %s", meta_data.empty() ? "null" : meta_data.c_str());
+      GELOGD("TBE: meta data: %s", meta_data.empty() ? "null" : meta_data.c_str());
       GE_IF_BOOL_EXEC(!meta_data.empty(), GE_CHK_RT_RET(rtMetadataRegister(bin_handle, meta_data.c_str())));
 
       kernel_store.StoreTBEHandle(bin_file_key, bin_handle, tbe_kernel);
@@ -3626,8 +3613,7 @@ Status DavinciModel::InitTbeHandle(const OpDescPtr &op_desc) {
 
     std::string kernel_name;
     GE_IF_BOOL_EXEC(AttrUtils::GetStr(op_desc, op_desc->GetName() + "_kernelname", kernel_name),
-                    GELOGI("Get original type of kernel_name"));
-    GELOGI("TBE: binfile_key=%s, kernel_name=%s", bin_file_key, kernel_name.c_str());
+                    GELOGD("Get original type of kernel_name"));
     GE_CHK_RT_RET(rtFunctionRegister(bin_handle, bin_file_key, bin_file_key, kernel_name.c_str(), 0));
     used_tbe_handle_map_[bin_file_key] = 1;  // Init used num to 1.
     return SUCCESS;
@@ -3822,7 +3808,7 @@ Status DavinciModel::InitModelStream(rtStream_t stream) {
 Status DavinciModel::NnExecute(rtStream_t stream, bool async_mode, const InputData &input_data,
                                OutputData &output_data) {
   is_async_mode_ = async_mode;
-  GELOGI("Model Run begin, model id:%u, data index:%u, flag:%d.", model_id_, input_data.index, is_async_mode_);
+  GELOGD("Model Run begin, model id:%u, data index:%u, flag:%d.", model_id_, input_data.index, is_async_mode_);
   GE_CHK_STATUS_RET(InitModelStream(stream), "Init model stream failed.");
   is_dynamic_ = input_data.is_dynamic_batch;
   if (!is_dynamic_) {
@@ -3834,7 +3820,7 @@ Status DavinciModel::NnExecute(rtStream_t stream, bool async_mode, const InputDa
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ret != SUCCESS, return ret, "Copy input data to model failed. model id: %u",
                                  model_id_);
 
-  GELOGI("current_data.index=%u", input_data.index);
+  GELOGD("current_data.index=%u", input_data.index);
   GE_IF_BOOL_EXEC(ProfilingManager::Instance().ProfilingModelExecuteOn(), SetProfileTime(MODEL_PRE_PROC_END));
 
   if (!task_list_.empty()) {
@@ -3843,7 +3829,7 @@ Status DavinciModel::NnExecute(rtStream_t stream, bool async_mode, const InputDa
     rtError_t rt_ret = rtModelExecute(rt_model_handle_, rt_model_stream_, 0);
     GE_CHK_RT_EXEC(rt_ret, return RT_ERROR_TO_GE_STATUS(rt_ret));
     GE_IF_BOOL_EXEC(ProfilingManager::Instance().ProfilingModelExecuteOn(), SetProfileTime(MODEL_INFER_END));
-    GELOGI("rtModelExecute end");
+    GELOGD("rtModelExecute end");
   }
 
   if (!is_async_mode_) {
@@ -3855,7 +3841,7 @@ Status DavinciModel::NnExecute(rtStream_t stream, bool async_mode, const InputDa
 
   // report model time data
   GE_IF_BOOL_EXEC(ProfilingManager::Instance().ProfilingModelExecuteOn(), (void)SinkTimeProfile(input_data));
-  GELOGI("Model run end, model id:%u", model_id_);
+  GELOGD("Model run end, model id:%u", model_id_);
   return SUCCESS;
 }
 
@@ -4009,7 +3995,6 @@ void DavinciModel::FreeWeightsMem() {
 }
 
 Status DavinciModel::TransAllVarData(ComputeGraphPtr &graph, uint32_t graph_id) {
-  GELOGI("TransAllVarData start: session_id:%lu, graph_id: %u.", session_id_, graph_id);
   rtContext_t ctx = nullptr;
   rtError_t rt_ret = rtCtxGetCurrent(&ctx);
   if (rt_ret != RT_ERROR_NONE) {
@@ -4030,13 +4015,10 @@ Status DavinciModel::TransAllVarData(ComputeGraphPtr &graph, uint32_t graph_id)
 
   GE_CHK_STATUS_RET_NOLOG(
       TransVarDataUtils::TransAllVarData(variable_node_list, session_id_, ctx, graph_id, kThreadNum));
-
-  GELOGI("TransAllVarData success.");
   return SUCCESS;
 }
 
 void DavinciModel::SetDataDumperArgs(const ComputeGraphPtr &compute_graph) {
-  GELOGI("set data dumper args, name: %s, id: %u.", name_.c_str(), model_id_);
   data_dumper_.SetModelName(name_);
   data_dumper_.SetModelId(model_id_);
   data_dumper_.SetOmName(om_name_);
@@ -4062,15 +4044,13 @@ void DavinciModel::SetDataDumperArgs(const ComputeGraphPtr &compute_graph) {
       }
       return v_output_addr[0];
     }
-    GELOGW("op is null.");
+    GELOGD("op is null.");
     return nullptr;
   };
 
   data_dumper_.SetLoopAddr(get_var_addr(GetVariableOp(NODE_NAME_GLOBAL_STEP), runtime_param_),
                            get_var_addr(GetVariableOp(NODE_NAME_FLOWCTRL_LOOP_PER_ITER), runtime_param_),
                            get_var_addr(GetVariableOp(NODE_NAME_FLOWCTRL_LOOP_COND), runtime_param_));
-
-  GELOGI("SetDataDumperArgs end.");
 }
 
 uint32_t DavinciModel::GetFlowctrlIndex(uint32_t op_index) {
@@ -4089,7 +4069,6 @@ void DavinciModel::SaveHcclFollowStream(int64_t main_stream_id, rtStream_t strea
 }
 
 Status DavinciModel::GetComputeGraphInfo(vector<ComputeGraphDescInfo> &graph_desc_info) {
-  GELOGI("GetComputeGraphInfo start.");
   auto &all_op_desc = data_dumper_.GetAllOpDescInfo();
   for (auto &op_desc : all_op_desc) {
     ComputeGraphDescInfo compute_graph_info;
@@ -4109,7 +4088,6 @@ Status DavinciModel::GetComputeGraphInfo(vector<ComputeGraphDescInfo> &graph_des
 
     graph_desc_info.emplace_back(compute_graph_info);
   }
-  GELOGI("GetComputeGraphInfo end.");
   return SUCCESS;
 }
 

ge/graph/load/new_model_manager/model_manager.cc

@@ -202,7 +202,6 @@ void ModelManager::DestroyAicpuSession(uint64_t session_id) {
 }
 
 ge::Status ModelManager::DestroyAicpuSessionForInfer(uint32_t model_id) {
-  GELOGI("Destroy aicpu session for infer, model id is %u.", model_id);
   std::lock_guard<std::mutex> lock(map_mutex_);
   auto it = model_map_.find(model_id);
   if (it == model_map_.end()) {
@@ -210,7 +209,6 @@ ge::Status ModelManager::DestroyAicpuSessionForInfer(uint32_t model_id) {
     return GE_EXEC_MODEL_ID_INVALID;
   }
   uint64_t session_id = it->second->GetSessionId();
-  GELOGI("Destroy aicpu session for infer, session id is %lu.", session_id);
   DestroyAicpuSession(session_id);
   return SUCCESS;
 }
@@ -1213,7 +1211,7 @@ Status ModelManager::ExecuteModel(uint32_t model_id, rtStream_t stream, bool asy
 
   Status status = davinci_model->NnExecute(stream, async_mode, input_data, output_data);
   if (status == SUCCESS) {
-    GELOGI("Execute model %u success.", model_id);
+    GELOGD("Execute model %u success.", model_id);
   }
 
   return status;
@@ -1270,7 +1268,6 @@ Status ModelManager::LoadCustAicpuSo(const OpDescPtr &op_desc, const string &so_
 }
 
 Status ModelManager::LaunchKernelCustAicpuSo(const string &kernel_name) {
-  GELOGI("LaunchCustAucpuSo in, kernel name %s", kernel_name.c_str());
   std::lock_guard<std::mutex> lock(cust_aicpu_mutex_);
   if (cust_aicpu_so_.size() == 0) return SUCCESS;
   // get current context

ge/graph/load/new_model_manager/model_utils.cc

@@ -337,9 +337,7 @@ vector<void *> ModelUtils::GetInputDataAddrs(const RuntimeParam &model_param, Co
       continue;
     }
 
-    GE_IF_BOOL_EXEC(non_const_index >= v_input_offset.size(),
-                    GELOGW("offsets=%zu, inputs=%zu, index=%zu.", v_input_offset.size(), inputs_size, non_const_index);
-                    break);
+    GE_IF_BOOL_EXEC(non_const_index >= v_input_offset.size(), break);
 
     int64_t input_offset = v_input_offset[non_const_index];
     non_const_index++;

ge/graph/load/new_model_manager/task_info/kernel_task_info.cc

@@ -178,7 +178,7 @@ void KernelTaskInfo::UpdateTaskId() {
     }
     task_id_ = task_id;
     stream_id_ = stream_id;
-    GELOGI("UpdateTaskId:UpdateTaskId [%u], stream id [%u]:", task_id, stream_id);
+    GELOGD("UpdateTaskId:UpdateTaskId [%u], stream id [%u]:", task_id, stream_id);
   }
 }
 
@@ -382,7 +382,7 @@ Status KernelTaskInfo::Distribute() {
     call_save_dump_ = true;
   } else {
     /* default: not skt launch */
-    GELOGI(
+    GELOGD(
         "KernelTaskInfo Distribute Start, sktenable:%d taskid:%u sktid:%u last_sktid:%u stubfunc_name:%s "
         "stubfunc:%p blockdim:%u stream:%p",
         call_skt, task_id_, skt_id_, skt_info_.last_task_id, stub_func_name_.c_str(), stub_func_, block_dim_, stream_);
@@ -409,7 +409,7 @@ Status KernelTaskInfo::Distribute() {
   }
   // set for task_id_
   UpdateTaskId();
-  GELOGI(
+  GELOGD(
       "KernelTaskInfo Distribute Success. sktenable:%d taskid:%d sktid:%d stubfunc_name:%s stubfunc:%p "
       "blockdim:%d stream:%p",
       call_skt, task_id_, skt_id_, stub_func_name_.c_str(), stub_func_, block_dim_, stream_);

ge/graph/load/new_model_manager/zero_copy_offset.cc

@@ -39,20 +39,18 @@ Status ZeroCopyOffset::InitInputDataInfo(int64_t output_size, void *virtual_addr
   (void)ge::AttrUtils::GetListInt(op_desc, ATTR_ZERO_COPY_RELATIVE_OFFSET, zero_copy_relative_offset_);
   GE_CHK_BOOL_EXEC(zero_copy_basic_offset_.size() == zero_copy_relative_offset_.size(), return PARAM_INVALID,
                    "basic_offset_size should be equal to relative_offset_size");
-  GELOGI("[ZCPY] zero_copy_basic_offset size is %zu", zero_copy_basic_offset_.size());
+  GELOGD("[ZCPY] zero_copy_basic_offset size is %zu", zero_copy_basic_offset_.size());
 
   int64_t virtual_addr_offset = op_desc->GetOutputOffset().at(kDataIndex);
-  GELOGI("virtual_addr_offset is %ld.", virtual_addr_offset);
   IsL2Fusion(zero_copy_basic_offset_, virtual_addr_offset, fusion_flag);
 
   uint32_t out_count = 0;
   data_size_ = output_size;
   if (!fusion_flag) {
-    GELOGI("[ZCPY] %s not set l2_fusion.", op_desc->GetName().c_str());
     out_count++;
     data_info_.emplace_back(output_size, virtual_addr);
     relative_offset_.emplace_back(0);
-    GELOGI("[ZCPY] %s size is %ld, virtual_addr is %p.", op_desc->GetName().c_str(), output_size, virtual_addr);
+    GELOGD("[ZCPY] %s size is %ld, virtual_addr is %p.", op_desc->GetName().c_str(), output_size, virtual_addr);
   } else {
     GELOGI("[ZCPY] set l2_fusion for %s.", op_desc->GetName().c_str());
     for (size_t index = 0; index < zero_copy_basic_offset_.size(); ++index) {
@@ -73,7 +71,6 @@ Status ZeroCopyOffset::InitInputDataInfo(int64_t output_size, void *virtual_addr
 Status ZeroCopyOffset::InitOutputDataInfo(const vector<int64_t> &input_size_list,
                                           const vector<void *> &virtual_addr_list, const OpDescPtr &op_desc,
                                           const size_t &idx, bool &fusion_flag) {
-  GELOGI("[ZCPY] Start to InitOutputDataInfo of %s.", op_desc->GetName().c_str());
   int64_t size = input_size_list[idx];
   auto tensor_desc = op_desc->GetInputDescPtr(idx);
   GE_CHECK_NOTNULL(tensor_desc);
@@ -82,7 +79,7 @@ Status ZeroCopyOffset::InitOutputDataInfo(const vector<int64_t> &input_size_list
     return FAILED;
   }
 
-  GELOGI("Tensor data size: GetSize=%ld, GetTensorSizeInBytes=%ld", input_size_list[idx], size);
+  GELOGD("Tensor data size: GetSize=%ld, GetTensorSizeInBytes=%ld", input_size_list[idx], size);
 
   basic_addr_ = virtual_addr_list[idx];
   (void)ge::AttrUtils::GetListInt(op_desc, ATTR_ZERO_COPY_BASIC_OFFSET, zero_copy_basic_offset_);
@@ -90,13 +87,11 @@ Status ZeroCopyOffset::InitOutputDataInfo(const vector<int64_t> &input_size_list
   GE_CHK_BOOL_EXEC(zero_copy_basic_offset_.size() == zero_copy_relative_offset_.size(), return PARAM_INVALID,
                    "basic_offset_size should be equal to relative_offset_size");
   int64_t virtual_addr_offset = op_desc->GetInputOffset().at(idx);
-  GELOGI("virtual_addr_offset is %ld.", virtual_addr_offset);
   IsL2Fusion(zero_copy_basic_offset_, virtual_addr_offset, fusion_flag);
 
   uint32_t in_count = 0;
   data_size_ = size;
   if (!fusion_flag) {
-    GELOGI("[ZCPY] %s not set l2-fusion.", op_desc->GetName().c_str());
     in_count++;
     data_info_.emplace_back(size, virtual_addr_list[idx]);
     // op_desc not set l2fusion when fusion_flag is false
@@ -132,10 +127,8 @@ void ZeroCopyOffset::IsL2Fusion(const vector<int64_t> &fusion_basic_addrs, const
 
 void ZeroCopyOffset::SetInputOutsideAddrs(const vector<int64_t> &output_offset_list, void *addr, const size_t &index,
                                           bool fusion_flag, std::set<const void *> &real_virtual_addrs) {
-  GELOGI("[ZCPY] Start to SetInputOutsideAddrs for virtual_addr %p.", addr);
   uint32_t out_count = 0;
   if (!fusion_flag) {
-    GELOGI("[ZCPY] not set l2-fusion for virtual_adr %p.", addr);
     out_count++;
     std::map<const void *, std::vector<void *>> addr_mapping;
     addr_mapping[addr] = {};
@@ -165,7 +158,6 @@ void ZeroCopyOffset::SetOutputOutsideAddrs(const int64_t &input_offset, const bo
   GELOGI("[ZCPY] Start to SetOutputOutsideAddrs for virtual_addr %p.", addr);
   uint32_t out_count = 0;
   if (!fusion_flag) {
-    GELOGI("[ZCPY] not set l2-fusion for virtual_addr %p.", addr);
     out_count++;
     std::map<const void *, std::vector<void *>> addr_mapping;
     addr_mapping[addr] = {};
@@ -199,7 +191,7 @@ bool ZeroCopyOffset::SetOutsideAddrsValue(ZeroCopyTask &zero_copy_task, void *ou
       GE_CHK_STATUS(zero_copy_task.SetTaskArgsOffset(addr_val, offset), "Input args invalid.");
       void *args_val = static_cast<uint8_t *>(args) + offset;
       args_addrs->second.push_back(args_val);
-      GELOGI("[ZCPY] set copy input: virtual_addr: 0x%lx, task_addr: %p, args: %p, offset: %zu.", addr_val, args_val,
+      GELOGD("[ZCPY] set copy input: virtual_addr: 0x%lx, task_addr: %p, args: %p, offset: %zu.", addr_val, args_val,
              args, offset);
       set_batch_label_flag = true;
     }

ge/graph/load/new_model_manager/zero_copy_task.cc

@@ -49,7 +49,7 @@ Status ZeroCopyTask::SetTaskArgsOffset(uintptr_t addr, size_t offset) {
     it->second.insert(offset);
   }
 
-  GELOGI("[ZCPY] %s set task, virtual_addr: 0x%lx, args_addr: %p, size: %zu, offset: %zu", name_.c_str(), addr,
+  GELOGD("[ZCPY] %s set task, virtual_addr: 0x%lx, args_addr: %p, size: %zu, offset: %zu", name_.c_str(), addr,
          args_addr_, args_size_, offset);
   return SUCCESS;
 }
@@ -167,7 +167,7 @@ Status ZeroCopyTask::DistributeParam(bool async_mode, rtStream_t stream) {
     return RT_ERROR_TO_GE_STATUS(rt_err);
   }
 
-  GELOGI("[ZCPY] %s refresh task args success, args_addr: %p, size: %zu, args_info_: %p, length: %zu", name_.c_str(),
+  GELOGD("[ZCPY] %s refresh task args success, args_addr: %p, size: %zu, args_info_: %p, length: %zu", name_.c_str(),
          args_addr_, args_size_, args_info_.data(), args_info_.size());
   return SUCCESS;
 }

ge/graph/manager/graph_manager.cc

@@ -363,7 +363,7 @@ Status GraphManager::AddGraph(const GraphId &graph_id, const Graph &graph,
     for (auto &subgraph : compute_graph->GetAllSubgraphs()) {
       (void)AttrUtils::SetStr(*subgraph, ATTR_NAME_SESSION_GRAPH_ID, session_graph_id);
     }
-    GELOGW("Get graph session_graph_id attr failed, set session id to default value: [0]");
+    GELOGD("Get graph session_graph_id attr failed, set session id to default value: [0]");
   }
 
   GraphNodePtr graph_node = MakeShared<ge::GraphNode>(graph_id);
@@ -396,8 +396,6 @@ Status GraphManager::AddGraph(const GraphId &graph_id, const Graph &graph,
   stages.builder.SetOptions(options_);
 
   var_acc_ctrl_.AddGraph(graph_id, compute_graph);
-
-  GELOGI("[GraphManager] add graph success, graph_id = %u.", graph_id);
   return SUCCESS;
 }
 
@@ -435,7 +433,7 @@ Status GraphManager::AddGraphWithCopy(const GraphId &graph_id, const Graph &grap
     for (auto &subgraph : new_compute_graph->GetAllSubgraphs()) {
       (void)AttrUtils::SetStr(*subgraph, ATTR_NAME_SESSION_GRAPH_ID, session_graph_id);
     }
-    GELOGW("Get graph session_graph_id attr failed, set session id to default value: [0]");
+    GELOGD("Get graph session_graph_id attr failed, set session id to default value: [0]");
   }
 
   GraphNodePtr graph_node = MakeShared<ge::GraphNode>(graph_id);
@@ -468,8 +466,6 @@ Status GraphManager::AddGraphWithCopy(const GraphId &graph_id, const Graph &grap
   stages.builder.SetOptions(options_);
 
   var_acc_ctrl_.AddGraph(graph_id, new_compute_graph);
-
-  GELOGI("[GraphManager] add graph success, graph_id = %u.", graph_id);
   return SUCCESS;
 }
 
@@ -546,7 +542,7 @@ Status GraphManager::OptimizeSubGraphWithMultiThreads(ComputeGraphPtr compute_gr
   const auto &root_subgraph_list = sub_graph_map[compute_graph];
   std::string op_compile_strategy;
   (void)AttrUtils::GetStr(compute_graph, ATTR_NAME_OP_COMPILE_STRATEGY, op_compile_strategy);
-  GELOGI("OptimizeSubGraphWithMultiThreads Process op_compile_strategy:%s", op_compile_strategy.c_str());
+  GELOGD("OptimizeSubGraphWithMultiThreads Process op_compile_strategy:%s", op_compile_strategy.c_str());
   for (const auto &subgraph : root_subgraph_list) {
     if (!op_compile_strategy.empty()) {
       (void) AttrUtils::SetStr(subgraph->GetSubGraph(), ATTR_NAME_OP_COMPILE_STRATEGY, op_compile_strategy);
@@ -576,7 +572,7 @@ Status GraphManager::OptimizeSubGraphWithMultiThreads(ComputeGraphPtr compute_gr
       vector_future.emplace_back(std::move(f));
     }
   }
-  GELOGI("All sub graph num is %zu", vector_future.size());
+  GELOGD("All sub graph num is %zu", vector_future.size());
   for (size_t i = 0; i < vector_future.size(); ++i) {
     Status ret_status = vector_future[i].get();
     if (ret_status != SUCCESS) {
@@ -700,7 +696,7 @@ Status GraphManager::SetSubgraph(uint64_t session_id, ComputeGraphPtr compute_gr
     /// Multiply optimize subgraph:
     /// 1. run lx buffer while build_mode is normal and buffer_optimize is empty or "off_optimize";
     /// 2. run lx fusion or buffer according build_mode and build_step in fe.
-    GELOGI("Directly optimize subgraph with build mode:%s, and step:%s, buffer_optimize:%s.",
+    GELOGD("Directly optimize subgraph with build mode:%s, and step:%s, buffer_optimize:%s.",
            options_.build_mode.c_str(),
            options_.build_step.c_str(),
            buffer_optimize.c_str());
@@ -747,7 +743,7 @@ Status GraphManager::PreRunOptimizeOriginalGraph(const GraphNodePtr &graph_node,
   GE_CHK_STATUS_RET(graph_pass.Run(compute_graph));
 
   GE_CHK_STATUS_RET(stages.optimizer.IdentifyReference(compute_graph), "Identify reference failed.");
-  GELOGI("PreRun:PreRunOptimizeOriginalGraph success.");
+  GELOGD("PreRun:PreRunOptimizeOriginalGraph success.");
   return SUCCESS;
 }
 
@@ -762,10 +758,10 @@ Status GraphManager::PreRunOptimizeSubGraph(const GraphNodePtr &graph_node,
   if (options_.build_mode == BUILD_MODE_TUNING && options_.build_step == BUILD_STEP_AFTER_UB_MATCH) {
     std::string tuning_path;
     (void) GetContext().GetOption(TUNING_PATH, tuning_path);
-    GELOGI("Dump path:%s.", tuning_path.c_str());
+    GELOGD("Dump path:%s.", tuning_path.c_str());
     GraphUtils::DumpGEGraph(compute_graph, "", true, tuning_path);
   }
-  GELOGI("PreRun:PreRunOptimizeSubGraph success.");
+  GELOGD("PreRun:PreRunOptimizeSubGraph success.");
   return SUCCESS;
 }
 
@@ -785,12 +781,12 @@ Status GraphManager::PreRunAfterOptimizeSubGraph(const GraphNodePtr &graph_node,
   }
 
   GM_RUN_AND_DUMP_PERF("Build", Build, graph_node, compute_graph, ge_root_model, session_id);
-  GELOGI("PreRun:PreRunAfterOptimizeSubGraph success.");
+  GELOGD("PreRun:PreRunAfterOptimizeSubGraph success.");
   return SUCCESS;
 }
 
 Status GraphManager::SetRtContext(rtContext_t rt_context, rtCtxMode_t mode, uint64_t session_id, uint32_t graph_id) {
-  GELOGI("set rt_context, session id: %lu, graph id: %u, mode %d, device id:%u.", session_id, graph_id,
+  GELOGD("set rt_context, session id: %lu, graph id: %u, mode %d, device id:%u.", session_id, graph_id,
          static_cast<int>(mode), ge::GetContext().DeviceId());
 
   rtError_t rt_ret = rtCtxCreate(&rt_context, mode, ge::GetContext().DeviceId());
@@ -1251,7 +1247,7 @@ Status GraphManager::BuildGraphForUnregisteredOp(const GraphId &graph_id, const
 
 Status GraphManager::BuildGraph(const GraphId &graph_id, const std::vector<GeTensor> &inputs,
                                 GeRootModelPtr &ge_root_model, uint64_t session_id, bool async) {
-  GELOGI("[BuildGraph] start to build graph, graph_id=%u.", graph_id);
+  GELOGD("[BuildGraph] start to build graph, graph_id=%u.", graph_id);
   if (inputs.empty()) {
     GELOGW("[BuildGraph] BuildGraph warning: empty GeTensor inputs");
   }
@@ -1531,7 +1527,6 @@ Status GraphManager::ParseOptions(const std::map<std::string, std::string> &opti
 
   // Set save_original_model flag (ge.save_original_model)
   ParseOption(options, SAVE_ORIGINAL_MODEL, options_.save_original_model);
-  GELOGI("Set save original model flag %s", options_.save_original_model.c_str());
   // Original model file name
   ParseOption(options, ORIGINAL_MODEL_FILE, options_.original_model_file);
 
@@ -2242,7 +2237,7 @@ Status GraphManager::OptimizeStage1(ge::ComputeGraphPtr &compute_graph) {
 }
 
 Status GraphManager::OptimizeStage2(ge::ComputeGraphPtr &compute_graph) {
-  GELOGI("Start optimize after merge sub graph.");
+  GELOGD("Start optimize after merge sub graph.");
 
   PassManager after_merge_passes;
   GE_CHK_STATUS_RET(after_merge_passes.AddPass("OptimizeStage2::AfterMergePasses::LinkGenMaskNodesPass",
@@ -2492,7 +2487,7 @@ Status GraphManager::ProcessSubGraphWithMultiThreads(GraphManager *graph_manager
 
     ComputeGraphPtr compute_graph_tmp = sub_graph_info_ptr->GetSubGraph();
     const std::string &engine_name = sub_graph_info_ptr->GetEngineName();
-    GELOGI("ProcessSubGraphWithMultiThreads start, graph name is %s, engine_name is %s, thread id is %lu",
+    GELOGD("ProcessSubGraphWithMultiThreads start, graph name is %s, engine_name is %s, thread id is %lu",
            compute_graph_tmp != nullptr ? compute_graph_tmp->GetName().c_str() : "", engine_name.c_str(),
            pthread_self());
     GE_DUMP(compute_graph_tmp, "OptimizeSubGraphBefore");
@@ -2504,11 +2499,11 @@ Status GraphManager::ProcessSubGraphWithMultiThreads(GraphManager *graph_manager
       GELOGE(ret, "SubGraph optimize Failed %s", engine_name.c_str());
       return ret;
     } else {
-      GELOGI("SubGraph optimize success %s", engine_name.c_str());
+      GELOGD("SubGraph optimize success %s", engine_name.c_str());
     }
     GE_DUMP(compute_graph_tmp, "OptimizeSubGraphAfter");
     sub_graph_info_ptr->SetSubGraph(compute_graph_tmp);
-    GELOGI("ProcessSubGraphWithMultiThreads end, graph name is %s, engine_name is %s, thread id is %lu",
+    GELOGD("ProcessSubGraphWithMultiThreads end, graph name is %s, engine_name is %s, thread id is %lu",
            compute_graph_tmp != nullptr ? compute_graph_tmp->GetName().c_str() : "", engine_name.c_str(),
            pthread_self());
   } else {

ge/graph/manager/graph_var_manager.cc

@@ -642,7 +642,7 @@ ge::Status VarManager::SyncBroadCastData2Var(uint32_t graph_id, const std::strin
 bool VarManager::IsVarAddr(const int64_t &offset) {
   std::lock_guard<std::recursive_mutex> lock(mutex_);
   if (var_resource_ == nullptr) {
-    GELOGW("VarManager has not been init.");
+    GELOGD("VarManager has not been init.");
     return false;
   }
   return var_resource_->IsVarAddr(offset);

ge/graph/manager/trans_var_data_utils.cc

@@ -501,7 +501,7 @@ Status TransVarDataUtils::TransAllVarData(const vector<NodePtr> &variable_nodes,
 }
 
 Status TransVarDataUtils::CopyVarData(const ComputeGraphPtr &compute_graph, uint64_t session_id, uint32_t device_id) {
-  GELOGI("CopyVarData start: session_id:%lu.", session_id);
+  GELOGD("CopyVarData start: session_id:%lu.", session_id);
   if (compute_graph == nullptr) {
     GELOGE(FAILED, "compute_graph is nullptr");
     return FAILED;

ge/graph/optimize/graph_optimize.cc

@@ -58,8 +58,7 @@ void AddNodeInputProperty(ComputeGraphPtr &compute_graph) {
 
     for (auto &in_data_anchor : node->GetAllInDataAnchors()) {
       auto peer_out_anchor = in_data_anchor->GetPeerOutAnchor();
-      GE_IF_BOOL_EXEC(
-        peer_out_anchor == nullptr, GELOGW("peer_out_anchor is nullptr! node: %s", node->GetName().c_str()); continue);
+      GE_IF_BOOL_EXEC(peer_out_anchor == nullptr, continue);
 
       ge::NodePtr src_node = peer_out_anchor->GetOwnerNode();
       src_index_list = node_op_desc->GetSrcIndex();
@@ -242,11 +241,11 @@ Status GraphOptimize::OptimizeGraphBeforeBuildForRts(ComputeGraphPtr &compute_gr
   }
 
   auto graph_optimizer = instance_ptr->OpsKernelManagerObj().GetAllGraphOptimizerObjsByPriority();
-  GELOGI("optimize by opskernel in graph optimize before build phase. num of graph_optimizer is %zu.",
+  GELOGD("optimize by opskernel in graph optimize before build phase. num of graph_optimizer is %zu.",
          graph_optimizer.size());
   Status ret = SUCCESS;
   string exclude_core_Type = (core_type_ == kVectorCore) ? kAicoreEngine : kVectorEngine;
-  GELOGI("[OptimizeGraphBeforeBuildForRts]: engine type will exclude: %s, core_type_: %s",
+  GELOGD("[OptimizeGraphBeforeBuildForRts]: engine type will exclude: %s, core_type_: %s",
          exclude_core_Type.c_str(), core_type_.c_str());
   if (graph_optimizer.size() != 0) {
     for (auto iter = graph_optimizer.begin(); iter != graph_optimizer.end(); ++iter) {

ge/graph/partition/engine_place.cc

@@ -50,7 +50,7 @@ Status EnginePlacer::Check() const {
 Status EnginePlacer::Run() {
   std::lock_guard<std::mutex> lock(check_support_cost_mutex);
 
-  GELOGI("Engine placer starts.");
+  GELOGD("Engine placer starts.");
   if (Check() != SUCCESS) {
     return FAILED;
   }
@@ -101,7 +101,7 @@ Status EnginePlacer::Run() {
   for (auto &it : ge::GELib::GetInstance()->DNNEngineManagerObj().GetCheckSupportCost()) {
     GEEVENT("The time cost of %s::CheckSupported is [%lu] micro second.", it.first.c_str(), it.second);
   }
-  GELOGI("Engine placer ends.");
+  GELOGD("Engine placer ends.");
   return is_check_support_success ? SUCCESS : FAILED;
 }
 

ge/graph/partition/graph_partition.cc

@@ -223,7 +223,7 @@ Status ge::GraphPartitioner::MergeSubGraph(ge::ComputeGraphPtr &output_merged_co
     GELOGE(GE_GRAPH_UNSUPPORTED, "Cannot call merging in partition mode");
     return FAILED;
   }
-  GELOGI("Graph merge starts.");
+  GELOGD("Graph merge starts.");
   // check input param
   for (const auto &it : sub_graph_list) {
     if (it == nullptr) {
@@ -261,7 +261,7 @@ Status ge::GraphPartitioner::MergeSubGraph(ge::ComputeGraphPtr &output_merged_co
     return FAILED;
   }
   GE_TIMESTAMP_END(MergeSubGraphEnginePlacerRun, "GraphPartitioner::MergeGraphEnginePlacerRun");
-  GELOGI("Graph merge ends.");
+  GELOGD("Graph merge ends.");
   return SUCCESS;
 }
 
@@ -581,7 +581,7 @@ Status ge::GraphPartitioner::Initialize(ge::ComputeGraphPtr compute_graph) {
            new_cluster->engine_name_.c_str(), new_cluster->index_, new_cluster->stream_label_.c_str());
     temp_index++;
   }
-  GELOGI("Initialize ends.");
+  GELOGD("Initialize ends.");
   return SUCCESS;
 }
 
@@ -754,11 +754,11 @@ void ge::GraphPartitioner::MarkClusters() {
       }
     }
   }
-  GELOGI("MarkClusters ends.");
+  GELOGD("MarkClusters ends.");
 }
 
 Status ge::GraphPartitioner::SplitSubGraphs(ge::ComputeGraphPtr compute_graph) {
-  GELOGI("SplitSubGraphs starts.");
+  GELOGD("SplitSubGraphs starts.");
   if (compute_graph == nullptr) {
     GELOGE(FAILED, "parameter ptr is null.");
     return FAILED;
@@ -823,7 +823,7 @@ Status ge::GraphPartitioner::SplitSubGraphs(ge::ComputeGraphPtr compute_graph) {
       }
     }
   }
-  GELOGI("SplitSubGraphs ends.");
+  GELOGD("SplitSubGraphs ends.");
   return SUCCESS;
 }
 

ge/graph/passes/atomic_addr_clean_pass.cc

@@ -46,7 +46,7 @@ Status AtomicAddrCleanPass::Run(ComputeGraphPtr graph) {
     }
   }
   if (atomic_node_vec.empty()) {
-    GELOGI("There is no atomic node. Ignore atomicAddrClean pass.");
+    GELOGD("There is no atomic node. Ignore atomicAddrClean pass.");
     return SUCCESS;
   }
 

ge/graph/passes/cond_remove_pass.cc

@@ -326,7 +326,7 @@ Status CondRemovePass::GetCondInfo(const NodePtr &node, ComputeGraphPtr &graph,
       return FAILED;
     }
   } else {
-    GELOGI("no need cond_pass for node %s.", node->GetName().c_str());
+    GELOGD("no need cond_pass for node %s.", node->GetName().c_str());
     return NOT_CHANGED;
   }
 

ge/graph/passes/memcpy_addr_async_pass.cc

@@ -278,7 +278,7 @@ Status MemcpyAddrAsyncPass::InsertMemcpyAddrAsyncNode(const OutDataAnchorPtr &ou
 }
 
 Status MemcpyAddrAsyncPass::InsertMemAddrAsyncNodeBeforeNetoutput(const ComputeGraphPtr &graph, const NodePtr &node) {
-  GELOGI("Start AddMemcpyAddrAsyncNode for %s.", node->GetName().c_str());
+  GELOGD("Start AddMemcpyAddrAsyncNode for %s.", node->GetName().c_str());
   for (const auto &in_data_anchor : node->GetAllInDataAnchors()) {
     auto in_node = NodeUtils::GetInDataNodeByIndex(*node, in_data_anchor->GetIdx());
     GE_CHECK_NOTNULL(in_node);

ge/graph/passes/multi_batch_pass.cc

@@ -36,7 +36,7 @@ Status MultiBatchPass::Run(ComputeGraphPtr graph) {
   OutDataAnchorPtr pred_value = nullptr;
   Status ret = FindPredValue(graph, pred_value);
   if (ret == NOT_CHANGED) {
-    GELOGI("SwitchN node not exist, graph not changed.");
+    GELOGD("SwitchN node not exist, graph not changed.");
     return SUCCESS;
   }
   if (ret != SUCCESS) {
@@ -160,7 +160,7 @@ Status MultiBatchPass::FindPredValue(const ComputeGraphPtr &graph, OutDataAnchor
   }
 
   if (switch_n_nodes_.empty()) {
-    GELOGI("SwitchN node not exist.");
+    GELOGD("SwitchN node not exist.");
     return NOT_CHANGED;
   }
 

ge/graph/passes/set_input_output_offset_pass.cc

@@ -128,7 +128,7 @@ Status SetInputOutputOffsetPass::SetInputOffsetForHcom(const ge::NodePtr &node,
 }
 
 Status SetInputOutputOffsetPass::SetInputOffset(const NodePtr &node, const vector<int> &connect_input) {
-  GELOGI("Start to SetInputOffset for %s.", node->GetName().c_str());
+  GELOGD("Start to SetInputOffset for %s.", node->GetName().c_str());
   std::vector<int64_t> memory_type;
   auto op_desc = node->GetOpDesc();
   (void)ge::AttrUtils::GetListInt(op_desc, ATTR_NAME_INPUT_MEM_TYPE_LIST, memory_type);
@@ -241,7 +241,7 @@ Status SetInputOutputOffsetPass::SetOutputOffsetForHcom(const NodePtr &node, con
 }
 
 Status SetInputOutputOffsetPass::SetOutputOffset(const NodePtr &node, const vector<int> &connect_output) {
-  GELOGI("Start SetOutputOffset of %s.", node->GetName().c_str());
+  GELOGD("Start SetOutputOffset of %s.", node->GetName().c_str());
   bool attr_no_task = false;
   bool get_attr_no_task = ge::AttrUtils::GetBool(node->GetOpDesc(), ATTR_NAME_NOTASK, attr_no_task);
   if (get_attr_no_task && attr_no_task) {

ge/ir_build/atc_ir_common.cc

@@ -504,7 +504,7 @@ void PrintOptionMap(std::map<std::string, std::string> &options, std::string tip
   for (auto iter = options.begin(); iter != options.end(); iter++) {
     std::string key = iter->first;
     std::string option_name = iter->second;
-    GELOGI("%s set successfully, option_key=%s, option_value=%s", tips.c_str(), key.c_str(), option_name.c_str());
+    GELOGD("%s set successfully, option_key=%s, option_value=%s", tips.c_str(), key.c_str(), option_name.c_str());
   }
 }
 

ge/ir_build/ge_ir_build.cc

@@ -340,7 +340,7 @@ void Impl::SetRtSocVersion() {
     if (rt_ret != RT_ERROR_NONE) {
       GELOGW("Set soc version %s failed. ret:0x%X", soc_version, rt_ret);
     }
-    GELOGI("Set soc version %s success.", soc_version);
+    GELOGD("Set soc version %s success.", soc_version);
   }
 }
 
@@ -359,25 +359,25 @@ graphStatus Impl::CreateInputsForIRBuild(const ge::Graph &graph, vector<ge::GeTe
     GE_CHECK_NOTNULL(op);
     if (op->GetType() == DATA) {
       (void)AttrUtils::SetInt(op, ATTR_NAME_INDEX, index++);
-      GELOGI("Data op inputDesc size: %zu", op->GetAllInputsDesc().size());
+      GELOGD("Data op inputDesc size: %zu", op->GetAllInputsDesc().size());
       ge::GeTensorDesc tensor = op->GetInputDesc(0);
       string data_op_name = op->GetName();
-      GELOGI("Data op name: %s", data_op_name.c_str());
+      GELOGD("Data op name: %s", data_op_name.c_str());
       ge::GeShape data_shape;
       auto iter = omg_context_.input_dims.find(data_op_name);
       if (iter != omg_context_.input_dims.end()) {
         data_shape = ge::GeShape(iter->second);
-        GELOGI("Data op get shape from Context.");
+        GELOGD("Data op get shape from Context.");
       } else {
         data_shape = tensor.GetShape();
-        GELOGI("Data op get shape from InputDesc in ge ir graph.");
+        GELOGD("Data op get shape from InputDesc in ge ir graph.");
       }
       // If user point input format, do work for all data ops; else do according to tensor_desc
       auto data_format = omg_context_.format != domi::DOMI_TENSOR_ND ?
         ge::TypeUtils::DomiFormatToFormat(omg_context_.format) : tensor.GetFormat();
       ge::DataType data_type = tensor.GetDataType();
       string data_type_str = ge::TypeUtils::DataTypeToSerialString(data_type);
-      GELOGI("Data op get data type:%s from InputDesc in ge ir graph.", data_type_str.c_str());
+      GELOGD("Data op get data type:%s from InputDesc in ge ir graph.", data_type_str.c_str());
 
       ge::GeTensor inputTensor;
       ge::GeTensorDesc desc(data_shape, ge::Format(data_format), data_type);

ge/opskernel_manager/ops_kernel_manager.cc

@@ -391,7 +391,7 @@ void OpsKernelManager::GetGraphOptimizerByEngine(const std::string &engine_name,
       continue;
     }
     if (attrs.engineName == engine_name) {
-      GELOGI("GetGraphOptimizerByEngine GraphOptimzer name: %s, engineName: %s", (it.first).c_str(),
+      GELOGD("GetGraphOptimizerByEngine GraphOptimzer name: %s, engineName: %s", (it.first).c_str(),
              attrs.engineName.c_str());
       graph_optimizer.push_back(it.second);
     }