m53297601
/
graphengine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

!402 log rectify

Browse Source 
From: @yangyongqiang5033
Reviewed-by: @xchu42,@ji_chen
Signed-off-by: @ji_chen
pull/402/MERGE
mindspore-ci-bot 4 years ago committed by Gitee
parent 52da0581a6 5d06755d29
commit e6933805d3
45 changed files with 154 additions and 255 deletions
Show Stats Download Patch File Download Diff File

4
ge/common/cust_aicpu_kernel_store.cc
Unescape View File

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

31
ge/common/helper/model_helper.cc
Unescape View File

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

12
ge/common/helper/om_file_helper.cc
Unescape View File

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

4
ge/common/kernel_store.cc
Unescape View File

@ -51,7 +51,7 @@ bool KernelStore::Build() {
kernel_head.name_len = static_cast<uint32_t>(kernel->GetName().length()); kernel_head.name_len = static_cast<uint32_t>(kernel->GetName().length());
kernel_head.bin_len = static_cast<uint32_t>(kernel->GetBinDataSize()); 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()); kernel->GetName().c_str(), kernel->GetBinData(), kernel->GetBinDataSize());
mem_ret = memcpy_s(next_buffer, remain_len, &kernel_head, sizeof(kernel_head)); mem_ret = memcpy_s(next_buffer, remain_len, &kernel_head, sizeof(kernel_head));
GE_CHK_BOOL_EXEC_NOLOG(mem_ret == EOK, return false); 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); std::string name(next_buffer, kernel_head->name_len);
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); 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)); KernelBinPtr teb_kernel_ptr = ge::MakeShared<KernelBin>(name, std::move(kernel_bin));
if (teb_kernel_ptr != nullptr) { if (teb_kernel_ptr != nullptr) {

2
ge/common/model_parser/base.cc
Unescape View File

@ -106,7 +106,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelParserBase::ParseMo
model_data = data; model_data = data;
model_len = file_header->length; 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 { } else {
GELOGE(ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION, "Invalid model. ModelEncryptType not supported."); GELOGE(ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION, "Invalid model. ModelEncryptType not supported.");
res = ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION; res = ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION;

20
ge/common/profiling/profiling_manager.cc
Unescape View File

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

16
ge/executor/ge_executor.cc
Unescape View File

@ -588,7 +588,7 @@ Status GeExecutor::LoadModel(uint32_t &model_id, const ModelData &model_data,
} }
Status GeExecutor::UnloadModel(uint32_t model_id) { Status GeExecutor::UnloadModel(uint32_t model_id) {
GELOGI("unload model %u begin.", model_id); GELOGD("unload model %u begin.", model_id);
if (!isInit_) { if (!isInit_) {
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!");
return ACL_ERROR_GE_EXEC_NOT_INIT; 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 // Get input and output descriptor
Status GeExecutor::GetModelDescInfo(uint32_t model_id, std::vector<ge::TensorDesc> &input_desc, Status GeExecutor::GetModelDescInfo(uint32_t model_id, std::vector<ge::TensorDesc> &input_desc,
std::vector<ge::TensorDesc> &output_desc, bool new_model_desc) { std::vector<ge::TensorDesc> &output_desc, bool new_model_desc) {
GELOGI("get model desc info begin.");
if (!isInit_) { if (!isInit_) {
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!");
return ACL_ERROR_GE_EXEC_NOT_INIT; 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(input_desc, input_desc_infos, input_formats);
GetGeTensorDescFromDomiInfo(output_desc, output_desc_infos, output_formats); GetGeTensorDescFromDomiInfo(output_desc, output_desc_infos, output_formats);
GELOGI("get model desc info end.");
return ge::SUCCESS; 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, Status GeExecutor::GetDynamicBatchInfo(uint32_t model_id, std::vector<std::vector<int64_t>> &batch_info,
int32_t &dynamic_type) { int32_t &dynamic_type) {
GELOGI("Begin to get dynamic batch info.");
if (!isInit_) { if (!isInit_) {
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!");
return ACL_ERROR_GE_EXEC_NOT_INIT; 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."); GELOGE(ret, "GetDynamicBatchInfo failed.");
return ret; return ret;
} }
GELOGI("Get dynamic batch info succ.");
return SUCCESS; return SUCCESS;
} }
@ -727,7 +722,6 @@ Status GeExecutor::GetCombinedDynamicDims(uint32_t model_id, vector<vector<int64
/// @return execute result /// @return execute result
/// ///
Status GeExecutor::GetUserDesignateShapeOrder(uint32_t model_id, vector<string> &user_designate_shape_order) { Status GeExecutor::GetUserDesignateShapeOrder(uint32_t model_id, vector<string> &user_designate_shape_order) {
GELOGI("Begin to get user designate shape info.");
if (!isInit_) { if (!isInit_) {
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!");
return ACL_ERROR_GE_EXEC_NOT_INIT; return ACL_ERROR_GE_EXEC_NOT_INIT;
@ -739,7 +733,6 @@ Status GeExecutor::GetUserDesignateShapeOrder(uint32_t model_id, vector<string>
return ret; return ret;
} }
GELOGI("Get user designate shape order succ.");
return SUCCESS; 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) { 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_) { if (!isInit_) {
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!"); GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!");
return ACL_ERROR_GE_EXEC_NOT_INIT; 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."); GELOGE(ret, "Get dynamic batch output shape info failed.");
return ret; return ret;
} }
GELOGI("Get dynamic batch output shape info succ.");
return SUCCESS; return SUCCESS;
} }
@ -835,8 +825,6 @@ Status GeExecutor::GetModelDescInfoForZeroCopy(uint32_t model_id, std::vector<ge
} }
Status GeExecutor::CommandHandle(const Command &command) { Status GeExecutor::CommandHandle(const Command &command) {
GELOGI("command handle begin.");
Status ret = GraphLoader::CommandHandle(command); Status ret = GraphLoader::CommandHandle(command);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ACL_ERROR_GE_COMMAND_HANDLE, "CommandHandle: Command Handle failed."); 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, 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) { void *weight_ptr, size_t weight_size) {
GELOGI("Load model from data begin.");
if (!isInit_) { if (!isInit_) {
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!"); GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "not inited yet!");
return ACL_ERROR_GE_EXEC_NOT_INIT; 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, Status GeExecutor::ExecModel(uint32_t model_id, void *stream, const ge::RunModelData &run_input_data,
ge::RunModelData &run_output_data, bool async_mode) { ge::RunModelData &run_output_data, bool async_mode) {
GELOGI("Execute model begin.");
if (!isInit_) { if (!isInit_) {
GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!"); GELOGE(ACL_ERROR_GE_EXEC_NOT_INIT, "GeExecutor has not been initialized!");
return ACL_ERROR_GE_EXEC_NOT_INIT; return ACL_ERROR_GE_EXEC_NOT_INIT;

4
ge/ge_local_engine/ops_kernel_store/ge_local_ops_kernel_builder.cc
Unescape View File

@ -111,7 +111,7 @@ Status GeLocalOpsKernelBuilder::CalcOpRunningParam(Node &ge_node) {
TypeUtils::DataTypeToSerialString(data_type).c_str(), output_mem_size); TypeUtils::DataTypeToSerialString(data_type).c_str(), output_mem_size);
return FAILED; return FAILED;
} }
GELOGI( GELOGD(
"Calc op[%s:%s] out[%zu] mem size is %ld," "Calc op[%s:%s] out[%zu] mem size is %ld,"
" format=%s, data_type=%s.", " format=%s, data_type=%s.",
node_name.c_str(), node_type.c_str(), i, output_mem_size, TypeUtils::FormatToSerialString(format).c_str(), 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()); GELOGE(ret, "Node:%s(%s) op run failed.", name.c_str(), type.c_str());
return ret; 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; return ret;
} }
} // namespace ge_local } // namespace ge_local

2
ge/ge_local_engine/ops_kernel_store/op/no_op.cc
Unescape View File

@ -24,7 +24,7 @@ namespace ge_local {
NoOp::NoOp(const Node &node, RunContext &run_context) : Op(node, run_context) {} NoOp::NoOp(const Node &node, RunContext &run_context) : Op(node, run_context) {}
Status NoOp::Run() { 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 // Do nothing
return SUCCESS; return SUCCESS;
} }

10
ge/generator/ge_generator.cc
Unescape View File

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

8
ge/graph/build/graph_builder.cc
Unescape View File

@ -102,7 +102,6 @@ void GraphBuilder::SetOptions(const ge::GraphManagerOptions &options) {
} }
Status GraphBuilder::CalcOpParam(const ge::ComputeGraphPtr &graph) { Status GraphBuilder::CalcOpParam(const ge::ComputeGraphPtr &graph) {
GELOGI("Begin to calculate op running param.");
GE_CHECK_NOTNULL(graph); GE_CHECK_NOTNULL(graph);
auto instance_ptr = ge::GELib::GetInstance(); auto instance_ptr = ge::GELib::GetInstance();
if (instance_ptr == nullptr || !instance_ptr->InitFlag()) { if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
@ -140,7 +139,6 @@ Status GraphBuilder::CalcOpParam(const ge::ComputeGraphPtr &graph) {
auto parent_node = graph->GetParentNode(); auto parent_node = graph->GetParentNode();
if (parent_node == nullptr) { 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; 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, Status GraphBuilder::Build(ComputeGraphPtr &comp_graph, std::vector<SubGraphInfoPtr> &subgraph_ptr_list,
GeRootModelPtr &ge_root_model_ptr, uint64_t session_id) { GeRootModelPtr &ge_root_model_ptr, uint64_t session_id) {
GELOGI("Start to build model.");
if (comp_graph == nullptr) { if (comp_graph == nullptr) {
GELOGE(GE_GRAPH_PARAM_NULLPTR, "Graph build comp_graph is null."); GELOGE(GE_GRAPH_PARAM_NULLPTR, "Graph build comp_graph is null.");
return GE_GRAPH_PARAM_NULLPTR; 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), GE_CHK_STATUS_RET(builder.SaveDataToModel(*model_ptr, *ge_model_ptr),
"Graph[%s] builder SaveDataToModel() return fail.", comp_graph->GetName().c_str()); "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"); GE_TIMESTAMP_END(BuildSubgraph, "GraphBuilder::Build");
return SUCCESS; return SUCCESS;
} }
@ -306,7 +303,7 @@ Status GraphBuilder::BuildForUnknownShapeGraph(ComputeGraphPtr &comp_graph, GeMo
} }
GE_CHK_STATUS_RET(builder.SaveDataToModel(*model_ptr, *ge_model_ptr), GE_CHK_STATUS_RET(builder.SaveDataToModel(*model_ptr, *ge_model_ptr),
"Graph[%s] builder SaveDataToModel() return fail.", comp_graph->GetName().c_str()); "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; 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) { Status GraphBuilder::SecondPartition(ge::ComputeGraphPtr &comp_graph, vector<ge::SubGraphInfoPtr> &subgraph_ptr_list) {
GELOGI("[SecondPartition] second partition.");
GE_TIMESTAMP_START(GraphPartition2); GE_TIMESTAMP_START(GraphPartition2);
auto ret = graph_partitioner_.Partition(comp_graph, GraphPartitioner::kSecondPartitioning); auto ret = graph_partitioner_.Partition(comp_graph, GraphPartitioner::kSecondPartitioning);
if (ret != SUCCESS) { if (ret != SUCCESS) {

2
ge/graph/build/label_allocator.cc
Unescape View File

@ -33,7 +33,7 @@ Status LabelAllocator::AssignFunctionalLabels() {
} }
// Add label task for sub graph. // 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; std::set<NodePtr> functional_nodes;
for (auto graph : compute_graph_->GetAllSubgraphs()) { for (auto graph : compute_graph_->GetAllSubgraphs()) {
if (!CollectFunctionalNode(graph, functional_nodes)) { if (!CollectFunctionalNode(graph, functional_nodes)) {

8
ge/graph/build/logical_stream_allocator.cc
Unescape View File

@ -597,10 +597,10 @@ Status LogicalStreamAllocator::DoAssign(const ComputeGraphPtr &graph, const Grap
return status; 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) { for (const auto &subgraph : subgraphs) {
if (subgraph != nullptr) { 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_); Status status = pass->Run(graph, subgraphs, context_);
if (status == SUCCESS) { 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) { } 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 { } else {
GELOGE(status, "Stream pass %s failed.", pass->GetName().c_str()); GELOGE(status, "Stream pass %s failed.", pass->GetName().c_str());
return status; return status;

4
ge/graph/build/memory/binary_block_mem_assigner.cc
Unescape View File

@ -76,7 +76,7 @@ Status BinaryBlockMemAssigner::GetMemoryRanges(vector<int64_t> &range_ceils) {
auto range_number = static_cast<size_t>( auto range_number = static_cast<size_t>(
ceil(log(all_memory_size.back() / static_cast<double>(all_memory_size.front())) / log(kLogBase))); ceil(log(all_memory_size.back() / static_cast<double>(all_memory_size.front())) / log(kLogBase)));
range_number = (range_number == 0) ? 1 : range_number; 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); vector<vector<int64_t>> ranges(range_number);
GE_CHK_BOOL_EXEC((range_number != 0), return PARAM_INVALID, "range_number can't be 0."); 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()); 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; return SUCCESS;
} }

13
ge/graph/build/memory/block_mem_assigner.cc
Unescape View File

@ -455,12 +455,11 @@ void BlockMemAssigner::GetOutAndWorkSpaceMem(vector<int64_t> &all_memory_size) {
GetNodeWorkSpaceSize(n, temp); GetNodeWorkSpaceSize(n, temp);
all_memory_size.insert(all_memory_size.end(), temp.begin(), temp.end()); 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_) { for (const auto &pair : symbol_size_) {
all_memory_size.emplace_back(pair.second); all_memory_size.emplace_back(pair.second);
} }
sort(all_memory_size.begin(), all_memory_size.end()); 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();) { for (auto iter = all_memory_size.begin(); iter != all_memory_size.end();) {
if (*iter == 0) { 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) { bool IsDirectOutputNode(const NodePtr &node, int idx) {
if ((node != nullptr) && (node->GetOpDesc() != nullptr) && (node->GetOpDesc()->GetType() == NETOUTPUT)) { 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 true;
} }
return false; return false;
@ -1219,7 +1218,7 @@ Status BlockMemAssigner::AssignOutputMemoryWithReuse(const NodePtr &node, vector
int64_t stream_id = op_desc->GetStreamId(); int64_t stream_id = op_desc->GetStreamId();
vector<int64_t> memorys_type; vector<int64_t> memorys_type;
bool has_mem_type_attr = ge::AttrUtils::GetListInt(op_desc, ATTR_NAME_OUTPUT_MEM_TYPE_LIST, 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()); op_desc->GetOutputsSize(), memorys_type.size());
if (has_mem_type_attr && (memorys_type.size() != op_desc->GetOutputsSize())) { 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]", 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 BlockMemAssigner::AssignMemoryWithReuse(vector<int64_t> &ranges) {
(void)ge::GetContext().GetOption(OPTION_EXEC_DISABLE_REUSED_MEMORY, ge_disable_reuse_mem_env_); (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; string op_no_reuse_mem_str;
const char *op_no_reuse_mem = std::getenv(OP_NO_REUSE_MEM); 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); 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; vector<bool> workspace_reuse_flag;
GE_IF_BOOL_EXEC(!ge::AttrUtils::GetListBool(node_op_desc, kAttrNameWorkspaceReuseFlag, 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())); 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()); temp.size(), tvm_workspace_memory_type.size());
if (has_tvm_workspace_mem_type_attr && (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); 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_); mem_offset_, p2p_mem_offset_);
} }

11
ge/graph/build/memory/graph_mem_assigner.cc
Unescape View File

@ -117,7 +117,7 @@ Status GraphMemoryAssigner::AssignMemory() {
return ge::FAILED; return ge::FAILED;
} }
int64_t var_size_assign = ge::VarManager::Instance(session_id)->GetVarMemSize(RT_MEMORY_HBM) - var_size_before_assign; 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); 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(); mem_offset[RT_MEMORY_HBM] += memory_block->Size();
memory_block->SetTailOffset(mem_offset[RT_MEMORY_HBM] - 1); 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 // set offset for zero copy nodes
priority_assigner->SetOpMemOffset(true); 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]; 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); zero_mem_copy_size);
return SUCCESS; return SUCCESS;
} }
Status GraphMemoryAssigner::ReAssignContinuousMemory(bool is_loop_graph) { Status GraphMemoryAssigner::ReAssignContinuousMemory(bool is_loop_graph) {
GELOGI("Begin to reassign continuous memory");
Status ret; Status ret;
for (auto &node : compute_graph_->GetAllNodes()) { for (auto &node : compute_graph_->GetAllNodes()) {
// Get the continuous input type of the node, default is false // 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_) { 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_); pair.second.mem_offset_);
} }
return ge::SUCCESS; return ge::SUCCESS;
@ -834,7 +832,6 @@ Status GraphMemoryAssigner::ReAssignVirtualNodesMemory(map<string, vector<NodePt
string max_batch_label; string max_batch_label;
GE_CHK_STATUS_RET(GetMaxBatchLabel(mem_reuse_nodes_map, mem_reuse_model, max_batch_label), GE_CHK_STATUS_RET(GetMaxBatchLabel(mem_reuse_nodes_map, mem_reuse_model, max_batch_label),
"Get max batch label failed."); "Get max batch label failed.");
GELOGI("The batch label of max batch virtual nodes is %s.", max_batch_label.c_str());
PrintMemoryOffset(); PrintMemoryOffset();
vector<size_t> nodes_mem_offset_list; vector<size_t> nodes_mem_offset_list;
for (auto &i_map : mem_reuse_nodes_map) { 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)); 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" : "", has_mem_type_attr == true ? "Fusion" : "",
tmp_op_desc->GetName().c_str(), tmp_op_desc->GetName().c_str(),
valid_input_index, valid_input_index,

4
ge/graph/build/memory/hybrid_mem_assigner.cc
Unescape View File

@ -62,9 +62,9 @@ Status HybridMemAssigner::Assign() {
std::unique_ptr<BlockMemAssigner> priority_assigner; 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) { 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); priority_assigner = std::move(binary_assigner);
} else { } else {
GELOGI("Use max-block memory assigner method"); GELOGI("Use max-block memory assigner method");

9
ge/graph/build/model_builder.cc
Unescape View File

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

12
ge/graph/build/run_context.cc
Unescape View File

@ -140,7 +140,7 @@ void RunContextUtil::DestroyRtModelResources() noexcept {
Status RunContextUtil::CreateRunContext(Model &model, const ComputeGraphPtr &graph, Buffer &buffer, Status RunContextUtil::CreateRunContext(Model &model, const ComputeGraphPtr &graph, Buffer &buffer,
const uint64_t session_id) { 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 // check params
if (graph == nullptr) { if (graph == nullptr) {
GELOGE(PARAM_INVALID, "CreateRunContext param graph is null. session_id=%lu", session_id); 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); GELOGE(INTERNAL_ERROR, "Get stream_num attr from model_def failed. session_id=%lu", session_id);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
GELOGI("Stream_num = %u", stream_num); GELOGD("Stream_num = %u", stream_num);
uint32_t event_num = 0; uint32_t event_num = 0;
if (!AttrUtils::GetInt(&model, ATTR_MODEL_EVENT_NUM, event_num)) { 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); GELOGE(INTERNAL_ERROR, "Get event_num attr from model failed. session_id=%lu", session_id);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
GELOGI("Event_num = %u", event_num); GELOGD("Event_num = %u", event_num);
uint32_t label_num = 0; uint32_t label_num = 0;
if (!AttrUtils::GetInt(&model, ATTR_MODEL_LABEL_NUM, label_num)) { 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); GELOGE(INTERNAL_ERROR, "Get label_num attr from model failed. session_id=%lu", session_id);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
GELOGI("Label_num = %u", label_num); GELOGD("Label_num = %u", label_num);
Status ret = CreateRtModelResources(stream_num, event_num, label_num); Status ret = CreateRtModelResources(stream_num, event_num, label_num);
if (ret != SUCCESS) { if (ret != SUCCESS) {
@ -198,11 +198,11 @@ Status RunContextUtil::CreateRunContext(Model &model, const ComputeGraphPtr &gra
void RunContextUtil::PrintMemInfo() { void RunContextUtil::PrintMemInfo() {
for (auto iter : mem_type_to_data_mem_base_) { 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_) { 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);
} }
} }

13
ge/graph/build/stream_allocator.cc
Unescape View File

@ -67,11 +67,10 @@ StreamAllocator::StreamAllocator(ComputeGraphPtr whole_graph, const Graph2SubGra
} }
enable_single_stream_ = (single_stream_str == kTrueStr) ? true : false; 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) { 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_CHECK_NOTNULL(whole_graph_);
GE_DUMP(whole_graph_, "BeforeAssignedLogicalStreams"); GE_DUMP(whole_graph_, "BeforeAssignedLogicalStreams");
@ -92,15 +91,12 @@ Status StreamAllocator::AssignLogicalStreams(const std::map<std::string, int> &m
return status; return status;
} }
GE_DUMP(whole_graph_, "AfterAssignedLogicalStreams"); GE_DUMP(whole_graph_, "AfterAssignedLogicalStreams");
GELOGI("Assign logical streams success.");
return SUCCESS; return SUCCESS;
} }
// After allocating the logical stream in the graph, refresh the stream in the // After allocating the logical stream in the graph, refresh the stream in the
// graph and insert the synchronization node. // graph and insert the synchronization node.
Status StreamAllocator::RefreshRealStream(int64_t &stream_num, int64_t &event_num) { Status StreamAllocator::RefreshRealStream(int64_t &stream_num, int64_t &event_num) {
GELOGI("RefreshRealStream start.");
GE_CHECK_NOTNULL(whole_graph_); GE_CHECK_NOTNULL(whole_graph_);
GE_DUMP(whole_graph_, "BeforeRefreshRealStream"); 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"); GELOGI("None of nodes need to assign stream, stream num is 0, it will cause error, so change it to 1");
stream_num_ = 1; stream_num_ = 1;
} }
GELOGI("stream num: %ld, event num: %u.", stream_num_, event_num_); GELOGD("stream num: %ld, event num: %u.", stream_num_, event_num_);
GELOGI("RefreshRealStream successfully.");
stream_num = stream_num_; stream_num = stream_num_;
event_num = static_cast<int64_t>(event_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) { for (const auto &one_pair : after_refresh_stream_nodes) {
int64_t stream_id = one_pair.first; 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) { for (const auto &node : one_pair.second) {
string send_event_str; 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."); GELOGE(FAILED, "Get max stream and task count by rts failed.");
return 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; return SUCCESS;
} }

10
ge/graph/build/stream_graph_optimizer.cc
Unescape View File

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

11
ge/graph/build/task_generator.cc
Unescape View File

@ -68,7 +68,7 @@ TaskGenerator::TaskGenerator(uint8_t *var_mem_base, uint64_t var_mem_size) {
TaskGenerator::~TaskGenerator() {} TaskGenerator::~TaskGenerator() {}
Status TaskGenerator::GetTaskInfo(Model &model, ComputeGraphPtr &graph, uint64_t session_id, RunContext &run_context) { 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 // Check params
if (graph == nullptr) { if (graph == nullptr) {
GELOGE(PARAM_INVALID, "GetTaskInfo param graph is null. session_id=%lu", session_id); 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; return ret;
} }
GELOGI("Get TaskInfo success. session_id=%lu", session_id); GELOGD("Get TaskInfo success. session_id=%lu", session_id);
return SUCCESS; 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; return SUCCESS;
} }
@ -575,7 +575,7 @@ Status TaskGenerator::MarkFirstAndLastOps(const vector<OpDescPtr> &ops, bool is_
continuous_op_lists.back().emplace_back(op_desc); 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) { for (const auto &continuous_ops : continuous_op_lists) {
map<string, std::pair<OpDescPtr, OpDescPtr>> first_and_last_ops; 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, Status TaskGenerator::FindProfilingTaskIndex(const ComputeGraphPtr &graph, ProfilingPoint &profiling_point,
vector<uint32_t> &all_reduce_nodes) const { vector<uint32_t> &all_reduce_nodes) const {
GELOGI("Start FindProfilingTaskIndex.");
GE_CHECK_NOTNULL(graph); GE_CHECK_NOTNULL(graph);
const char *profiling_mode = std::getenv(kProfilingMode); const char *profiling_mode = std::getenv(kProfilingMode);
bool is_profiling = (profiling_mode != nullptr) || ProfilingManager::Instance().ProfilingOn() || bool is_profiling = (profiling_mode != nullptr) || ProfilingManager::Instance().ProfilingOn() ||
ProfilingManager::Instance().ProfilingTrainingTraceOn(); ProfilingManager::Instance().ProfilingTrainingTraceOn();
if (!is_profiling) { if (!is_profiling) {
GELOGW("Profiling is not open."); GELOGD("Profiling is not open.");
return SUCCESS; return SUCCESS;
} }

2
ge/graph/execute/graph_execute.cc
Unescape View File

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

2
ge/graph/load/graph_loader.cc
Unescape View File

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

18
ge/graph/load/new_model_manager/data_dumper.cc
Unescape View File

@ -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) { void DataDumper::SaveDumpInput(const std::shared_ptr<Node> &node) {
GELOGI("Start to save data %s message", node->GetName().c_str());
if (node != nullptr) { if (node != nullptr) {
auto input_op_desc = node->GetOpDesc(); auto input_op_desc = node->GetOpDesc();
if (input_op_desc == nullptr) { 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()}}); {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"); GELOGW("Get input size failed");
return; 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); op_desc_info.input_size.emplace_back(input_size);
} }
for (size_t j = 0; j < op->GetOutputsSize(); ++j) { 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"); GELOGW("Get input size failed");
return; 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.output_size.emplace_back(output_size);
} }
op_desc_info.input_addrs = ModelUtils::GetInputDataAddrs(model_param, op); 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) { if (step_id != 0) {
GELOGI("step_id exists."); GELOGI("step_id exists.");
op_mapping_info.set_step_id_addr(static_cast<uint64_t>(step_id)); op_mapping_info.set_step_id_addr(static_cast<uint64_t>(step_id));
} else {
GELOGI("step_id is null.");
} }
if (loop_per_iter != 0) { if (loop_per_iter != 0) {
GELOGI("loop_per_iter exists."); GELOGI("loop_per_iter exists.");
op_mapping_info.set_iterations_per_loop_addr(static_cast<uint64_t>(loop_per_iter)); 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) { if (loop_cond != 0) {
GELOGI("loop_cond exists."); GELOGI("loop_cond exists.");
op_mapping_info.set_loop_cond_addr(static_cast<uint64_t>(loop_cond)); 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); PrintCheckLog(dump_list_key);
if (op_list_.empty()) { if (op_list_.empty()) {
GELOGW("op_list_ is empty"); GELOGD("op_list_ is empty");
} }
aicpu::dump::OpMappingInfo op_mapping_info; aicpu::dump::OpMappingInfo op_mapping_info;
@ -684,8 +676,6 @@ Status DataDumper::LoadDumpInfo() {
op_mapping_info.set_flag(kAicpuLoadFlag); op_mapping_info.set_flag(kAicpuLoadFlag);
op_mapping_info.set_dump_step(dump_properties_.GetDumpStep()); op_mapping_info.set_dump_step(dump_properties_.GetDumpStep());
SetOpMappingLoopAddr(global_step_, loop_per_iter_, loop_cond_, op_mapping_info); 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); auto ret = BuildTaskInfo(op_mapping_info);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ret, "Build task info failed"); 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() { Status DataDumper::UnloadDumpInfo() {
if (!load_flag_) { if (!load_flag_) {
GELOGI("No need to UnloadDumpInfo.");
load_flag_ = false; load_flag_ = false;
return SUCCESS; return SUCCESS;
} }
@ -838,7 +827,6 @@ Status DataDumper::UnloadDumpInfo() {
void DataDumper::PrintCheckLog(string &dump_list_key) { void DataDumper::PrintCheckLog(string &dump_list_key) {
std::set<std::string> model_list = dump_properties_.GetAllDumpModel(); std::set<std::string> model_list = dump_properties_.GetAllDumpModel();
if (model_list.empty()) { if (model_list.empty()) {
GELOGI("No model need dump.");
return; return;
} }

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save