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

!1456 日志整改

Browse Source 
Merge pull request !1456 from ldy2021/master
pull/1456/MERGE
计晨 4 years ago committed by Gitee
parent 0a7842cfa5 2252abcce8
commit 5057512666
31 changed files with 905 additions and 717 deletions
Show Stats Download Patch File Download Diff File

20
ge/hybrid/common/npu_memory_allocator.cc
Unescape View File

@ -41,8 +41,7 @@ NpuMemoryAllocator *NpuMemoryAllocator::GetAllocator() {
auto rt_result = rtGetDevice(&device_id); auto rt_result = rtGetDevice(&device_id);
if (rt_result != RT_ERROR_NONE) { if (rt_result != RT_ERROR_NONE) {
GELOGE(RT_FAILED, "[Get][Device] Failed, result:%d.", rt_result); GELOGE(RT_FAILED, "[Get][Device] Failed, result:%d.", rt_result);
REPORT_INNER_ERROR("E19999", "rtGetDevice failed when NpuMemoryAllocator %s, result:%d.", REPORT_INNER_ERROR("E19999", "rtGetDevice failed, result:%d.", rt_result);
__FUNCTION__, rt_result);
return nullptr; return nullptr;
} }
@ -62,8 +61,7 @@ void *NpuMemoryAllocator::Allocate(std::size_t size, AllocationAttr *attr) {
if (allocate_size == 0) { if (allocate_size == 0) {
GELOGE(MEMALLOC_FAILED, "[Check][Param:size_t]Memory size is 0, device_id = %u, size = %zu.", GELOGE(MEMALLOC_FAILED, "[Check][Param:size_t]Memory size is 0, device_id = %u, size = %zu.",
device_id_, allocate_size); device_id_, allocate_size);
REPORT_INNER_ERROR("E19999", "Memory size is 0, device_id = %u, size = %zu when %s.", REPORT_INNER_ERROR("E19999", "Memory size is 0, device_id = %u, size = %zu.", device_id_, allocate_size);
device_id_, allocate_size, __FUNCTION__);
return nullptr; return nullptr;
} }
@ -75,9 +73,9 @@ void *NpuMemoryAllocator::Allocate(std::size_t size, AllocationAttr *attr) {
} else { } else {
if (allocate_size > kMaxHbmMemorySize) { if (allocate_size > kMaxHbmMemorySize) {
GELOGE(PARAM_INVALID, "[Check][Param:size_t]Invalid HBM memory size: %zu bigger than limit:%lu, check invalid.", GELOGE(PARAM_INVALID, "[Check][Param:size_t]Invalid HBM memory size: %zu bigger than limit:%lu, check invalid.",
allocate_size, kMaxHbmMemorySize); allocate_size, kMaxHbmMemorySize);
REPORT_CALL_ERROR("E19999", "Invalid HBM memory size: %zu bigger than limit:%lu, check invalid when %s.", REPORT_CALL_ERROR("E19999", "Invalid HBM memory size: %zu bigger than limit:%lu, check invalid.",
allocate_size, kMaxHbmMemorySize, __FUNCTION__); allocate_size, kMaxHbmMemorySize);
return nullptr; return nullptr;
} }
void *try_reuse_addr = nullptr; void *try_reuse_addr = nullptr;
@ -96,10 +94,10 @@ void *NpuMemoryAllocator::Allocate(std::size_t size, AllocationAttr *attr) {
.Malloc(allocate_size, reinterpret_cast<uint8_t *>(try_reuse_addr), device_id_); .Malloc(allocate_size, reinterpret_cast<uint8_t *>(try_reuse_addr), device_id_);
} }
if (buffer == nullptr) { if (buffer == nullptr) {
GELOGE(MEMALLOC_FAILED, "[Malloc][Memory] Failed, device_id = %u, size = %zu.", GELOGE(MEMALLOC_FAILED, "[Malloc][Memory] Failed, device_id = %u, size = %zu",
device_id_, allocate_size); device_id_, allocate_size);
REPORT_CALL_ERROR("E19999", "malloc memory failed, device_id = %u, size = %zu when %s.", REPORT_CALL_ERROR("E19999", "malloc memory failed, device_id = %u, size = %zu",
device_id_, allocate_size, __FUNCTION__); device_id_, allocate_size);
return nullptr; return nullptr;
} }

4
ge/hybrid/common/tensor_value.cc
Unescape View File

@ -33,7 +33,7 @@ std::unique_ptr<TensorBuffer> TensorBuffer::Create(NpuMemoryAllocator *allocator
if (allocator == nullptr) { if (allocator == nullptr) {
GELOGE(INTERNAL_ERROR, "[Check][Param:NpuMemoryAllocator] allocator is NULL."); GELOGE(INTERNAL_ERROR, "[Check][Param:NpuMemoryAllocator] allocator is NULL.");
REPORT_INNER_ERROR("E19999", "input allocator is NULL, when %s.", __FUNCTION__); REPORT_INNER_ERROR("E19999", "input allocator is NULL.");
return nullptr; return nullptr;
} }
@ -44,7 +44,7 @@ std::unique_ptr<TensorBuffer> TensorBuffer::Create(NpuMemoryAllocator *allocator
buffer = allocator->Allocate(size, attr); buffer = allocator->Allocate(size, attr);
if (buffer == nullptr) { if (buffer == nullptr) {
GELOGE(MEMALLOC_FAILED, "[Allocate][Memory] Failed. size = %zu.", size); GELOGE(MEMALLOC_FAILED, "[Allocate][Memory] Failed. size = %zu.", size);
REPORT_CALL_ERROR("E19999", "allocate failed, size = %zu, when %s.", size, __FUNCTION__); REPORT_CALL_ERROR("E19999", "allocate failed, size = %zu.", size);
return nullptr; return nullptr;
} }

3
ge/hybrid/executor/hybrid_execution_context.cc
Unescape View File

@ -60,8 +60,7 @@ Status GraphExecutionContext::Synchronize(rtStream_t rt_stream) {
} }
GELOGE(RT_FAILED, "[Invoke][rtStreamSynchronize] failed, ret = %d", rt_ret); GELOGE(RT_FAILED, "[Invoke][rtStreamSynchronize] failed, ret = %d", rt_ret);
REPORT_CALL_ERROR("E19999", REPORT_CALL_ERROR("E19999", "invoke rtStreamSynchronize failed, ret = %d", rt_ret);
"invoke rtStreamSynchronize failed when GraphExecutionContext %s, ret = %d", __FUNCTION__, rt_ret);
return RT_FAILED; return RT_FAILED;
} }
} // namespace hybrid } // namespace hybrid

76
ge/hybrid/executor/hybrid_model_async_executor.cc
Unescape View File

@ -48,8 +48,7 @@ void HybridModelAsyncExecutor::SetModelId(uint32_t model_id) {
Status HybridModelAsyncExecutor::EnqueueData(const shared_ptr<InputDataWrapper> &data) { Status HybridModelAsyncExecutor::EnqueueData(const shared_ptr<InputDataWrapper> &data) {
if (data_inputer_->Push(data) != SUCCESS) { if (data_inputer_->Push(data) != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Data queue is full, please call again later when %s, model_id %u.", REPORT_CALL_ERROR("E19999", "Data queue is full, please call again later, model_id %u.", model_id_);
__FUNCTION__, model_id_);
GELOGE(domi::DATA_QUEUE_ISFULL, GELOGE(domi::DATA_QUEUE_ISFULL,
"[Push][Data] Data queue is full, please call again later, model_id %u ", model_id_); "[Push][Data] Data queue is full, please call again later, model_id %u ", model_id_);
return domi::DATA_QUEUE_ISFULL; return domi::DATA_QUEUE_ISFULL;
@ -62,8 +61,7 @@ Status HybridModelAsyncExecutor::Start(const std::shared_ptr<ModelListener> &lis
GELOGD("HybridModelExecutor::Start IN, has listener = %d", listener != nullptr); GELOGD("HybridModelExecutor::Start IN, has listener = %d", listener != nullptr);
std::lock_guard<std::mutex> lk(mu_); std::lock_guard<std::mutex> lk(mu_);
if (run_flag_) { if (run_flag_) {
REPORT_INNER_ERROR("E19999", REPORT_INNER_ERROR("E19999", "Model already started, model_id:%u.", model_id_);
"Model already started when HybridModelAsyncExecutor %s, model_id:%u.", __FUNCTION__, model_id_);
GELOGE(INTERNAL_ERROR, "[Check][RunState] Model already started, model_id:%u.", model_id_); GELOGE(INTERNAL_ERROR, "[Check][RunState] Model already started, model_id:%u.", model_id_);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -209,8 +207,7 @@ Status HybridModelAsyncExecutor::HandleResult(Status exec_ret,
if (exec_ret != SUCCESS) { if (exec_ret != SUCCESS) {
GELOGE(exec_ret, "[Check][Param:Status] failed to execute graph. model_id = %u", model_id_); GELOGE(exec_ret, "[Check][Param:Status] failed to execute graph. model_id = %u", model_id_);
REPORT_INNER_ERROR("E19999", REPORT_INNER_ERROR("E19999", "failed to execute graph. model_id = %u", model_id_);
"failed to execute graph when HybridModelAsyncExecutor %s. model_id = %u", __FUNCTION__, model_id_);
return OnComputeDone(data_id, INTERNAL_ERROR, output_tensor_info_list); return OnComputeDone(data_id, INTERNAL_ERROR, output_tensor_info_list);
} }
@ -247,11 +244,10 @@ Status HybridModelAsyncExecutor::SyncVarData() {
Status HybridModelAsyncExecutor::PrepareInputs(const InputData &current_data, HybridModelExecutor::ExecuteArgs &args) { Status HybridModelAsyncExecutor::PrepareInputs(const InputData &current_data, HybridModelExecutor::ExecuteArgs &args) {
if (current_data.blobs.size() < input_tensor_desc_.size()) { if (current_data.blobs.size() < input_tensor_desc_.size()) {
GELOGE(PARAM_INVALID, GELOGE(PARAM_INVALID,
"[Check][Size]Blob size mismatches, expect at least %zu, but got %zu, model_id = %u", "[Check][Size]Blob size mismatches, expect at least %zu, but got %zu, model_id = %u",
input_tensor_desc_.size(), current_data.blobs.size(), model_id_); input_tensor_desc_.size(), current_data.blobs.size(), model_id_);
REPORT_INNER_ERROR("E19999", REPORT_INNER_ERROR("E19999", "Blob size mismatches, expect at least %zu, but got %zu, model_id = %u.",
"Blob size mismatches, expect at least %zu, but got %zu when HybridModelAsyncExecutor %s, model_id = %u.", input_tensor_desc_.size(), current_data.blobs.size(), model_id_);
input_tensor_desc_.size(), current_data.blobs.size(), __FUNCTION__, model_id_);
return PARAM_INVALID; return PARAM_INVALID;
} }
@ -264,11 +260,10 @@ Status HybridModelAsyncExecutor::PrepareInputs(const InputData &current_data, Hy
if (is_input_dynamic_[input_index]) { if (is_input_dynamic_[input_index]) {
if (input_index >= current_data.shapes.size()) { if (input_index >= current_data.shapes.size()) {
GELOGE(PARAM_INVALID, GELOGE(PARAM_INVALID,
"[Check][Range]Shape index out of range, index = %zu, shape size = %zu model_id = %u.", "[Check][Range]Shape index out of range, index = %zu, shape size = %zu model_id = %u.",
input_index, current_data.shapes.size(), model_id_); input_index, current_data.shapes.size(), model_id_);
REPORT_INNER_ERROR("E19999", REPORT_INNER_ERROR("E19999", "Shape index out of range, index = %zu, shape size = %zu, model_id = %u.",
"Shape index out of range, index = %zu, shape size = %zu when HybridModelAsyncExecutor %s, model_id = %u.", input_index, current_data.shapes.size(), model_id_);
input_index, current_data.shapes.size(), __FUNCTION__, model_id_);
return PARAM_INVALID; return PARAM_INVALID;
} }
auto &tensor_desc = input_tensor_desc_[input_index]; auto &tensor_desc = input_tensor_desc_[input_index];
@ -283,12 +278,12 @@ Status HybridModelAsyncExecutor::PrepareInputs(const InputData &current_data, Hy
} }
// range[k].second can be -1 // range[k].second can be -1
if (shape.GetDim(k) < range[k].first || (range[k].second >= 0 && shape.GetDim(k) > range[k].second)) { if (shape.GetDim(k) < range[k].first || (range[k].second >= 0 && shape.GetDim(k) > range[k].second)) {
GELOGE(PARAM_INVALID, GELOGE(PARAM_INVALID, "[Check][Range]Dim out of range, shape idx = %zu, dim idx = %zu,"
"[Check][Range]Dim out of range, shape idx = %zu, dim idx = %zu, dim = %ld, range = [%ld, %ld], model_id = %u.", "dim = %ld, range = [%ld, %ld], model_id = %u.",
input_index, k, shape.GetDim(k), range[k].first, range[k].second, model_id_); input_index, k, shape.GetDim(k), range[k].first, range[k].second, model_id_);
REPORT_INNER_ERROR("E19999", REPORT_INNER_ERROR("E19999", "Dim out of range, shape idx = %zu, dim idx = %zu, dim = %ld,"
"Dim out of range, shape idx = %zu, dim idx = %zu, dim = %ld, range = [%ld, %ld], model_id = %u.", "range = [%ld, %ld], model_id = %u.",
input_index, k, shape.GetDim(k), range[k].first, range[k].second, model_id_); input_index, k, shape.GetDim(k), range[k].first, range[k].second, model_id_);
return PARAM_INVALID; return PARAM_INVALID;
} }
} }
@ -296,8 +291,9 @@ Status HybridModelAsyncExecutor::PrepareInputs(const InputData &current_data, Hy
args.input_desc[input_index] = tensor_desc; args.input_desc[input_index] = tensor_desc;
GELOGD("Update shape of input[%zu] to [%s]", input_index, tensor_desc->MutableShape().ToString().c_str()); GELOGD("Update shape of input[%zu] to [%s]", input_index, tensor_desc->MutableShape().ToString().c_str());
GE_CHK_GRAPH_STATUS_RET(TensorUtils::GetTensorMemorySizeInBytes(*tensor_desc, tensor_size), GE_CHK_GRAPH_STATUS_RET(TensorUtils::GetTensorMemorySizeInBytes(*tensor_desc, tensor_size),
"[Invoke][GetTensorMemorySizeInBytes]Failed to calc tensor size, index = %zu, shape = [%s], model_id = %u.", "[Invoke][GetTensorMemorySizeInBytes]Failed to calc tensor size,"
input_index, tensor_desc->GetShape().ToString().c_str(), model_id_); "index = %zu, shape = [%s], model_id = %u.",
input_index, tensor_desc->GetShape().ToString().c_str(), model_id_);
GELOGD("Input tensor[%zu] size = %zu", input_index, tensor_size); GELOGD("Input tensor[%zu] size = %zu", input_index, tensor_size);
} }
@ -316,11 +312,11 @@ Status HybridModelAsyncExecutor::PrepareInputs(const InputData &current_data, Hy
if (mem_size < data_buf.length) { if (mem_size < data_buf.length) {
REPORT_INNER_ERROR("E19999", REPORT_INNER_ERROR("E19999",
"input data size(%lu) does not match model required size(%lu) when %s, ret failed, model_id = %u.", "input data size(%lu) does not match model required size(%lu), ret failed, model_id = %u.",
data_buf.length, mem_size, __FUNCTION__, model_id_); data_buf.length, mem_size, model_id_);
GELOGE(PARAM_INVALID, GELOGE(PARAM_INVALID,
"[Check][Size]input data size(%lu) does not match model required size(%lu), ret failed, model_id = %u.", "[Check][Size]input data size(%lu) does not match model required size(%lu), ret failed, model_id = %u.",
data_buf.length, mem_size, model_id_); data_buf.length, mem_size, model_id_);
return PARAM_INVALID; return PARAM_INVALID;
} }
if (data_buf.length > 0) { if (data_buf.length > 0) {
@ -391,11 +387,11 @@ Status HybridModelAsyncExecutor::CopyOutputs(HybridModelExecutor::ExecuteArgs &a
std::vector<TensorValue> &output_tensors = args.outputs; std::vector<TensorValue> &output_tensors = args.outputs;
if (output_tensor_desc_list.size() != output_tensors.size()) { if (output_tensor_desc_list.size() != output_tensors.size()) {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR,
"[Check][Size]Output sizes mismatch. From op_desc = %zu, and from output tensors = %zu, model_id = %u.", "[Check][Size]Output sizes mismatch. From op_desc = %zu, and from output tensors = %zu, model_id = %u.",
output_tensor_desc_list.size(), output_tensors.size(), model_id_); output_tensor_desc_list.size(), output_tensors.size(), model_id_);
REPORT_INNER_ERROR("E19999", "Output sizes mismatch. From op_desc = %zu, and from output tensors = %zu, " REPORT_INNER_ERROR("E19999",
"when HybridModelAsyncExecutor %s, model_id = %u.", "Output sizes mismatch. From op_desc = %zu, and from output tensors = %zu, model_id = %u.",
output_tensor_desc_list.size(), output_tensors.size(), __FUNCTION__, model_id_); output_tensor_desc_list.size(), output_tensors.size(), model_id_);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -410,7 +406,7 @@ Status HybridModelAsyncExecutor::CopyOutputs(HybridModelExecutor::ExecuteArgs &a
tensor_desc->GetFormat(), tensor_desc->GetFormat(),
tensor_desc->GetDataType(), tensor_desc->GetDataType(),
output_size), output_size),
"Failed to calc tensor size for output[%zu]. shape = [%s], type = %s, format = %s", "[Calc][TensorMemSize]Failed for output[%zu]. shape = [%s], type = %s, format = %s",
i, i,
tensor_desc->GetShape().ToString().c_str(), tensor_desc->GetShape().ToString().c_str(),
TypeUtils::DataTypeToSerialString(tensor_desc->GetDataType()).c_str(), TypeUtils::DataTypeToSerialString(tensor_desc->GetDataType()).c_str(),
@ -427,12 +423,10 @@ Status HybridModelAsyncExecutor::CopyOutputs(HybridModelExecutor::ExecuteArgs &a
GE_CHECK_LE(output_size, UINT32_MAX); GE_CHECK_LE(output_size, UINT32_MAX);
if (output_tensor.GetSize() < static_cast<size_t>(output_size)) { if (output_tensor.GetSize() < static_cast<size_t>(output_size)) {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR,
"[Check][Size]output[%zu] tensor size(%zu) is not enough for output shape [%s], model_id = %u.", "[Check][Size]output[%zu] tensor size(%zu) is not enough for output shape [%s], model_id = %u.",
i, output_tensor.GetSize(), tensor_desc->GetShape().ToString().c_str(), model_id_); i, output_tensor.GetSize(), tensor_desc->GetShape().ToString().c_str(), model_id_);
REPORT_INNER_ERROR("E19999", REPORT_INNER_ERROR("E19999", "output[%zu] tensor size(%zu) is not enough for output shape [%s] model_id = %u",
"output[%zu] tensor size(%zu) is not enough for output shape [%s] model_id = %u," i, output_tensor.GetSize(), tensor_desc->GetShape().ToString().c_str(), model_id_);
" when HybridModelAsyncExecutor %s.",
i, output_tensor.GetSize(), tensor_desc->GetShape().ToString().c_str(), model_id_, __FUNCTION__);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -569,7 +563,7 @@ Status HybridModelAsyncExecutor::DumpOpDebug() {
} }
data_dumper_.SetLoopAddr(global_step, loop_per_iter, loop_cond); data_dumper_.SetLoopAddr(global_step, loop_per_iter, loop_cond);
GE_CHK_STATUS_RET(data_dumper_.LoadDumpInfo(), GE_CHK_STATUS_RET(data_dumper_.LoadDumpInfo(),
"[Invoke][LoadDumpInfo] failed in hybrid engine, model_id = %u.", model_id_); "[Invoke][LoadDumpInfo] failed in hybrid engine, model_id = %u.", model_id_);
GELOGD("Dump op debug SUCCESS in hybrid engine"); GELOGD("Dump op debug SUCCESS in hybrid engine");
} }
return SUCCESS; return SUCCESS;

24
ge/hybrid/executor/hybrid_model_pipeline_executor.cc
Unescape View File

@ -69,10 +69,8 @@ Status StageExecutor::Start(const std::vector<TensorValue> &inputs, const std::v
task_queue_.Pop(task_info); task_queue_.Pop(task_info);
GELOGD("[Executor: %d] Got task, stage = %d, iteration = %ld", id_, task_info.stage, task_info.iteration); GELOGD("[Executor: %d] Got task, stage = %d, iteration = %ld", id_, task_info.stage, task_info.iteration);
if (task_info.iteration >= pipe_config_->iteration_end) { if (task_info.iteration >= pipe_config_->iteration_end) {
GELOGE(INTERNAL_ERROR, "[Check][Range][Executor: %d] Unexpected iteration: %ld.", GELOGE(INTERNAL_ERROR, "[Check][Range][Executor: %d] Unexpected iteration: %ld.", id_, task_info.iteration);
id_, task_info.iteration); REPORT_INNER_ERROR("E19999", "[Executor: %d] Unexpected iteration: %ld.", id_, task_info.iteration);
REPORT_INNER_ERROR("E19999", "[Executor: %d] Unexpected iteration: %ld when StageExecutor %s.",
id_, task_info.iteration, __FUNCTION__);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -89,7 +87,7 @@ Status StageExecutor::Start(const std::vector<TensorValue> &inputs, const std::v
if (task_info.stage == 0) { if (task_info.stage == 0) {
GELOGD("[Executor: %d] To ResetExecutionContext", id_); GELOGD("[Executor: %d] To ResetExecutionContext", id_);
GE_CHK_STATUS_RET(ResetExecutionContext(context_), GE_CHK_STATUS_RET(ResetExecutionContext(context_),
"[Invoke][ResetExecutionContext][Executor: %d] Failed to reset context", id_); "[Invoke][ResetExecutionContext][Executor: %d] Failed to reset context", id_);
context_.iteration = task_info.iteration; context_.iteration = task_info.iteration;
GE_CHK_STATUS_RET_NOLOG(SetInputs(inputs, input_desc)); GE_CHK_STATUS_RET_NOLOG(SetInputs(inputs, input_desc));
} }
@ -107,10 +105,10 @@ Status StageExecutor::Start(const std::vector<TensorValue> &inputs, const std::v
auto sync_result = Synchronize(); auto sync_result = Synchronize();
if (sync_result != SUCCESS) { if (sync_result != SUCCESS) {
GELOGE(sync_result, GELOGE(sync_result,
"[Invoke][Synchronize][Executor: %d] Failed to sync result:%d. iteration = %ld", "[Invoke][Synchronize][Executor: %d] Failed to sync result:%d. iteration = %ld",
id_, sync_result, task_info.iteration); id_, sync_result, task_info.iteration);
REPORT_CALL_ERROR("E19999", "[Executor: %d] Failed to sync result:%d when StageExecutor %s. iteration = %ld", REPORT_CALL_ERROR("E19999", "[Executor: %d] Failed to sync result:%d. iteration = %ld",
id_, sync_result, __FUNCTION__, task_info.iteration); id_, sync_result, task_info.iteration);
context_.profiler->Dump(std::cout); context_.profiler->Dump(std::cout);
context_.callback_manager->Destroy(); context_.callback_manager->Destroy();
RuntimeInferenceContext::DestroyContext(std::to_string(context_.context_id)); RuntimeInferenceContext::DestroyContext(std::to_string(context_.context_id));
@ -260,8 +258,7 @@ Status HybridModelPipelineExecutor::Execute(HybridModelExecutor::ExecuteArgs &ar
auto ret = futures[i].get(); auto ret = futures[i].get();
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ret, "[Check][Result][Executor: %zu] Failed to schedule tasks.", i); GELOGE(ret, "[Check][Result][Executor: %zu] Failed to schedule tasks.", i);
REPORT_INNER_ERROR("E19999", "[Executor: %zu] Failed to schedule tasks when HybridModelPipelineExecutor %s.", REPORT_INNER_ERROR("E19999", "[Executor: %zu] Failed to schedule tasks.", i);
i, __FUNCTION__);
has_error = true; has_error = true;
continue; continue;
} }
@ -270,8 +267,7 @@ Status HybridModelPipelineExecutor::Execute(HybridModelExecutor::ExecuteArgs &ar
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ret, "[Invoke][Synchronize] failed for [Executor: %zu].", i); GELOGE(ret, "[Invoke][Synchronize] failed for [Executor: %zu].", i);
REPORT_CALL_ERROR("E19999", "[Executor: %zu] failed to Synchronize result when HybridModelPipelineExecutor %s.", REPORT_CALL_ERROR("E19999", "[Executor: %zu] failed to Synchronize result.", i);
i, __FUNCTION__);
has_error = true; has_error = true;
continue; continue;
} }
@ -288,7 +284,7 @@ Status HybridModelPipelineExecutor::Execute(HybridModelExecutor::ExecuteArgs &ar
if (has_error) { if (has_error) {
GELOGE(FAILED, "[Check][Error]Error occurred while execution."); GELOGE(FAILED, "[Check][Error]Error occurred while execution.");
REPORT_INNER_ERROR("E19999", "Error occurred while execution when HybridModelPipelineExecutor %s.", __FUNCTION__); REPORT_INNER_ERROR("E19999", "Error occurred while execution.");
return FAILED; return FAILED;
} }

7
ge/hybrid/executor/hybrid_profiler.cc
Unescape View File

@ -41,7 +41,7 @@ void HybridProfiler::RecordEvent(EventType event_type, const char *fmt, ...) {
char buf[kEventDescMax]; char buf[kEventDescMax];
if (vsnprintf_s(buf, kEventDescMax, kEventDescMax - 1, fmt, args) == -1) { if (vsnprintf_s(buf, kEventDescMax, kEventDescMax - 1, fmt, args) == -1) {
GELOGE(FAILED, "[Parse][Param:fmt]Format %s failed.", fmt); GELOGE(FAILED, "[Parse][Param:fmt]Format %s failed.", fmt);
REPORT_CALL_ERROR("E19999", "Parse Format %s failed when HybridProfiler %s.", fmt, __FUNCTION__); REPORT_CALL_ERROR("E19999", "Parse Format %s failed.", fmt);
va_end(args); va_end(args);
return; return;
} }
@ -50,9 +50,8 @@ void HybridProfiler::RecordEvent(EventType event_type, const char *fmt, ...) {
auto index = counter_++; auto index = counter_++;
if (index >= static_cast<int>(events_.size())) { if (index >= static_cast<int>(events_.size())) {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR,
"[Check][Range]index out of range. index = %d, max event size = %zu", index, events_.size()); "[Check][Range]index out of range. index = %d, max event size = %zu", index, events_.size());
REPORT_INNER_ERROR("E19999", "index out of range when HybridProfiler %s. index = %d, max event size = %zu", REPORT_INNER_ERROR("E19999", "index out of range. index = %d, max event size = %zu", index, events_.size());
__FUNCTION__, index, events_.size());
return; return;
} }
auto &evt = events_[index]; auto &evt = events_[index];

2
ge/hybrid/executor/node_done_manager.cc
Unescape View File

@ -29,7 +29,7 @@ bool NodeDoneManager::Cond::Await() {
std::chrono::seconds(kDefaultWaitTimeoutInSec), std::chrono::seconds(kDefaultWaitTimeoutInSec),
[&]() { return is_released_ || is_cancelled_; })) { [&]() { return is_released_ || is_cancelled_; })) {
GELOGE(INTERNAL_ERROR, "[Invoke][wait_for]Wait timed out."); GELOGE(INTERNAL_ERROR, "[Invoke][wait_for]Wait timed out.");
REPORT_INNER_ERROR("E19999", "wait timed out[%d] when %s.", kDefaultWaitTimeoutInSec, __FUNCTION__); REPORT_INNER_ERROR("E19999", "wait timed out[%d].", kDefaultWaitTimeoutInSec);
return false; return false;
} }

21
ge/hybrid/executor/node_state.cc
Unescape View File

@ -67,10 +67,8 @@ Status ShapeInferenceState::UpdateInputShape(int idx, const GeTensorDesc &target
Format format = input_desc.GetFormat(); Format format = input_desc.GetFormat();
DataType data_type = input_desc.GetDataType(); DataType data_type = input_desc.GetDataType();
if (TensorUtils::CalcTensorMemSize(shape, format, data_type, tensor_size) != GRAPH_SUCCESS) { if (TensorUtils::CalcTensorMemSize(shape, format, data_type, tensor_size) != GRAPH_SUCCESS) {
GELOGE(FAILED, "[Invoke][CalcTensorMemSize] failed for [%s].", GELOGE(FAILED, "[Invoke][CalcTensorMemSize] failed for [%s].", node_item.NodeName().c_str());
node_item.NodeName().c_str()); REPORT_CALL_ERROR("E19999", "CalcTensorMemSize failed for [%s].", node_item.NodeName().c_str());
REPORT_CALL_ERROR("E19999", "CalcTensorMemSize failed for [%s] when ShapeInferenceState %s.",
node_item.NodeName().c_str(), __FUNCTION__);
return FAILED; return FAILED;
} }
} }
@ -124,19 +122,15 @@ Status ShapeInferenceState::AwaitShapesReady(const GraphExecutionContext &contex
} }
if (context.GetStatus() != SUCCESS) { if (context.GetStatus() != SUCCESS) {
GELOGE(FAILED, "[Check][Status][%s] Await pending shape cancelled.", GELOGE(FAILED, "[Check][Status][%s] Await pending shape cancelled.", node_item.NodeName().c_str());
node_item.NodeName().c_str()); REPORT_CALL_ERROR("E19999", "[%s] Await pending shape cancelled.", node_item.NodeName().c_str());
REPORT_CALL_ERROR("E19999", "[%s] Await pending shape cancelled when %s.",
node_item.NodeName().c_str(), __FUNCTION__);
break; break;
} }
} }
if (!wait_success) { if (!wait_success) {
GELOGE(FAILED, "[Check][Status][%s] Wait for shape timeout:%d.", GELOGE(FAILED, "[Check][Status][%s] Wait for shape timeout:%d.", node_item.NodeName().c_str(), kWaitInternal);
node_item.NodeName().c_str(), kWaitInternal); REPORT_CALL_ERROR("E19999", "[%s] Wait for shape timeout:%d.", node_item.NodeName().c_str(), kWaitInternal);
REPORT_CALL_ERROR("E19999", "[%s] Wait for shape timeout:%d when %s.",
node_item.NodeName().c_str(), kWaitInternal, __FUNCTION__);
return FAILED; return FAILED;
} }
} }
@ -240,8 +234,7 @@ Status NodeState::AwaitInputTensors(GraphExecutionContext &context) const {
Status NodeState::WaitForPrepareDone() { Status NodeState::WaitForPrepareDone() {
if (prepare_future_.valid()) { if (prepare_future_.valid()) {
GELOGD("[%s] Start to wait for prepare future.", GetName().c_str()); GELOGD("[%s] Start to wait for prepare future.", GetName().c_str());
GE_CHK_STATUS_RET(prepare_future_.get(), GE_CHK_STATUS_RET(prepare_future_.get(), "[Check][Status][%s] PreRun failed.", GetName().c_str());
"[Check][Status][%s] PreRun failed.", GetName().c_str());
} }
return SUCCESS; return SUCCESS;

5
ge/hybrid/executor/rt_callback_manager.cc
Unescape View File

@ -28,7 +28,7 @@ Status CallbackManager::RegisterCallback(rtStream_t stream, rtCallback_t callbac
auto rt_ret = rtEventRecord(event, stream); auto rt_ret = rtEventRecord(event, stream);
if (rt_ret != RT_ERROR_NONE) { if (rt_ret != RT_ERROR_NONE) {
GELOGE(RT_FAILED, "[Invoke][rtEventRecord] failed, error code = %d", rt_ret); GELOGE(RT_FAILED, "[Invoke][rtEventRecord] failed, error code = %d", rt_ret);
REPORT_CALL_ERROR("E19999", "Invoke rtEventRecord failed when %s, error code = %d", __FUNCTION__, rt_ret); REPORT_CALL_ERROR("E19999", "Invoke rtEventRecord failed, error code = %d", rt_ret);
(void) rtEventDestroy(event); (void) rtEventDestroy(event);
return RT_FAILED; return RT_FAILED;
} }
@ -76,8 +76,7 @@ Status CallbackManager::CallbackProcess(rtContext_t context) {
auto rt_err = rtEventSynchronize(event); auto rt_err = rtEventSynchronize(event);
if (rt_err != RT_ERROR_NONE) { if (rt_err != RT_ERROR_NONE) {
GELOGE(RT_FAILED, "[Invoke][rtEventSynchronize] failed. ret = %d", rt_err); GELOGE(RT_FAILED, "[Invoke][rtEventSynchronize] failed. ret = %d", rt_err);
REPORT_CALL_ERROR("E19999", REPORT_CALL_ERROR("E19999", "Invoke rtEventSynchronize failed, ret = %d.", rt_err);
"Invoke rtEventSynchronize failed when CallbackManager %s, ret = %d.", __FUNCTION__, rt_err);
GE_CHK_RT(rtEventDestroy(event)); GE_CHK_RT(rtEventDestroy(event));
return RT_FAILED; return RT_FAILED;
} }

26
ge/hybrid/executor/subgraph_context.cc
Unescape View File

@ -50,11 +50,10 @@ NodeStatePtr SubgraphContext::GetOrCreateNodeState(const NodeItem *node_item) {
Status SubgraphContext::SetInput(int index, const TensorValue &tensor) { Status SubgraphContext::SetInput(int index, const TensorValue &tensor) {
if (static_cast<size_t>(index) >= all_inputs_.size()) { if (static_cast<size_t>(index) >= all_inputs_.size()) {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR,
"[Check][Param:index]input index out of range. all input num = %zu, input index = %d", "[Check][Param:index]input index out of range. all input num = %zu, input index = %d",
all_inputs_.size(), index); all_inputs_.size(), index);
REPORT_INNER_ERROR("E19999", REPORT_INNER_ERROR("E19999", "input param index out of range, all input num = %zu, input index = %d.",
"input param index out of range when SubgraphContext %s, all input num = %zu, input index = %d.", all_inputs_.size(), index);
__FUNCTION__, all_inputs_.size(), index);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
all_inputs_[index] = tensor; all_inputs_[index] = tensor;
@ -69,12 +68,11 @@ Status SubgraphContext::SetInput(const NodeItem &node_item, int input_index, con
Status SubgraphContext::SetOutput(const NodeItem &node_item, int output_index, const TensorValue &tensor) { Status SubgraphContext::SetOutput(const NodeItem &node_item, int output_index, const TensorValue &tensor) {
auto index = node_item.output_start + output_index; auto index = node_item.output_start + output_index;
if ((output_index >= node_item.num_outputs) || (static_cast<size_t>(index) >= all_outputs_.size())) { if ((output_index >= node_item.num_outputs) || (static_cast<size_t>(index) >= all_outputs_.size())) {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR, "[Check][Param:output_index]output index out of range. all output num = %zu,"
"[Check][Param:output_index]output index out of range. all output num = %zu, node_item = %s," "node_item = %s, output index = %d.",
"output index = %d.", all_outputs_.size(), node_item.DebugString().c_str(), output_index); all_outputs_.size(), node_item.DebugString().c_str(), output_index);
REPORT_INNER_ERROR("E19999", "output index out of range when SubgraphContext %s. " REPORT_INNER_ERROR("E19999", "output index out of range. all output num = %zu, node_item = %s, output index = %d.",
"all output num = %zu, node_item = %s, output index = %d.", all_outputs_.size(), node_item.DebugString().c_str(), output_index);
__FUNCTION__, all_outputs_.size(), node_item.DebugString().c_str(), output_index);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -130,9 +128,9 @@ Status SubgraphContext::Await(const NodePtr &node) {
void SubgraphContext::OnError(Status error) { void SubgraphContext::OnError(Status error) {
if (error != END_OF_SEQUENCE) { if (error != END_OF_SEQUENCE) {
GELOGE(error, "[Check][Param:error][%s] Error:%d occurred while executing graph.", GELOGE(error, "[Check][Param:error][%s] Error:%d occurred while executing graph.",
graph_item_->GetName().c_str(), error); graph_item_->GetName().c_str(), error);
REPORT_INNER_ERROR("E19999", "[%s] Error:%d occurred while executing graph when SubgraphContext %s.", REPORT_INNER_ERROR("E19999", "[%s] Error:%d occurred while executing graph.",
graph_item_->GetName().c_str(), error, __FUNCTION__); graph_item_->GetName().c_str(), error);
} }
node_done_manager_.Destroy(); node_done_manager_.Destroy();
} }

108
ge/hybrid/executor/subgraph_executor.cc
Unescape View File

@ -69,12 +69,11 @@ Status SubgraphExecutor::InitInputsForUnknownShape(const std::vector<TensorValue
auto input_nodes = graph_item_->GetInputNodes(); auto input_nodes = graph_item_->GetInputNodes();
if (inputs.size() < input_nodes.size()) { if (inputs.size() < input_nodes.size()) {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR,
"[Check][Size][%s] Number of inputs [%zu] is not sufficient for subgraph which needs [%zu] inputs.", "[Check][Size][%s] Number of inputs [%zu] is not sufficient for subgraph which needs [%zu] inputs.",
graph_item_->GetName().c_str(), inputs.size(), input_nodes.size()); graph_item_->GetName().c_str(), inputs.size(), input_nodes.size());
REPORT_INNER_ERROR("E19999", REPORT_INNER_ERROR("E19999",
"[%s] Number of inputs [%zu] is not sufficient for subgraph which needs [%zu] inputs," "[%s] Number of inputs [%zu] is not sufficient for subgraph which needs [%zu] inputs.",
"check invalid when SubgraphExecutor %s.", graph_item_->GetName().c_str(), inputs.size(), input_nodes.size());
graph_item_->GetName().c_str(), inputs.size(), input_nodes.size(), __FUNCTION__);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -93,7 +92,8 @@ Status SubgraphExecutor::InitInputsForUnknownShape(const std::vector<TensorValue
input_tensor.DebugString().c_str()); input_tensor.DebugString().c_str());
GE_CHK_STATUS_RET(subgraph_context_->SetInput(*input_node, kDataInputIndex, input_tensor), GE_CHK_STATUS_RET(subgraph_context_->SetInput(*input_node, kDataInputIndex, input_tensor),
"[Invoke][SetInput] failed for grap_item[%s] input tensor[%zu]", graph_item_->GetName().c_str(), i); "[Invoke][SetInput] failed for grap_item[%s] input tensor[%zu]",
graph_item_->GetName().c_str(), i);
if (force_infer_shape_ || input_node->is_dynamic) { if (force_infer_shape_ || input_node->is_dynamic) {
GELOGD("[%s] Start to update input[%zu] for subgraph data node.", graph_item_->GetName().c_str(), i); GELOGD("[%s] Start to update input[%zu] for subgraph data node.", graph_item_->GetName().c_str(), i);
@ -115,13 +115,12 @@ Status SubgraphExecutor::InitInputsForKnownShape(const std::vector<TensorValue>
for (size_t i = 0; i < input_index_mapping.size(); ++i) { for (size_t i = 0; i < input_index_mapping.size(); ++i) {
auto &parent_input_index = input_index_mapping[i]; auto &parent_input_index = input_index_mapping[i];
if (static_cast<size_t>(parent_input_index) >= inputs.size()) { if (static_cast<size_t>(parent_input_index) >= inputs.size()) {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR, "[Check][Size][%s] Number of inputs [%zu] is not sufficient for subgraph"
"[Check][Size][%s] Number of inputs [%zu] is not sufficient for subgraph which needs at lease [%d] inputs", "which needs at lease [%d] inputs", graph_item_->GetName().c_str(), inputs.size(),
graph_item_->GetName().c_str(), inputs.size(), parent_input_index + 1); parent_input_index + 1);
REPORT_INNER_ERROR("E19999", REPORT_INNER_ERROR("E19999", "[%s] Number of inputs [%zu] is not sufficient for subgraph"
"[%s] Number of inputs [%zu] is not sufficient for subgraph which needs at lease [%d] inputs," "which needs at lease [%d] inputs",
"check invalid when %s.", graph_item_->GetName().c_str(), inputs.size(), parent_input_index + 1);
graph_item_->GetName().c_str(), inputs.size(), parent_input_index + 1, __FUNCTION__);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -144,7 +143,7 @@ Status SubgraphExecutor::ExecuteAsync(const std::vector<TensorValue> &inputs,
GE_CHK_STATUS_RET(Init(inputs, input_desc), "[Invoke][Init]failed for [%s].", graph_item_->GetName().c_str()); GE_CHK_STATUS_RET(Init(inputs, input_desc), "[Invoke][Init]failed for [%s].", graph_item_->GetName().c_str());
if (!outputs.empty()) { if (!outputs.empty()) {
GE_CHK_STATUS_RET(EnableOutputZeroCopy(outputs), GE_CHK_STATUS_RET(EnableOutputZeroCopy(outputs),
"[Invoke][EnableOutputZeroCopy] Failed by user provided outputs."); "[Invoke][EnableOutputZeroCopy] Failed by user provided outputs.");
} }
if (!graph_item_->IsDynamic()) { if (!graph_item_->IsDynamic()) {
return ExecuteAsyncForKnownShape(inputs); return ExecuteAsyncForKnownShape(inputs);
@ -163,10 +162,10 @@ Status SubgraphExecutor::ExecuteAsync(const std::vector<TensorValue> &inputs,
Status SubgraphExecutor::ExecuteAsyncForKnownShape(const std::vector<TensorValue> &inputs) { Status SubgraphExecutor::ExecuteAsyncForKnownShape(const std::vector<TensorValue> &inputs) {
GELOGD("[%s] subgraph is not dynamic.", graph_item_->GetName().c_str()); GELOGD("[%s] subgraph is not dynamic.", graph_item_->GetName().c_str());
if (graph_item_->GetAllNodes().size() != 1) { if (graph_item_->GetAllNodes().size() != 1) {
GELOGE(INTERNAL_ERROR, REPORT_INNER_ERROR("E19999", "[%s] Invalid known shape subgraph. node size = %zu",
"[%s] Invalid known shape subgraph. node size = %zu", graph_item_->GetName().c_str(), graph_item_->GetAllNodes().size());
graph_item_->GetName().c_str(), GELOGE(INTERNAL_ERROR, "[Check][Size][%s] Invalid known shape subgraph. node size = %zu",
graph_item_->GetAllNodes().size()); graph_item_->GetName().c_str(), graph_item_->GetAllNodes().size());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -198,12 +197,12 @@ Status SubgraphExecutor::ExecuteAsync(TaskContext &task_context) {
input_desc.emplace_back(task_context.GetInputDesc(i)); input_desc.emplace_back(task_context.GetInputDesc(i));
} }
GE_CHK_STATUS_RET(ExecuteAsync(inputs, input_desc), GE_CHK_STATUS_RET(ExecuteAsync(inputs, input_desc), "[Invoke][ExecuteAsync] failed for [%s].",
"[Invoke][ExecuteAsync] failed for [%s].", graph_item_->GetName().c_str()); graph_item_->GetName().c_str());
GE_CHK_STATUS_RET(SetOutputsToParentNode(task_context), GE_CHK_STATUS_RET(SetOutputsToParentNode(task_context),
"[Invoke][SetOutputsToParentNode][%s] Failed to set output shapes to parent node.", "[Invoke][SetOutputsToParentNode][%s] Failed to set output shapes to parent node.",
graph_item_->GetName().c_str()); graph_item_->GetName().c_str());
return SUCCESS; return SUCCESS;
} }
@ -243,7 +242,7 @@ Status SubgraphExecutor::PrepareNodes(int group) {
if (node_item.kernel_task == nullptr) { if (node_item.kernel_task == nullptr) {
GELOGW("[%s] Node of static shape got no task.", node_item.NodeName().c_str()); GELOGW("[%s] Node of static shape got no task.", node_item.NodeName().c_str());
GE_CHK_STATUS_RET(TaskCompileEngine::Compile(*p_node_state, context_), GE_CHK_STATUS_RET(TaskCompileEngine::Compile(*p_node_state, context_),
"[Invoke][Compile] failed for [%s].", p_node_state->GetName().c_str()); "[Invoke][Compile] failed for [%s].", p_node_state->GetName().c_str());
} else { } else {
node_state->SetKernelTask(node_item.kernel_task); node_state->SetKernelTask(node_item.kernel_task);
} }
@ -253,8 +252,7 @@ Status SubgraphExecutor::PrepareNodes(int group) {
const auto &task = node_state->GetKernelTask(); const auto &task = node_state->GetKernelTask();
if (task == nullptr) { if (task == nullptr) {
GELOGE(INTERNAL_ERROR, "[Get][KernelTask] failed for[%s], NodeTask is null.", node_state->GetName().c_str()); GELOGE(INTERNAL_ERROR, "[Get][KernelTask] failed for[%s], NodeTask is null.", node_state->GetName().c_str());
REPORT_CALL_ERROR("E19999", "invoke GetKernelTask failed for %s when %s, nodetask is null.", REPORT_CALL_ERROR("E19999", "GetKernelTask failed for %s, nodetask is null.", node_state->GetName().c_str());
node_state->GetName().c_str(), __FUNCTION__);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
auto shared_task_context = std::shared_ptr<TaskContext>(unique_task_context.release()); auto shared_task_context = std::shared_ptr<TaskContext>(unique_task_context.release());
@ -268,9 +266,9 @@ Status SubgraphExecutor::PrepareNodes(int group) {
return SUCCESS; return SUCCESS;
} }
GELOGE(INTERNAL_ERROR, "[Check][State][%s] Error occurs while launching tasks. quit from preparing nodes.", GELOGE(INTERNAL_ERROR, "[Check][State][%s] Error occurs while launching tasks. quit from preparing nodes.",
graph_item_->GetName().c_str()); graph_item_->GetName().c_str());
REPORT_INNER_ERROR("E19999", "[%s] Error occurs while launching tasks. quit from preparing nodes when %s.", REPORT_INNER_ERROR("E19999", "[%s] Error occurs while launching tasks. quit from preparing nodes.",
graph_item_->GetName().c_str(), __FUNCTION__); graph_item_->GetName().c_str());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -283,9 +281,9 @@ Status SubgraphExecutor::PrepareNodes(int group) {
Status SubgraphExecutor::InferShape(ShapeInferenceEngine *shape_inference_engine, NodeState &node_state) const { Status SubgraphExecutor::InferShape(ShapeInferenceEngine *shape_inference_engine, NodeState &node_state) const {
HYBRID_CHK_STATUS_RET(shape_inference_engine->InferShape(node_state), HYBRID_CHK_STATUS_RET(shape_inference_engine->InferShape(node_state),
"[Invoke][InferShape] failed for [%s].", node_state.GetName().c_str()); "[Invoke][InferShape] failed for [%s].", node_state.GetName().c_str());
HYBRID_CHK_STATUS_RET(shape_inference_engine->PropagateOutputShapes(node_state), HYBRID_CHK_STATUS_RET(shape_inference_engine->PropagateOutputShapes(node_state),
"[Invoke][PropagateOutputShapes] failed for [%s].", node_state.GetName().c_str()); "[Invoke][PropagateOutputShapes] failed for [%s].", node_state.GetName().c_str());
return SUCCESS; return SUCCESS;
} }
@ -293,7 +291,7 @@ Status SubgraphExecutor::PrepareForExecution(GraphExecutionContext *ctx, NodeSta
auto &node_item = *node_state.GetNodeItem(); auto &node_item = *node_state.GetNodeItem();
if (node_item.kernel_task == nullptr) { if (node_item.kernel_task == nullptr) {
GE_CHK_STATUS_RET(TaskCompileEngine::Compile(node_state, ctx), GE_CHK_STATUS_RET(TaskCompileEngine::Compile(node_state, ctx),
"[Invoke][Compile] Failed for node[%s]", node_state.GetName().c_str()); "[Invoke][Compile] Failed for node[%s]", node_state.GetName().c_str());
} else { } else {
node_state.SetKernelTask(node_item.kernel_task); node_state.SetKernelTask(node_item.kernel_task);
} }
@ -302,8 +300,7 @@ Status SubgraphExecutor::PrepareForExecution(GraphExecutionContext *ctx, NodeSta
const auto &task = node_state.GetKernelTask(); const auto &task = node_state.GetKernelTask();
if (task == nullptr) { if (task == nullptr) {
GELOGE(INTERNAL_ERROR, "[Invoke][GetKernelTask] failed for[%s], NodeTask is null.", node_state.GetName().c_str()); GELOGE(INTERNAL_ERROR, "[Invoke][GetKernelTask] failed for[%s], NodeTask is null.", node_state.GetName().c_str());
REPORT_CALL_ERROR("E19999", "invoke GetKernelTask failed for %s, NodeTask is null when %s.", REPORT_CALL_ERROR("E19999", "invoke GetKernelTask failed for %s, NodeTask is null.", node_state.GetName().c_str());
node_state.GetName().c_str(), __FUNCTION__);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
auto shared_task_context = std::shared_ptr<TaskContext>(unique_task_context.release()); auto shared_task_context = std::shared_ptr<TaskContext>(unique_task_context.release());
@ -320,7 +317,7 @@ Status SubgraphExecutor::LaunchTasks() {
NodeState *node_state = nullptr; NodeState *node_state = nullptr;
if (!ready_queue_.Pop(node_state)) { if (!ready_queue_.Pop(node_state)) {
GELOGE(INTERNAL_ERROR, "[Invoke][Pop] failed for [%s].", graph_item_->GetName().c_str()); GELOGE(INTERNAL_ERROR, "[Invoke][Pop] failed for [%s].", graph_item_->GetName().c_str());
REPORT_CALL_ERROR("E19999", "invoke pop failed for %s when %s", graph_item_->GetName().c_str(), __FUNCTION__); REPORT_CALL_ERROR("E19999", "invoke pop failed for %s.", graph_item_->GetName().c_str());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -345,7 +342,7 @@ Status SubgraphExecutor::LaunchTasks() {
GE_CHECK_NOTNULL(shared_task_context); GE_CHECK_NOTNULL(shared_task_context);
shared_task_context->SetForceInferShape(force_infer_shape_); shared_task_context->SetForceInferShape(force_infer_shape_);
HYBRID_CHK_STATUS_RET(ExecutionEngine::ExecuteAsync(*node_state, shared_task_context, *context_), HYBRID_CHK_STATUS_RET(ExecutionEngine::ExecuteAsync(*node_state, shared_task_context, *context_),
"[Invoke][ExecuteAsync] failed for [%s].", node_state->GetName().c_str()); "[Invoke][ExecuteAsync] failed for [%s].", node_state->GetName().c_str());
GELOGD("[%s] Done executing node successfully.", node_state->GetName().c_str()); GELOGD("[%s] Done executing node successfully.", node_state->GetName().c_str());
} }
} }
@ -370,8 +367,8 @@ Status SubgraphExecutor::ScheduleTasks(int group) {
return ret; return ret;
} }
GE_CHK_STATUS_RET(prepare_future.get(), GE_CHK_STATUS_RET(prepare_future.get(), "[Invoke][get] [%s] Error occurred in task preparation.",
"[Invoke][get] [%s] Error occurred in task preparation.", graph_item_->GetName().c_str()); graph_item_->GetName().c_str());
GELOGD("[%s] Done launching all tasks successfully.", graph_item_->GetName().c_str()); GELOGD("[%s] Done launching all tasks successfully.", graph_item_->GetName().c_str());
return SUCCESS; return SUCCESS;
@ -386,14 +383,13 @@ Status SubgraphExecutor::GetOutputs(vector<TensorValue> &outputs, std::vector<Co
// copy output data from op to designated position // copy output data from op to designated position
GE_CHK_STATUS_RET(graph_item_->GetOutputDescList(output_desc), GE_CHK_STATUS_RET(graph_item_->GetOutputDescList(output_desc),
"[Invoke][GetOutputDescList][%s] Failed to get output tensor desc.", graph_item_->GetName().c_str()); "[Invoke][GetOutputDescList][%s] Failed to get output tensor desc.",
graph_item_->GetName().c_str());
if (outputs.size() != output_desc.size()) { if (outputs.size() != output_desc.size()) {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR, "[Check][Size]Number of outputs(%zu) mismatch number of output_desc(%zu).",
"[Check][Size]Number of outputs(%zu) mismatch number of output_desc(%zu).", outputs.size(), output_desc.size());
outputs.size(), output_desc.size()); REPORT_INNER_ERROR("E19999", "Number of outputs(%zu) mismatch number of output_desc(%zu).",
REPORT_INNER_ERROR("E19999", "Number of outputs(%zu) mismatch number of output_desc(%zu)," outputs.size(), output_desc.size());
"check invlid when SubgraphExecutor %s.",
outputs.size(), output_desc.size(), __FUNCTION__);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
return SUCCESS; return SUCCESS;
@ -410,18 +406,17 @@ Status SubgraphExecutor::SetOutputsToParentNode(TaskContext &task_context) {
// get output tensors and tensor desc list // get output tensors and tensor desc list
std::vector<TensorValue> outputs; std::vector<TensorValue> outputs;
std::vector<ConstGeTensorDescPtr> output_desc_list; std::vector<ConstGeTensorDescPtr> output_desc_list;
GE_CHK_STATUS_RET(subgraph_context_->GetOutputs(outputs), GE_CHK_STATUS_RET(subgraph_context_->GetOutputs(outputs), "[Invoke][GetOutputs][%s] Failed to get output tensors.",
"[Invoke][GetOutputs][%s] Failed to get output tensors.", graph_item_->GetName().c_str()); graph_item_->GetName().c_str());
GE_CHK_STATUS_RET(graph_item_->GetOutputDescList(output_desc_list), GE_CHK_STATUS_RET(graph_item_->GetOutputDescList(output_desc_list),
"[Invoke][GetOutputDescList][%s] Failed to get output tensor desc.", graph_item_->GetName().c_str()); "[Invoke][GetOutputDescList][%s] Failed to get output tensor desc.",
graph_item_->GetName().c_str());
if (outputs.size() != output_desc_list.size()) { if (outputs.size() != output_desc_list.size()) {
GELOGE(INTERNAL_ERROR, "[Check][Size][%s] num of output tensors = %zu, num of output tensor desc = %zu not equal", GELOGE(INTERNAL_ERROR, "[Check][Size][%s] num of output tensors = %zu, num of output tensor desc = %zu not equal",
graph_item_->GetName().c_str(), outputs.size(), output_desc_list.size()); graph_item_->GetName().c_str(), outputs.size(), output_desc_list.size());
REPORT_INNER_ERROR("E19999", REPORT_INNER_ERROR("E19999", "%s num of output tensors = %zu, num of output tensor desc = %zu not equal",
"%s num of output tensors = %zu, num of output tensor desc = %zu not equal," graph_item_->GetName().c_str(), outputs.size(), output_desc_list.size());
"check invalid when SubgraphExecutor %s",
graph_item_->GetName().c_str(), outputs.size(), output_desc_list.size(), __FUNCTION__);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -471,9 +466,9 @@ Status SubgraphExecutor::EnableOutputZeroCopy(const vector<TensorValue> &outputs
// Op -> MetOutput, set the output tensor of Op that output to the NetOutput node // Op -> MetOutput, set the output tensor of Op that output to the NetOutput node
if (outputs.size() != output_edges.size()) { if (outputs.size() != output_edges.size()) {
GELOGE(PARAM_INVALID, "[Check][Size]Output number mismatches, expect = %zu, but given = %zu", GELOGE(PARAM_INVALID, "[Check][Size]Output number mismatches, expect = %zu, but given = %zu",
output_edges.size(), outputs.size()); output_edges.size(), outputs.size());
REPORT_INNER_ERROR("E19999", "Output number mismatches, expect = %zu, but given = %zu when %s", REPORT_INNER_ERROR("E19999", "Output number mismatches, expect = %zu, but given = %zu",
output_edges.size(), outputs.size(), __FUNCTION__); output_edges.size(), outputs.size());
return PARAM_INVALID; return PARAM_INVALID;
} }
@ -489,7 +484,8 @@ Status SubgraphExecutor::EnableOutputZeroCopy(const vector<TensorValue> &outputs
output_tensor.DebugString().c_str()); output_tensor.DebugString().c_str());
GE_CHK_STATUS_RET(subgraph_context_->SetOutput(*output_node, output_idx, output_tensor), GE_CHK_STATUS_RET(subgraph_context_->SetOutput(*output_node, output_idx, output_tensor),
"[Invoke][SetOutput][%s] Failed to set input tensor[%zu]", graph_item_->GetName().c_str(), i); "[Invoke][SetOutput][%s] Failed to set input tensor[%zu]",
graph_item_->GetName().c_str(), i);
} }
GELOGD("Done enabling zero copy for outputs successfully."); GELOGD("Done enabling zero copy for outputs successfully.");

43
ge/hybrid/executor/worker/execution_engine.cc
Unescape View File

@ -106,9 +106,9 @@ Status NodeDoneCallback::PrepareConstInputs(const NodeItem &node_item) {
node_item.NodeName().c_str(), output_idx, tensor_size, node_item.NodeName().c_str(), output_idx, tensor_size,
output_tensor->DebugString().c_str()); output_tensor->DebugString().c_str());
REPORT_INNER_ERROR("E19999", REPORT_INNER_ERROR("E19999",
"[%s] Tensor size is not enough. output index = %d, required size = %ld, tensor = %s when %s.", "[%s] Tensor size is not enough. output index = %d, required size = %ld, tensor = %s.",
node_item.NodeName().c_str(), output_idx, tensor_size, node_item.NodeName().c_str(), output_idx, tensor_size,
output_tensor->DebugString().c_str(), __FUNCTION__); output_tensor->DebugString().c_str());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -176,7 +176,7 @@ Status NodeDoneCallback::ProfilingReport() {
auto node = context_->GetNodeItem().node; auto node = context_->GetNodeItem().node;
if (node == nullptr) { if (node == nullptr) {
GELOGE(PARAM_INVALID, "[Get][Node] value is nullptr."); GELOGE(PARAM_INVALID, "[Get][Node] value is nullptr.");
REPORT_INNER_ERROR("E19999", "Get node failed, when %s.", __FUNCTION__); REPORT_INNER_ERROR("E19999", "TaskContext GetNodeItem value is nullptr.");
return PARAM_INVALID; return PARAM_INVALID;
} }
@ -194,7 +194,7 @@ Status NodeDoneCallback::ProfilingReport() {
auto profiling_ret = GetTaskDescInfo(node, model, task_desc_info); auto profiling_ret = GetTaskDescInfo(node, model, task_desc_info);
if (profiling_ret != RT_ERROR_NONE) { if (profiling_ret != RT_ERROR_NONE) {
GELOGE(profiling_ret, "[Get][TaskDescInfo] of node:%s failed.", node->GetName().c_str()); GELOGE(profiling_ret, "[Get][TaskDescInfo] of node:%s failed.", node->GetName().c_str());
REPORT_CALL_ERROR("E19999", "GetTaskDescInfo of node:%s failed, when %s.", node->GetName().c_str(), __FUNCTION__); REPORT_CALL_ERROR("E19999", "GetTaskDescInfo of node:%s failed.", node->GetName().c_str());
return profiling_ret; return profiling_ret;
} }
@ -207,7 +207,7 @@ Status NodeDoneCallback::DumpDynamicNode() {
auto node = context_->GetNodeItem().node; auto node = context_->GetNodeItem().node;
if (node == nullptr) { if (node == nullptr) {
GELOGE(PARAM_INVALID, "[Get][Node] value is nullptr."); GELOGE(PARAM_INVALID, "[Get][Node] value is nullptr.");
REPORT_INNER_ERROR("E19999", "get node is nullptr when %s.", __FUNCTION__); REPORT_INNER_ERROR("E19999", "get node value is nullptr.");
return PARAM_INVALID; return PARAM_INVALID;
} }
auto op_desc = node->GetOpDesc(); auto op_desc = node->GetOpDesc();
@ -217,7 +217,7 @@ Status NodeDoneCallback::DumpDynamicNode() {
std::string dynamic_model_name = model->GetModelName(); std::string dynamic_model_name = model->GetModelName();
std::string dynamic_om_name = model->GetOmName(); std::string dynamic_om_name = model->GetOmName();
uint32_t model_id = model->GetModelId(); uint32_t model_id = model->GetModelId();
if(!context_->GetDumpProperties().IsLayerNeedDump(dynamic_model_name, dynamic_om_name, op_desc->GetName())) { if (!context_->GetDumpProperties().IsLayerNeedDump(dynamic_model_name, dynamic_om_name, op_desc->GetName())) {
GELOGI("[%s] is not in dump list, no need dump", op_desc->GetName().c_str()); GELOGI("[%s] is not in dump list, no need dump", op_desc->GetName().c_str());
return SUCCESS; return SUCCESS;
} }
@ -260,7 +260,7 @@ Status NodeDoneCallback::DumpDynamicNode() {
auto rt_ret = rtStreamSynchronize(stream); auto rt_ret = rtStreamSynchronize(stream);
if (rt_ret != RT_ERROR_NONE) { if (rt_ret != RT_ERROR_NONE) {
GELOGE(rt_ret, "[Call][rtStreamSynchronize] failed, ret = %d.", rt_ret); GELOGE(rt_ret, "[Call][rtStreamSynchronize] failed, ret = %d.", rt_ret);
REPORT_CALL_ERROR("E19999", "call rtStreamSynchronize failed when %s, ret = %d.", __FUNCTION__, rt_ret); REPORT_CALL_ERROR("E19999", "call rtStreamSynchronize failed, ret = %d.", rt_ret);
return rt_ret; return rt_ret;
} }
return SUCCESS; return SUCCESS;
@ -279,8 +279,7 @@ Status NodeDoneCallback::OnNodeDone() {
} }
if (ProfilingManager::Instance().ProfilingModelExecuteOn()) { if (ProfilingManager::Instance().ProfilingModelExecuteOn()) {
GE_CHK_STATUS_RET(ProfilingReport(), "[Report][Profiling] of node[%s] failed.", GE_CHK_STATUS_RET(ProfilingReport(), "[Report][Profiling] of node[%s] failed.", node_item.NodeName().c_str());
node_item.NodeName().c_str());
} }
// release workspace // release workspace
@ -302,8 +301,8 @@ Status NodeDoneCallback::OnNodeDone() {
(void) LogOutputs(node_item, *context_); (void) LogOutputs(node_item, *context_);
} }
GE_CHK_STATUS_RET(context_->PropagateOutputs(), GE_CHK_STATUS_RET(context_->PropagateOutputs(), "[Propagate][Outputs] of [%s] failed.",
"[Propagate][Outputs] of [%s] failed.", node_item.NodeName().c_str()); node_item.NodeName().c_str());
RECORD_CALLBACK_EVENT(graph_context_, context_->GetNodeName(), "[PropagateOutputs] End"); RECORD_CALLBACK_EVENT(graph_context_, context_->GetNodeName(), "[PropagateOutputs] End");
} }
@ -344,7 +343,7 @@ Status ExecutionEngine::DoExecuteAsync(NodeState &node_state,
const auto &task = node_state.GetKernelTask(); const auto &task = node_state.GetKernelTask();
if (task == nullptr) { if (task == nullptr) {
GELOGE(INTERNAL_ERROR, "[Get][KernelTask] of [%s] is null.", node_state.GetName().c_str()); GELOGE(INTERNAL_ERROR, "[Get][KernelTask] of [%s] is null.", node_state.GetName().c_str());
REPORT_INNER_ERROR("E19999", "GetKernelTask of %s is null when %s.", node_state.GetName().c_str(), __FUNCTION__); REPORT_INNER_ERROR("E19999", "GetKernelTask of %s is null.", node_state.GetName().c_str());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -358,8 +357,8 @@ Status ExecutionEngine::DoExecuteAsync(NodeState &node_state,
auto executor = node_item.node_executor; auto executor = node_item.node_executor;
GE_CHECK_NOTNULL(executor); GE_CHECK_NOTNULL(executor);
RECORD_EXECUTION_EVENT(&context, task_context.GetNodeName(), "[PrepareTask] Start"); RECORD_EXECUTION_EVENT(&context, task_context.GetNodeName(), "[PrepareTask] Start");
GE_CHK_STATUS_RET(executor->PrepareTask(*task, task_context), GE_CHK_STATUS_RET(executor->PrepareTask(*task, task_context), "[Prepare][Task] for [%s] failed.",
"[Prepare][Task] for [%s] failed.", node_state.GetName().c_str()); node_state.GetName().c_str());
RECORD_EXECUTION_EVENT(&context, task_context.GetNodeName(), "[PrepareTask] End"); RECORD_EXECUTION_EVENT(&context, task_context.GetNodeName(), "[PrepareTask] End");
GELOGD("[%s] Done task preparation successfully.", node_state.GetName().c_str()); GELOGD("[%s] Done task preparation successfully.", node_state.GetName().c_str());
@ -371,7 +370,7 @@ Status ExecutionEngine::DoExecuteAsync(NodeState &node_state,
} }
GE_CHK_STATUS_RET(ValidateInputTensors(node_state, task_context), "[Validate][InputTensors] for %s failed.", GE_CHK_STATUS_RET(ValidateInputTensors(node_state, task_context), "[Validate][InputTensors] for %s failed.",
node_state.GetName().c_str()); node_state.GetName().c_str());
RECORD_EXECUTION_EVENT(&context, task_context.GetNodeName(), "[ValidateInputTensors] End"); RECORD_EXECUTION_EVENT(&context, task_context.GetNodeName(), "[ValidateInputTensors] End");
if (context.profiling_level > 0) { if (context.profiling_level > 0) {
@ -425,10 +424,10 @@ Status ExecutionEngine::ValidateInputTensors(const NodeState &node_state, const
input_tensor->GetSize()); input_tensor->GetSize());
} else { } else {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR,
"[Check][Size] for [%s] Input[%d]: tensor size mismatches. expected: %ld, but given %zu.", "[Check][Size] for [%s] Input[%d]: tensor size mismatches. expected: %ld, but given %zu.",
task_context.GetNodeName(), i, expected_size, input_tensor->GetSize()); task_context.GetNodeName(), i, expected_size, input_tensor->GetSize());
REPORT_INNER_ERROR("E19999", "[%s] Input[%d]: tensor size mismatches. expected: %ld, but given %zu when %s.", REPORT_INNER_ERROR("E19999", "[%s] Input[%d]: tensor size mismatches. expected: %ld, but given %zu.",
task_context.GetNodeName(), i, expected_size, input_tensor->GetSize(), __FUNCTION__); task_context.GetNodeName(), i, expected_size, input_tensor->GetSize());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
} }
@ -441,8 +440,8 @@ Status ExecutionEngine::PropagateOutputs(const NodeItem &node_item,
TaskContext &task_context, TaskContext &task_context,
GraphExecutionContext &context) { GraphExecutionContext &context) {
if (node_item.shape_inference_type != DEPEND_COMPUTE) { if (node_item.shape_inference_type != DEPEND_COMPUTE) {
GE_CHK_STATUS_RET(task_context.PropagateOutputs(), GE_CHK_STATUS_RET(task_context.PropagateOutputs(), "[Propagate][Outputs] for [%s] failed.",
"[Propagate][Outputs] for [%s] failed.", node_item.NodeName().c_str()); node_item.NodeName().c_str());
RECORD_EXECUTION_EVENT(&context, task_context.GetNodeName(), "[PropagateOutputs] End"); RECORD_EXECUTION_EVENT(&context, task_context.GetNodeName(), "[PropagateOutputs] End");
GELOGD("[%s] Done propagating outputs successfully.", node_item.NodeName().c_str()); GELOGD("[%s] Done propagating outputs successfully.", node_item.NodeName().c_str());
} }

43
ge/hybrid/executor/worker/shape_inference_engine.cc
Unescape View File

@ -205,8 +205,7 @@ Status ShapeInferenceEngine::UpdatePeerNodeShape(const Node &node) {
auto peer_input_desc = peer_op_desc->MutableInputDesc(peer_anchor->GetIdx()); auto peer_input_desc = peer_op_desc->MutableInputDesc(peer_anchor->GetIdx());
if (peer_input_desc == nullptr) { if (peer_input_desc == nullptr) {
GELOGE(GRAPH_FAILED, "[Call][MutableInputDesc] for %s return nullptr.", peer_op_desc->GetName().c_str()); GELOGE(GRAPH_FAILED, "[Call][MutableInputDesc] for %s return nullptr.", peer_op_desc->GetName().c_str());
REPORT_CALL_ERROR("E19999", "%s call MutableInputDesc return nullptr when ShapeInferenceEngine %s.", REPORT_CALL_ERROR("E19999", "%s call MutableInputDesc return nullptr.", peer_op_desc->GetName().c_str());
peer_op_desc->GetName().c_str(), __FUNCTION__);
continue; continue;
} }
@ -232,10 +231,10 @@ Status ShapeInferenceEngine::CanonicalizeShape(GeTensorDesc &tensor_desc,
if (tensor_shape.IsUnknownShape()) { if (tensor_shape.IsUnknownShape()) {
if (!fallback_with_range) { if (!fallback_with_range) {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR,
"[Is][UnknownShape] Output shape is still unknown after shape inference. shape = [%s].", "[Is][UnknownShape] Output shape is still unknown after shape inference. shape = [%s].",
tensor_shape.ToString().c_str()); tensor_shape.ToString().c_str());
REPORT_INNER_ERROR("E19999", "Output shape is still unknown after shape inference. " REPORT_INNER_ERROR("E19999", "Output shape is still unknown after shape inference. shape = [%s].",
"shape = [%s] when ShapeInferenceEngine %s.", tensor_shape.ToString().c_str(), __FUNCTION__); tensor_shape.ToString().c_str());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -244,9 +243,9 @@ Status ShapeInferenceEngine::CanonicalizeShape(GeTensorDesc &tensor_desc,
GE_CHK_GRAPH_STATUS_RET(tensor_desc.GetShapeRange(shape_range), "Failed to get shape range"); GE_CHK_GRAPH_STATUS_RET(tensor_desc.GetShapeRange(shape_range), "Failed to get shape range");
if (shape_range.size() != shape.size()) { if (shape_range.size() != shape.size()) {
GELOGE(INTERNAL_ERROR, "[Check][Size] Number of shape ranges (%zu) mismatches that of dims (%zu).", GELOGE(INTERNAL_ERROR, "[Check][Size] Number of shape ranges (%zu) mismatches that of dims (%zu).",
shape_range.size(), shape.size()); shape_range.size(), shape.size());
REPORT_INNER_ERROR("E19999", "Number of shape ranges (%zu) mismatches that of dims (%zu)" REPORT_INNER_ERROR("E19999", "Number of shape ranges (%zu) mismatches that of dims (%zu)",
" when ShapeInferenceEngine %s.", shape_range.size(), shape.size(), __FUNCTION__); shape_range.size(), shape.size());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -271,23 +270,24 @@ Status ShapeInferenceEngine::CalcTensorSize(DataType data_type,
uint32_t type_size; uint32_t type_size;
if (!TypeUtils::GetDataTypeLength(data_type, type_size)) { if (!TypeUtils::GetDataTypeLength(data_type, type_size)) {
GELOGE(INTERNAL_ERROR, "[Get][DataTypeLength] failed for type:%s.", GELOGE(INTERNAL_ERROR, "[Get][DataTypeLength] failed for type:%s.",
TypeUtils::DataTypeToSerialString(data_type).c_str()); TypeUtils::DataTypeToSerialString(data_type).c_str());
REPORT_CALL_ERROR("E19999", "GetDataTypeLength failed for type:%s when ShapeInferenceEngine %s.", REPORT_CALL_ERROR("E19999", "GetDataTypeLength failed for type:%s.",
TypeUtils::DataTypeToSerialString(data_type).c_str(), __FUNCTION__); TypeUtils::DataTypeToSerialString(data_type).c_str());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
tensor_size = type_size; tensor_size = type_size;
for (const auto &dim : shape) { for (const auto &dim : shape) {
GE_CHECK_GE(dim, 0); GE_CHECK_GE(dim, 0);
GE_CHK_STATUS_RET(Int64MulCheckOverflow(tensor_size, dim), GE_CHK_STATUS_RET(Int64MulCheckOverflow(tensor_size, dim), "[Check][Overflow] Shape size overflow, shape = [%s]",
"[Check][Overflow] Shape size overflow, shape = [%s]", GeShape(shape).ToString().c_str()); GeShape(shape).ToString().c_str());
tensor_size *= dim; tensor_size *= dim;
} }
GE_CHK_STATUS_RET(CheckInt64AddOverflow(tensor_size, kAlignment - 1), GE_CHK_STATUS_RET(CheckInt64AddOverflow(tensor_size, kAlignment - 1),
"[Check][Overflow]Tensor size is too large: %ld, shape = [%s] Shape size will overflow when add align.", "[Check][Overflow]Tensor size is too large:%ld, shape = [%s]"
tensor_size, GeShape(shape).ToString().c_str()); "Shape size will overflow when add align.",
tensor_size, GeShape(shape).ToString().c_str());
tensor_size = (tensor_size + kAlignment - 1) / kAlignment * kAlignment; tensor_size = (tensor_size + kAlignment - 1) / kAlignment * kAlignment;
return SUCCESS; return SUCCESS;
} }
@ -302,9 +302,8 @@ Status ShapeInferenceEngine::CalcOutputTensorSizes(const NodeItem &node_item, bo
auto dims = shape.GetDims(); auto dims = shape.GetDims();
auto status_result = CanonicalizeShape(*tensor_desc, dims, fallback_with_range); auto status_result = CanonicalizeShape(*tensor_desc, dims, fallback_with_range);
if (status_result != SUCCESS) { if (status_result != SUCCESS) {
REPORT_CALL_ERROR("E19999", REPORT_CALL_ERROR("E19999", "CanonicalizeShape failed, node:%s, output:%zu.",
"Invoke CanonicalizeShape failed when ShapeInferenceEngine %s, node:%s, output:%zu.", node_item.NodeName().c_str(), output_index);
node_item.NodeName().c_str(), __FUNCTION__, output_index);
GELOGE(ge::FAILED, "[Canonicalize][Shape] failed for [%s], output %zu.", GELOGE(ge::FAILED, "[Canonicalize][Shape] failed for [%s], output %zu.",
node_item.NodeName().c_str(), output_index); node_item.NodeName().c_str(), output_index);
return status_result; return status_result;
@ -312,10 +311,10 @@ Status ShapeInferenceEngine::CalcOutputTensorSizes(const NodeItem &node_item, bo
int64_t tensor_size; int64_t tensor_size;
status_result = CalcTensorSize(tensor_desc->GetDataType(), dims, tensor_size); status_result = CalcTensorSize(tensor_desc->GetDataType(), dims, tensor_size);
if (status_result != SUCCESS) { if (status_result != SUCCESS) {
REPORT_CALL_ERROR("E19999", "Invoke CalcTensorSize failed when ShapeInferenceEngine %s, node:%s, output:%zu.", REPORT_CALL_ERROR("E19999", "Invoke CalcTensorSize failed, node:%s, output:%zu.",
node_item.NodeName().c_str(), __FUNCTION__, output_index); node_item.NodeName().c_str(), output_index);
GELOGE(ge::FAILED, "[Calc][TensorSize] failed for [%s], output %zu.", GELOGE(ge::FAILED, "[Calc][TensorSize] failed for [%s], output %zu.",
node_item.NodeName().c_str(), output_index); node_item.NodeName().c_str(), output_index);
return status_result; return status_result;
} }
GELOGD("[%s] Tensor size of output %zu = %ld", node_item.NodeName().c_str(), output_index, tensor_size); GELOGD("[%s] Tensor size of output %zu = %ld", node_item.NodeName().c_str(), output_index, tensor_size);

62
ge/hybrid/model/hybrid_model.cc
Unescape View File

@ -44,9 +44,9 @@ Status HybridModel::Init(bool is_single_op) {
GELOGD("Start to init hybrid model."); GELOGD("Start to init hybrid model.");
is_single_op_ = is_single_op; is_single_op_ = is_single_op;
if (is_single_op) { if (is_single_op) {
GE_CHK_STATUS_RET(HybridModelBuilder(*this).BuildForSingleOp(), "Failed to build hybrid model."); GE_CHK_STATUS_RET(HybridModelBuilder(*this).BuildForSingleOp(), "[Build][HybridModel] for SingleOp failed.");
} else { } else {
GE_CHK_STATUS_RET(HybridModelBuilder(*this).Build(), "Failed to build hybrid model."); GE_CHK_STATUS_RET(HybridModelBuilder(*this).Build(), "[Build][HybridModel] failed.");
} }
GELOGD("HybridModel initialized successfully."); GELOGD("HybridModel initialized successfully.");
return SUCCESS; return SUCCESS;
@ -106,7 +106,10 @@ const NodeItem *HybridModel::GetNodeItem(const NodePtr &node) const {
GeModelPtr HybridModel::GetGeModel(const NodePtr &node) const { GeModelPtr HybridModel::GetGeModel(const NodePtr &node) const {
auto it = known_shape_sub_models_.find(node); auto it = known_shape_sub_models_.find(node);
if (it == known_shape_sub_models_.end()) { if (it == known_shape_sub_models_.end()) {
GELOGE(INTERNAL_ERROR, "[%s] Failed to get GeModel for subgraph node.", node->GetName().c_str()); GELOGE(INTERNAL_ERROR, "[Check][Param:node][%s] Failed to get GeModel for subgraph node,"
"because node not in known_shape_sub_models_.", node->GetName().c_str());
REPORT_INNER_ERROR("E19999", "%s Failed to get GeModel for subgraph node,"
"because node not in known_shape_sub_models_.", node->GetName().c_str());
return nullptr; return nullptr;
} }
@ -130,7 +133,10 @@ const GraphItem *HybridModel::GetSubgraphItem(const std::string &graph_name) con
const GraphItem *HybridModel::GetSubgraphItem(const ComputeGraphPtr &subgraph) const { const GraphItem *HybridModel::GetSubgraphItem(const ComputeGraphPtr &subgraph) const {
if (subgraph == nullptr) { if (subgraph == nullptr) {
GELOGE(PARAM_INVALID, "subgraph is nullptr"); REPORT_INNER_ERROR("E19999", "Input param subgraph is nullptr, Graph:%s",
root_graph_item_->GetName().c_str());
GELOGE(PARAM_INVALID, "[Check][Param]subgraph is nullptr. graph:%s",
root_graph_item_->GetName().c_str());
return nullptr; return nullptr;
} }
@ -164,19 +170,27 @@ Status HybridModel::GetInputOutputDescInfo(vector<InputOutputDescInfo> &input_de
std::vector<uint32_t> &output_formats) { std::vector<uint32_t> &output_formats) {
auto node_item_list = root_graph_item_->GetInputNodes(); auto node_item_list = root_graph_item_->GetInputNodes();
if (node_item_list.empty()) { if (node_item_list.empty()) {
GELOGE(FAILED, "node item list is empty!"); REPORT_INNER_ERROR("E19999", "node item list is empty!, graph:%s",
root_graph_item_->GetName().c_str());
GELOGE(FAILED, "[Get][InputNodes]node item list is empty!, graph:%s",
root_graph_item_->GetName().c_str());
return FAILED; return FAILED;
} }
GE_CHECK_NOTNULL(node_item_list[0]->node); GE_CHECK_NOTNULL(node_item_list[0]->node);
GE_CHECK_NOTNULL(node_item_list[0]->node->GetOpDesc()); GE_CHECK_NOTNULL(node_item_list[0]->node->GetOpDesc());
if (node_item_list[0]->node->GetOpDesc()->GetInputsSize() != 1) { if (node_item_list[0]->node->GetOpDesc()->GetInputsSize() != 1) {
GELOGE(FAILED, "input size of op is not 1!"); REPORT_INNER_ERROR("E19999", "Input size of op is not 1, op:%s, type:%s",
node_item_list[0]->node->GetName().c_str(),
node_item_list[0]->node->GetType().c_str());
GELOGE(FAILED, "[Check][Size]input size of op is not 1! op:%s, type:%s",
node_item_list[0]->node->GetName().c_str(),
node_item_list[0]->node->GetType().c_str());
return FAILED; return FAILED;
} }
GE_CHK_STATUS_RET(GetInputDescInfo(input_desc, input_formats), "get input desc info failed"); GE_CHK_STATUS_RET(GetInputDescInfo(input_desc, input_formats), "[Get][InputDescInfo] failed.");
GE_CHK_STATUS_RET(GetOutputDescInfo(output_desc, output_formats), "get ouput desc info failed"); GE_CHK_STATUS_RET(GetOutputDescInfo(output_desc, output_formats), "[Get][OutputDescInfo] failed.");
return SUCCESS; return SUCCESS;
} }
@ -231,7 +245,14 @@ Status HybridModel::GetInputDescInfo(vector<InputOutputDescInfo> &input_desc, st
GeShape shape = op_desc->GetInputDescPtr(0)->GetShape(); GeShape shape = op_desc->GetInputDescPtr(0)->GetShape();
int64_t tensor_size = 0; int64_t tensor_size = 0;
if (TensorUtils::CalcTensorMemSize(shape, format, data_type, tensor_size) != GRAPH_SUCCESS) { if (TensorUtils::CalcTensorMemSize(shape, format, data_type, tensor_size) != GRAPH_SUCCESS) {
GELOGE(FAILED, "Calculate tensor mem size failed."); GELOGE(FAILED, "[Calculate][TensorMemSize] failed input0 desc in node:%s."
"shape:%s, format:%s, datatype:%s.", op_desc->GetName().c_str(),
shape.ToString().c_str(), TypeUtils::FormatToSerialString(format).c_str(),
TypeUtils::DataTypeToSerialString(data_type).c_str());
REPORT_CALL_ERROR("E19999", "CalcTensorMemSize failed for input0 desc in node:%s,"
"shape:%s, format:%s, datatype:%s", op_desc->GetName().c_str(),
shape.ToString().c_str(), TypeUtils::FormatToSerialString(format).c_str(),
TypeUtils::DataTypeToSerialString(data_type).c_str());
return FAILED; return FAILED;
} }
if (tensor_size == kMemSizeUnknownShape) { if (tensor_size == kMemSizeUnknownShape) {
@ -249,7 +270,10 @@ Status HybridModel::GetInputDescInfo(vector<InputOutputDescInfo> &input_desc, st
void HybridModel::CreateOutput(ConstGeTensorDescPtr &output_desc, void HybridModel::CreateOutput(ConstGeTensorDescPtr &output_desc,
InputOutputDescInfo &output_desc_info, uint32_t &format_result) { InputOutputDescInfo &output_desc_info, uint32_t &format_result) {
GE_IF_BOOL_EXEC(output_desc == nullptr, GELOGE(FAILED, "output desc ptr is nullptr"); return ); GE_IF_BOOL_EXEC(output_desc == nullptr,
REPORT_INNER_ERROR("E19999", "param output_desc is nullptr, check invalid.");
GELOGE(FAILED, "[Check][Param:output_desc]output desc ptr is nullptr");
return );
Format format = output_desc->GetFormat(); Format format = output_desc->GetFormat();
GeShape shape = output_desc->GetShape(); GeShape shape = output_desc->GetShape();
std::vector<std::pair<int64_t,int64_t>> shape_ranges; std::vector<std::pair<int64_t,int64_t>> shape_ranges;
@ -290,7 +314,9 @@ void HybridModel::CreateOutput(ConstGeTensorDescPtr &output_desc,
Status HybridModel::GetOutputDescInfo(vector<InputOutputDescInfo> &output_desc, std::vector<uint32_t> &formats) { Status HybridModel::GetOutputDescInfo(vector<InputOutputDescInfo> &output_desc, std::vector<uint32_t> &formats) {
std::vector<ConstGeTensorDescPtr> output_desc_list; std::vector<ConstGeTensorDescPtr> output_desc_list;
// output_desc_list contains vaild input desc // output_desc_list contains vaild input desc
GE_CHK_STATUS_RET(root_graph_item_->GetOutputDescList(output_desc_list), "get output desc info failed"); GE_CHK_STATUS_RET(root_graph_item_->GetOutputDescList(output_desc_list),
"[Invoke][GetOutputDescList]get output desc info failed, Graph:%s",
root_graph_item_->GetName().c_str());
vector<std::string> out_node_names; vector<std::string> out_node_names;
(void)ge::AttrUtils::GetListStr(ge_root_model_->GetRootGraph(), ATTR_MODEL_OUT_NODES_NAME, out_node_names); (void)ge::AttrUtils::GetListStr(ge_root_model_->GetRootGraph(), ATTR_MODEL_OUT_NODES_NAME, out_node_names);
@ -300,8 +326,12 @@ Status HybridModel::GetOutputDescInfo(vector<InputOutputDescInfo> &output_desc,
GE_CHECK_NOTNULL(op_desc); GE_CHECK_NOTNULL(op_desc);
auto out_size = static_cast<uint32_t>(op_desc->GetInputsSize()); auto out_size = static_cast<uint32_t>(op_desc->GetInputsSize());
GE_CHK_BOOL_RET_STATUS(out_size == output_desc_list.size(), GE_IF_BOOL_EXEC(out_size != output_desc_list.size(),
FAILED, "output size[%u] not match output_desc_list size[%zu]", out_size, output_desc_list.size()); REPORT_INNER_ERROR("E19999", "output size[%u] not match output_desc_list size[%zu]",
out_size, output_desc_list.size());
GELOGE(FAILED, "[Check][Size]output size[%u] not match output_desc_list size[%zu]",
out_size, output_desc_list.size());
return FAILED;);
for (uint32_t index = 0; index < out_size; ++index) { for (uint32_t index = 0; index < out_size; ++index) {
string output_name; string output_name;
@ -329,7 +359,8 @@ Status HybridModel::GetOutputDescInfo(vector<InputOutputDescInfo> &output_desc,
TensorValue *HybridModel::GetConstant(const NodePtr &node) const { TensorValue *HybridModel::GetConstant(const NodePtr &node) const {
if (node == nullptr) { if (node == nullptr) {
GELOGE(PARAM_INVALID, "Param is null"); GELOGE(PARAM_INVALID, "[Check][Param:node]node is null.");
REPORT_INNER_ERROR("E19999", "param node is null, check invalid.");
return nullptr; return nullptr;
} }
@ -347,7 +378,8 @@ TensorValue *HybridModel::GetConstant(const NodePtr &node) const {
TensorValue *HybridModel::GetTensor(const NodePtr &node) const { TensorValue *HybridModel::GetTensor(const NodePtr &node) const {
if (node == nullptr) { if (node == nullptr) {
GELOGE(PARAM_INVALID, "Param is null"); GELOGE(PARAM_INVALID, "[Check][Param:node]node is null.");
REPORT_INNER_ERROR("E19999", "param node is null, check invalid.");
return nullptr; return nullptr;
} }

171
ge/hybrid/model/hybrid_model_builder.cc
View File

File diff suppressed because it is too large Load Diff

42
ge/hybrid/model/node_item.cc
Unescape View File

@ -36,10 +36,10 @@ std::set<std::string> kControlOpTypes{
Status ParseInputMapping(Node &node, OpDesc &op_desc, FusedSubgraph &fused_subgraph) { Status ParseInputMapping(Node &node, OpDesc &op_desc, FusedSubgraph &fused_subgraph) {
uint32_t parent_index = 0; uint32_t parent_index = 0;
if (!AttrUtils::GetInt(op_desc, ATTR_NAME_PARENT_NODE_INDEX, parent_index)) { if (!AttrUtils::GetInt(op_desc, ATTR_NAME_PARENT_NODE_INDEX, parent_index)) {
GELOGE(FAILED, GELOGE(FAILED, "[Invoke][GetInt][%s] Failed to get attr [%s]",
"[%s] Failed to get attr [%s]", op_desc.GetName().c_str(), ATTR_NAME_PARENT_NODE_INDEX.c_str());
op_desc.GetName().c_str(), REPORT_CALL_ERROR("E19999", "[%s] Failed to get attr [%s]",
ATTR_NAME_PARENT_NODE_INDEX.c_str()); op_desc.GetName().c_str(), ATTR_NAME_PARENT_NODE_INDEX.c_str());
return FAILED; return FAILED;
} }
@ -58,10 +58,10 @@ Status ParseInputMapping(Node &node, OpDesc &op_desc, FusedSubgraph &fused_subgr
Status ParseOutputMapping(const OpDescPtr &op_desc, FusedSubgraph &fused_subgraph) { Status ParseOutputMapping(const OpDescPtr &op_desc, FusedSubgraph &fused_subgraph) {
uint32_t parent_index = 0; uint32_t parent_index = 0;
if (!AttrUtils::GetInt(op_desc, ATTR_NAME_PARENT_NODE_INDEX, parent_index)) { if (!AttrUtils::GetInt(op_desc, ATTR_NAME_PARENT_NODE_INDEX, parent_index)) {
GELOGE(FAILED, GELOGE(FAILED, "[Invoke][GetInt][%s] Failed to get attr [%s]",
"[%s] Failed to get attr [%s]", op_desc->GetName().c_str(), ATTR_NAME_PARENT_NODE_INDEX.c_str());
op_desc->GetName().c_str(), REPORT_CALL_ERROR("E19999", "[%s] Failed to get attr [%s].",
ATTR_NAME_PARENT_NODE_INDEX.c_str()); op_desc->GetName().c_str(), ATTR_NAME_PARENT_NODE_INDEX.c_str());
return FAILED; return FAILED;
} }
@ -122,7 +122,7 @@ Status NodeItem::Create(const NodePtr &node, std::unique_ptr<NodeItem> &node_ite
GE_CHECK_NOTNULL(node->GetOpDesc()); GE_CHECK_NOTNULL(node->GetOpDesc());
std::unique_ptr<NodeItem> instance(new(std::nothrow)NodeItem(node)); std::unique_ptr<NodeItem> instance(new(std::nothrow)NodeItem(node));
GE_CHECK_NOTNULL(instance); GE_CHECK_NOTNULL(instance);
GE_CHK_STATUS_RET(instance->Init(), "Failed to init NodeItem [%s] .", node->GetName().c_str()); GE_CHK_STATUS_RET(instance->Init(), "[Invoke][Init]Failed to init NodeItem [%s] .", node->GetName().c_str());
node_item = std::move(instance); node_item = std::move(instance);
return SUCCESS; return SUCCESS;
} }
@ -171,7 +171,7 @@ Status NodeItem::ResolveDynamicState() {
GELOGD("Node name is %s, dynamic state is %d.", this->node_name.c_str(), is_dynamic); GELOGD("Node name is %s, dynamic state is %d.", this->node_name.c_str(), is_dynamic);
if (!is_dynamic) { if (!is_dynamic) {
GE_CHK_STATUS_RET(NodeUtils::GetNodeUnknownShapeStatus(*node, is_dynamic), GE_CHK_STATUS_RET(NodeUtils::GetNodeUnknownShapeStatus(*node, is_dynamic),
"[%s] Failed to get shape status.", "[Invoke][GetNodeUnknownShapeStatus][%s] Failed to get shape status.",
node->GetName().c_str()); node->GetName().c_str());
} }
return SUCCESS; return SUCCESS;
@ -241,7 +241,8 @@ Status NodeItem::Init() {
ResolveUnknownShapeType(); ResolveUnknownShapeType();
if (is_dynamic) { if (is_dynamic) {
GE_CHK_STATUS_RET_NOLOG(ResolveStaticInputsAndOutputs()); GE_CHK_STATUS_RET_NOLOG(ResolveStaticInputsAndOutputs());
GE_CHK_STATUS_RET(ParseFusedSubgraph(*this), "[%s] Failed to parse fused subgraph", node_name.c_str()); GE_CHK_STATUS_RET(ParseFusedSubgraph(*this),
"[Invoke][ParseFusedSubgraph][%s] Failed to parse fused subgraph", node_name.c_str());
} }
return SUCCESS; return SUCCESS;
@ -303,11 +304,10 @@ GeTensorDescPtr NodeItem::DoGetInputDesc(int index) const {
} }
if (index < 0 || index >= num_inputs) { if (index < 0 || index >= num_inputs) {
GELOGE(PARAM_INVALID, GELOGE(PARAM_INVALID, "[Check][Param:index][%s] Invalid input index, num inputs = %d, index = %d",
"[%s] Invalid input index, num inputs = %d, index = %d", node_name.c_str(), num_inputs, index);
node_name.c_str(), REPORT_INNER_ERROR("E19999", "Invalid input index, node:%s num inputs = %d, index = %d",
num_inputs, node_name.c_str(), num_inputs, index);
index);
return nullptr; return nullptr;
} }
@ -356,7 +356,11 @@ Status NodeItem::GetCanonicalInputIndex(uint32_t index, int &canonical_index) co
auto iter = std::find(input_desc_indices_.begin(), input_desc_indices_.end(), index); auto iter = std::find(input_desc_indices_.begin(), input_desc_indices_.end(), index);
if (iter == input_desc_indices_.end()) { if (iter == input_desc_indices_.end()) {
GELOGE(INTERNAL_ERROR, "[%s] Invalid input index: %u", node_name.c_str(), index); GELOGE(INTERNAL_ERROR,
"[Check][Param:index]input index:%u not in input_desc_indices_, check Invalid, node:%s",
index, node_name.c_str());
REPORT_INNER_ERROR("E19999", "input index:%u not in input_desc_indices_, check Invalid, node:%s",
index, node_name.c_str());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -371,7 +375,9 @@ bool NodeItem::IsInputShapeStatic(int index) const {
} }
if (static_cast<size_t>(index) >= is_input_shape_static_.size()) { if (static_cast<size_t>(index) >= is_input_shape_static_.size()) {
GELOGE(PARAM_INVALID, "Input index(%d) out of range: [0, %zu)", index, is_input_shape_static_.size()); GELOGE(PARAM_INVALID, "[Check][Param:index]Input index(%d) out of range: [0, %zu)",
index, is_input_shape_static_.size());
REPORT_INNER_ERROR("E19999", "Input index(%d) out of range: [0, %zu).", index, is_input_shape_static_.size());
return false; return false;
} }

32
ge/hybrid/node_executor/aicore/aicore_node_executor.cc
Unescape View File

@ -42,7 +42,7 @@ AiCoreNodeTask::AiCoreNodeTask(std::vector<std::unique_ptr<AiCoreOpTask>> &&task
Status AiCoreNodeExecutor::Initialize() { Status AiCoreNodeExecutor::Initialize() {
compiler_ = TaskCompilerFactory::GetInstance().GetTaskCompiler(); compiler_ = TaskCompilerFactory::GetInstance().GetTaskCompiler();
if (compiler_ != nullptr) { if (compiler_ != nullptr) {
GE_CHK_STATUS_RET(compiler_->Initialize(), "Failed to init aicore task compiler."); GE_CHK_STATUS_RET(compiler_->Initialize(), "[Init][TaskCompiler] failed.");
} }
return SUCCESS; return SUCCESS;
} }
@ -60,8 +60,12 @@ Status AiCoreNodeExecutor::LoadTask(const HybridModel &model, const NodePtr &nod
node->GetName().c_str()); node->GetName().c_str());
return SUCCESS; return SUCCESS;
} else { } else {
GELOGE(FAILED, "Task_defs is empty for node (%s) which 'support_dynamicshape' is true, failed.", GELOGE(FAILED, "[Invoke][GetBool]Task_defs is empty for node (%s)"
"which 'support_dynamicshape' is true, check invalid",
node->GetName().c_str()); node->GetName().c_str());
REPORT_CALL_ERROR("E19999", "Task_defs is empty for node (%s)"
"which 'support_dynamicshape' is true, check invalid",
node->GetName().c_str());
return FAILED; return FAILED;
} }
} }
@ -69,7 +73,7 @@ Status AiCoreNodeExecutor::LoadTask(const HybridModel &model, const NodePtr &nod
AiCoreTaskBuilder builder(node->GetOpDesc(), *task_defs); AiCoreTaskBuilder builder(node->GetOpDesc(), *task_defs);
std::unique_ptr<AiCoreNodeTask> node_task; std::unique_ptr<AiCoreNodeTask> node_task;
GE_CHK_STATUS_RET(builder.BuildTask(node_task, true, is_single_op), GE_CHK_STATUS_RET(builder.BuildTask(node_task, true, is_single_op),
"[%s] Failed to build op tasks.", node->GetName().c_str()); "[Invoke][BuildTask][%s] Failed to build op tasks.", node->GetName().c_str());
task = std::move(node_task); task = std::move(node_task);
GELOGI("AiCoreNodeExecutor(%s) LoadTask End.", node->GetName().c_str()); GELOGI("AiCoreNodeExecutor(%s) LoadTask End.", node->GetName().c_str());
return SUCCESS; return SUCCESS;
@ -105,7 +109,8 @@ bool AiCoreNodeTaskRegistry::AddTask(const std::string &node_key, const std::sha
std::lock_guard<std::mutex> lock(mutex_); std::lock_guard<std::mutex> lock(mutex_);
auto iter = reg_node_tasks_.find(node_key); auto iter = reg_node_tasks_.find(node_key);
if (iter != reg_node_tasks_.end()) { if (iter != reg_node_tasks_.end()) {
GELOGE(FAILED, "AiCoreNodeTaskRegistry(%s) AddTask failed, key already exist.", node_key.c_str()); GELOGE(FAILED, "[Add][Task] failed, key:%s already exist.", node_key.c_str());
REPORT_INNER_ERROR("E19999", "AddTask failed, key:%s already exist.", node_key.c_str());
return false; return false;
} }
auto ret = reg_node_tasks_.emplace(node_key, task); auto ret = reg_node_tasks_.emplace(node_key, task);
@ -131,13 +136,14 @@ Status AiCoreNodeExecutor::CompileTask(const HybridModel &model,
auto ori_node_name = node->GetName(); auto ori_node_name = node->GetName();
if (compiler_ == nullptr) { if (compiler_ == nullptr) {
GELOGE(FAILED, "[%s] Can not find any valid aicore task compiler.", ori_node_name.c_str()); GELOGE(FAILED, "[Find][Compiler][%s] Can not find any valid aicore task compiler.", ori_node_name.c_str());
REPORT_INNER_ERROR("E19999", "[%s] Can not find any valid aicore task compiler.", ori_node_name.c_str());
return FAILED; return FAILED;
} }
AiCoreNodeTaskRegistry &registry = AiCoreNodeTaskRegistry::GetInstance(); AiCoreNodeTaskRegistry &registry = AiCoreNodeTaskRegistry::GetInstance();
std::string shape_key; std::string shape_key;
GE_CHK_STATUS_RET(GenNodeKey(node, shape_key), "GenNodeKey failed, op name = %s.", node->GetName().c_str()); GE_CHK_STATUS_RET(GenNodeKey(node, shape_key), "[Generate][NodeKey] failed, op name = %s.", node->GetName().c_str());
auto node_key = std::to_string(model.GetModelId()) + "/" + shape_key; auto node_key = std::to_string(model.GetModelId()) + "/" + shape_key;
GELOGD("NodeKey for %s = %s", node->GetName().c_str(), node_key.c_str()); GELOGD("NodeKey for %s = %s", node->GetName().c_str(), node_key.c_str());
@ -152,19 +158,21 @@ Status AiCoreNodeExecutor::CompileTask(const HybridModel &model,
std::vector<domi::TaskDef> task_defs; std::vector<domi::TaskDef> task_defs;
op_desc->SetName(ori_node_name + "_" + shape_key); op_desc->SetName(ori_node_name + "_" + shape_key);
GE_CHK_STATUS_RET(compiler_->CompileOp(node, task_defs), "Compile op(%s) failed.", ori_node_name.c_str()); GE_CHK_STATUS_RET(compiler_->CompileOp(node, task_defs), "[Compile][Op:%s] failed.", ori_node_name.c_str());
op_desc->SetName(ori_node_name); op_desc->SetName(ori_node_name);
GELOGD("successfully generated task_defs: %s", node->GetName().c_str()); GELOGD("successfully generated task_defs: %s", node->GetName().c_str());
AiCoreTaskBuilder builder(node->GetOpDesc(), task_defs); AiCoreTaskBuilder builder(node->GetOpDesc(), task_defs);
std::unique_ptr<AiCoreNodeTask> node_task; std::unique_ptr<AiCoreNodeTask> node_task;
GE_CHK_STATUS_RET(builder.BuildTask(node_task, false), "[%s] Failed to build op tasks.", node->GetName().c_str()); GE_CHK_STATUS_RET(builder.BuildTask(node_task, false),
"[Invoke][BuildTask][%s] Failed to build op tasks.", node->GetName().c_str());
node_task->SetWorkspaceSizes(op_desc->GetWorkspaceBytes()); node_task->SetWorkspaceSizes(op_desc->GetWorkspaceBytes());
aicore_task = std::move(node_task); aicore_task = std::move(node_task);
GELOGD("successfully created node task: %s", node->GetName().c_str()); GELOGD("successfully created node task: %s", node->GetName().c_str());
if (!registry.AddTask(node_key, aicore_task)) { if (!registry.AddTask(node_key, aicore_task)) {
GELOGE(INTERNAL_ERROR, "Add NodeTask failed, op name = %s.", node->GetName().c_str()); GELOGE(INTERNAL_ERROR, "[Add][NodeTask] failed, op name = %s.", node->GetName().c_str());
REPORT_CALL_ERROR("E19999", "add task failed, op name = %s.", node->GetName().c_str());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -196,7 +204,8 @@ Status AiCoreNodeTask::ExecuteAsync(TaskContext &context, std::function<void()>
uint32_t stream_id = 0; uint32_t stream_id = 0;
rtError_t rt_ret = rtGetTaskIdAndStreamID(&task_id, &stream_id); // must be called after Launch kernel rtError_t rt_ret = rtGetTaskIdAndStreamID(&task_id, &stream_id); // must be called after Launch kernel
if (rt_ret != RT_ERROR_NONE) { if (rt_ret != RT_ERROR_NONE) {
GELOGE(RT_FAILED, "Get task_id and stream_id failed, ret: 0x%X.", rt_ret); GELOGE(RT_FAILED, "[Invoke][rtGetTaskIdAndStreamID] failed, ret: 0x%X.", rt_ret);
REPORT_CALL_ERROR("E19999", "rtGetTaskIdAndStreamID failed, ret: 0x%X.", rt_ret);
return RT_ERROR_TO_GE_STATUS(rt_ret); return RT_ERROR_TO_GE_STATUS(rt_ret);
} }
GELOGD("Aicore node[%s] task_id: %u, stream_id: %u.", context.GetNodeName(), task_id, stream_id); GELOGD("Aicore node[%s] task_id: %u, stream_id: %u.", context.GetNodeName(), task_id, stream_id);
@ -271,7 +280,8 @@ Status AiCoreNodeTask::CheckOverflow(TaskContext &context) {
GELOGW("Dynamic shape op %s is over flow", context.GetNodeName()); GELOGW("Dynamic shape op %s is over flow", context.GetNodeName());
return SUCCESS; return SUCCESS;
} else if (rt_ret != RT_ERROR_NONE) { } else if (rt_ret != RT_ERROR_NONE) {
GELOGE(rt_ret, "rtstreamsynchronize failed"); GELOGE(rt_ret, "[Invoke][rtstreamsynchronize] failed, ret:%d.", rt_ret);
REPORT_CALL_ERROR("E19999", "rtstreamsynchronize failed, ret:%d.", rt_ret);
return RT_ERROR_TO_GE_STATUS(rt_ret); return RT_ERROR_TO_GE_STATUS(rt_ret);
} }
return SUCCESS; return SUCCESS;

178
ge/hybrid/node_executor/aicore/aicore_op_task.cc
View File

File diff suppressed because it is too large Load Diff

20
ge/hybrid/node_executor/aicore/aicore_task_builder.cc
Unescape View File

@ -42,10 +42,10 @@ Status AiCoreTaskBuilder::BuildTask(std::unique_ptr<AiCoreNodeTask> &node_task,
bool is_single_op) { bool is_single_op) {
GE_CHECK_NOTNULL(op_desc_); GE_CHECK_NOTNULL(op_desc_);
if (task_defs_.size() > kNumTaskWithAtomicAddrCleanTask) { if (task_defs_.size() > kNumTaskWithAtomicAddrCleanTask) {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR, "[Check][Size][%s] At most %zu task was supported, but got %zu",
"[%s] At most 2 task was supported, but got %zu", op_desc_->GetName().c_str(), kNumTaskWithAtomicAddrCleanTask, task_defs_.size());
op_desc_->GetName().c_str(), REPORT_INNER_ERROR("E19999", "[%s] At most %zu task was supported, but got %zu, check invalid.",
task_defs_.size()); op_desc_->GetName().c_str(), kNumTaskWithAtomicAddrCleanTask, task_defs_.size());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -58,10 +58,10 @@ Status AiCoreTaskBuilder::BuildTask(std::unique_ptr<AiCoreNodeTask> &node_task,
task_defs_.size()); task_defs_.size());
return SUCCESS; return SUCCESS;
} else { } else {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR, "[Check][Size][%s] AtomicAddrClean task was expected:%zu, but got %zu task_defs",
"[%s] AtomicAddrClean task was expected, but got %zu task_defs", op_desc_->GetName().c_str(), kNumTaskWithAtomicAddrCleanTask, task_defs_.size());
op_desc_->GetName().c_str(), REPORT_INNER_ERROR("E19999", "[%s] AtomicAddrClean task was expected:%zu, but got %zu task_defs,",
task_defs_.size()); op_desc_->GetName().c_str(), kNumTaskWithAtomicAddrCleanTask, task_defs_.size());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
} }
@ -72,7 +72,7 @@ Status AiCoreTaskBuilder::BuildTask(std::unique_ptr<AiCoreNodeTask> &node_task,
GE_CHECK_NOTNULL(atomic_task); GE_CHECK_NOTNULL(atomic_task);
atomic_task->SetSingleOp(is_single_op); atomic_task->SetSingleOp(is_single_op);
GE_CHK_STATUS_RET(atomic_task->Init(*op_desc_, task_defs_.front()), GE_CHK_STATUS_RET(atomic_task->Init(*op_desc_, task_defs_.front()),
"[%s] Failed to init task for AtomicAddrClean", "[Invoke][AtomicAddrCleanOpTask::Init] failed for [%s].",
op_desc_->GetName().c_str()); op_desc_->GetName().c_str());
op_tasks.emplace_back(std::move(atomic_task)); op_tasks.emplace_back(std::move(atomic_task));
} }
@ -82,7 +82,7 @@ Status AiCoreTaskBuilder::BuildTask(std::unique_ptr<AiCoreNodeTask> &node_task,
GE_CHECK_NOTNULL(aicore_task); GE_CHECK_NOTNULL(aicore_task);
aicore_task->SetSingleOp(is_single_op); aicore_task->SetSingleOp(is_single_op);
GE_CHK_STATUS_RET(aicore_task->Init(*op_desc_, task_defs_.back()), GE_CHK_STATUS_RET(aicore_task->Init(*op_desc_, task_defs_.back()),
"[%s] Failed to init task for AtomicAddrClean", "[Invoke][AiCoreOpTask::Init] failed for [%s].",
op_desc_->GetName().c_str()); op_desc_->GetName().c_str());
op_tasks.emplace_back(std::move(aicore_task)); op_tasks.emplace_back(std::move(aicore_task));

11
ge/hybrid/node_executor/aicore/aicore_task_compiler.cc
Unescape View File

@ -34,7 +34,8 @@ Status AiCoreTaskCompiler::Initialize() {
auto ge_lib = GELib::GetInstance(); auto ge_lib = GELib::GetInstance();
GE_CHECK_NOTNULL(ge_lib); GE_CHECK_NOTNULL(ge_lib);
if (!ge_lib->InitFlag()) { if (!ge_lib->InitFlag()) {
GELOGE(GE_CLI_GE_NOT_INITIALIZED, "Ge_lib is uninitialized, failed."); GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[Check][State] failed, because Ge_lib is uninitialized.");
REPORT_INNER_ERROR("E19999", "Initialize failed, because Ge_lib is uninitialized.");
return GE_CLI_GE_NOT_INITIALIZED; return GE_CLI_GE_NOT_INITIALIZED;
} }
auto &kernel_manager = ge_lib->OpsKernelManagerObj(); auto &kernel_manager = ge_lib->OpsKernelManagerObj();
@ -49,11 +50,9 @@ Status AiCoreTaskCompiler::DoCompileOp(const NodePtr &node) const {
vector<NodePtr> node_vec; vector<NodePtr> node_vec;
node_vec.emplace_back(node); node_vec.emplace_back(node);
GE_CHK_STATUS_RET(aic_kernel_store_->CompileOpRun(node_vec), GE_CHK_STATUS_RET(aic_kernel_store_->CompileOpRun(node_vec),
"Failed to execute CompileOp, node = %s", "[Invoke][CompileOpRun] Failed, node = %s", node->GetName().c_str());
node->GetName().c_str());
GE_CHK_STATUS_RET(OpsKernelBuilderManager::Instance().CalcOpRunningParam(*node), GE_CHK_STATUS_RET(OpsKernelBuilderManager::Instance().CalcOpRunningParam(*node),
"Failed to execute CalcOpRunningParam, node = %s", "[Invoke][CalcOpRunningParam] Failed, node = %s", node->GetName().c_str());
node->GetName().c_str());
return SUCCESS; return SUCCESS;
} }
@ -102,7 +101,7 @@ Status AiCoreTaskCompiler::DoGenerateTask(const Node &node,
ret = OpsKernelBuilderManager::Instance().GenerateTask(node, context, tasks); ret = OpsKernelBuilderManager::Instance().GenerateTask(node, context, tasks);
} }
GE_CHK_STATUS(ret, "Failed to execute GenerateTask, node = %s", node.GetName().c_str()); GE_CHK_STATUS(ret, "[Invoke][GenerateTask] Failed, node = %s", node.GetName().c_str());
GE_CHK_RT(rtModelUnbindStream(rt_model_, stream)); GE_CHK_RT(rtModelUnbindStream(rt_model_, stream));
GE_CHK_RT(rtModelDestroy(rt_model_)); GE_CHK_RT(rtModelDestroy(rt_model_));
return ret; return ret;

123
ge/hybrid/node_executor/aicpu/aicpu_ext_info.cc
Unescape View File

@ -29,8 +29,9 @@ constexpr int64_t kDimEndFlag = INT64_MIN;
Status AicpuExtInfoHandler::Parse(const std::string &ext_info) { Status AicpuExtInfoHandler::Parse(const std::string &ext_info) {
GELOGI("Node[%s] parse ext info start.", node_name_.c_str()); GELOGI("Node[%s] parse ext info start.", node_name_.c_str());
if (ext_info.empty()) { if (ext_info.empty()) {
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Node[%s] parse ext info failed as ext info is empty.", GELOGE(ACL_ERROR_GE_PARAM_INVALID,
node_name_.c_str()); "[Check][Param:ext_info]Node[%s] parse ext info failed as ext info is empty.", node_name_.c_str());
REPORT_INNER_ERROR("E19999", "Node[%s] parse ext info failed as ext info is empty.", node_name_.c_str());
return ACL_ERROR_GE_PARAM_INVALID; return ACL_ERROR_GE_PARAM_INVALID;
} }
@ -39,7 +40,8 @@ Status AicpuExtInfoHandler::Parse(const std::string &ext_info) {
GE_CHECK_NOTNULL(ext_info_); GE_CHECK_NOTNULL(ext_info_);
if (memcpy_s(ext_info_.get(), ext_info_len_, ext_info.c_str(), ext_info.size()) != EOK) { if (memcpy_s(ext_info_.get(), ext_info_len_, ext_info.c_str(), ext_info.size()) != EOK) {
GELOGE(ACL_ERROR_GE_MEMORY_OPERATE_FAILED, "[%s] Failed to coy ext info", node_name_.c_str()); GELOGE(ACL_ERROR_GE_MEMORY_OPERATE_FAILED, "[Update][ext_info_][%s] Failed to copy ext info", node_name_.c_str());
REPORT_CALL_ERROR("E19999", "[%s] Failed to copy ext info.", node_name_.c_str());
return ACL_ERROR_GE_MEMORY_OPERATE_FAILED; return ACL_ERROR_GE_MEMORY_OPERATE_FAILED;
} }
@ -53,22 +55,22 @@ Status AicpuExtInfoHandler::Parse(const std::string &ext_info) {
GELOGD("Ext infoType=%d, infoLen=%u.", aicpu_ext_info->infoType, aicpu_ext_info->infoLen); GELOGD("Ext infoType=%d, infoLen=%u.", aicpu_ext_info->infoType, aicpu_ext_info->infoLen);
switch (aicpu_ext_info->infoType) { switch (aicpu_ext_info->infoType) {
case aicpu::FWKAdapter::FWK_ADPT_EXT_SHAPE_TYPE: case aicpu::FWKAdapter::FWK_ADPT_EXT_SHAPE_TYPE:
GE_CHK_STATUS_RET(ParseExtShapeType(aicpu_ext_info), "Parse ext shape type failed."); GE_CHK_STATUS_RET(ParseExtShapeType(aicpu_ext_info), "[Parse][ExtShapeType] failed.");
break; break;
case aicpu::FWKAdapter::FWK_ADPT_EXT_INPUT_SHAPE: case aicpu::FWKAdapter::FWK_ADPT_EXT_INPUT_SHAPE:
GE_CHK_STATUS_RET(ParseExtInputShape(aicpu_ext_info), "Parse ext input shape failed."); GE_CHK_STATUS_RET(ParseExtInputShape(aicpu_ext_info), "[Parse][ExtInputShape] failed.");
break; break;
case aicpu::FWKAdapter::FWK_ADPT_EXT_OUTPUT_SHAPE: case aicpu::FWKAdapter::FWK_ADPT_EXT_OUTPUT_SHAPE:
GE_CHK_STATUS_RET(ParseExtOutputShape(aicpu_ext_info), "Parse ext output shape failed."); GE_CHK_STATUS_RET(ParseExtOutputShape(aicpu_ext_info), "[Parse][ExtOutputShape] failed.");
break; break;
case aicpu::FWKAdapter::FWK_ADPT_EXT_SESSION_INFO: case aicpu::FWKAdapter::FWK_ADPT_EXT_SESSION_INFO:
GE_CHK_STATUS_RET(ParseExtSessionInfo(aicpu_ext_info), "Parse ext session info failed."); GE_CHK_STATUS_RET(ParseExtSessionInfo(aicpu_ext_info), "[Parse][ExtSessionInfo] failed.");
break; break;
case aicpu::FWKAdapter::FWK_ADPT_EXT_BITMAP: case aicpu::FWKAdapter::FWK_ADPT_EXT_BITMAP:
GE_CHK_STATUS_RET(ParseExtBitMap(aicpu_ext_info), "Parse ext bit map failed."); GE_CHK_STATUS_RET(ParseExtBitMap(aicpu_ext_info), "[Parse][ExtBitMap] failed.");
break; break;
case aicpu::FWKAdapter::FWK_ADPT_EXT_UPDATE_ADDR: case aicpu::FWKAdapter::FWK_ADPT_EXT_UPDATE_ADDR:
GE_CHK_STATUS_RET(ParseExtUpdateAddr(aicpu_ext_info), "Parse ext update_addr failed."); GE_CHK_STATUS_RET(ParseExtUpdateAddr(aicpu_ext_info), "[Parse][ExtUpdateAddr] failed.");
break; break;
default: default:
GELOGD("Node[%s] ignore infoType=%d, infoLen=%u.", GELOGD("Node[%s] ignore infoType=%d, infoLen=%u.",
@ -79,33 +81,51 @@ Status AicpuExtInfoHandler::Parse(const std::string &ext_info) {
offset += aicpu_ext_info->infoLen; offset += aicpu_ext_info->infoLen;
} }
GE_CHK_BOOL_RET_STATUS(offset == ext_info_len_, ACL_ERROR_GE_PARAM_INVALID, GE_IF_BOOL_EXEC(offset != ext_info_len_,
"Node[%s] ext_info format error, parse not reach end, offset=%zu, ext_info_len=%zu.", REPORT_INNER_ERROR("E19999", "Node[%s] ext_info format error, parse not reach end,"
"offset=%zu, ext_info_len=%zu.", node_name_.c_str(), offset, ext_info_len_);
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "[Check][Size]Node[%s] ext_info format error,"
"parse not reach end, offset=%zu, ext_info_len=%zu.",
node_name_.c_str(), offset, ext_info_len_); node_name_.c_str(), offset, ext_info_len_);
return ACL_ERROR_GE_PARAM_INVALID;);
GELOGI("Node[%s] parse ext info end.", node_name_.c_str()); GELOGI("Node[%s] parse ext info end.", node_name_.c_str());
return SUCCESS; return SUCCESS;
} }
Status AicpuExtInfoHandler::ParseExtShapeType(AicpuExtInfo *aicpu_ext_info) { Status AicpuExtInfoHandler::ParseExtShapeType(AicpuExtInfo *aicpu_ext_info) {
GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == sizeof(int32_t), ACL_ERROR_GE_PARAM_INVALID, GE_IF_BOOL_EXEC(aicpu_ext_info->infoLen != sizeof(int32_t),
"Node[%s] parse ext shape type failed as infoLen must be %zu but %u.", REPORT_INNER_ERROR("E19999", "Node[%s] parse ext shape type failed as infoLen must be %zu but %u.",
node_name_.c_str(), sizeof(int32_t), aicpu_ext_info->infoLen);
GELOGE(ACL_ERROR_GE_PARAM_INVALID,
"[Check][Size]Node[%s] parse ext shape type failed as infoLen must be %zu but %u.",
node_name_.c_str(), sizeof(int32_t), aicpu_ext_info->infoLen); node_name_.c_str(), sizeof(int32_t), aicpu_ext_info->infoLen);
return ACL_ERROR_GE_PARAM_INVALID;);
auto type = reinterpret_cast<const int32_t *>(aicpu_ext_info->infoMsg); auto type = reinterpret_cast<const int32_t *>(aicpu_ext_info->infoMsg);
GE_CHK_BOOL_RET_STATUS(*type == unknown_type_, ACL_ERROR_GE_PARAM_INVALID, GE_IF_BOOL_EXEC(*type != unknown_type_,
"Node[%s] parse ext shape type failed as need %d but %d.", REPORT_INNER_ERROR("E19999", "Node[%s] parse ext shape type failed as need %d but %d.",
node_name_.c_str(), unknown_type_, *type);
GELOGE(ACL_ERROR_GE_PARAM_INVALID,
"[Check][Type]Node[%s] parse ext shape type failed as need %d but %d.",
node_name_.c_str(), unknown_type_, *type); node_name_.c_str(), unknown_type_, *type);
return ACL_ERROR_GE_PARAM_INVALID;);
GELOGI("Node[%s] parse ext shape type success infoLen=%u.", node_name_.c_str(), aicpu_ext_info->infoLen); GELOGI("Node[%s] parse ext shape type success infoLen=%u.", node_name_.c_str(), aicpu_ext_info->infoLen);
return SUCCESS; return SUCCESS;
} }
Status AicpuExtInfoHandler::ParseExtInputShape(AicpuExtInfo *aicpu_ext_info) { Status AicpuExtInfoHandler::ParseExtInputShape(AicpuExtInfo *aicpu_ext_info) {
auto need_len = input_num_ * sizeof(AicpuShapeAndType); auto need_len = input_num_ * sizeof(AicpuShapeAndType);
GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == need_len, ACL_ERROR_GE_PARAM_INVALID, GE_IF_BOOL_EXEC(aicpu_ext_info->infoLen != need_len,
"Node[%s] parse ext input shape failed as infoLen must be " REPORT_INNER_ERROR("E19999", "Node[%s] parse ext input shape failed as infoLen must be "
"input_num[%u]*sizeof(ShapeAndType)[%zu] but %u.",
node_name_.c_str(), input_num_, sizeof(AicpuShapeAndType),
aicpu_ext_info->infoLen);
GELOGE(ACL_ERROR_GE_PARAM_INVALID,
"[Check][DataLen]Node[%s] parse ext input shape failed as infoLen must be "
"input_num[%u]*sizeof(ShapeAndType)[%zu] but %u.", "input_num[%u]*sizeof(ShapeAndType)[%zu] but %u.",
node_name_.c_str(), input_num_, sizeof(AicpuShapeAndType), aicpu_ext_info->infoLen); node_name_.c_str(), input_num_, sizeof(AicpuShapeAndType), aicpu_ext_info->infoLen);
return ACL_ERROR_GE_PARAM_INVALID;);
auto input = reinterpret_cast<AicpuShapeAndType *>(aicpu_ext_info->infoMsg); auto input = reinterpret_cast<AicpuShapeAndType *>(aicpu_ext_info->infoMsg);
@ -123,10 +143,16 @@ Status AicpuExtInfoHandler::ParseExtOutputShape(AicpuExtInfo *aicpu_ext_info) {
return SUCCESS; return SUCCESS;
} }
auto need_len = output_num_ * sizeof(AicpuShapeAndType); auto need_len = output_num_ * sizeof(AicpuShapeAndType);
GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == need_len, ACL_ERROR_GE_PARAM_INVALID, GE_IF_BOOL_EXEC(aicpu_ext_info->infoLen != need_len,
"Node[%s] parse ext output shape failed as infoLen must be " REPORT_INNER_ERROR("E19999", "Node[%s] parse ext output shape failed as infoLen must be "
"output_num[%u]*sizeof(ShapeAndType)[%zu] but %u.",
node_name_.c_str(), output_num_, sizeof(AicpuShapeAndType),
aicpu_ext_info->infoLen);
GELOGE(ACL_ERROR_GE_PARAM_INVALID,
"[Check][DataLen]Node[%s] parse ext output shape failed as infoLen must be "
"output_num[%u]*sizeof(ShapeAndType)[%zu] but %u.", "output_num[%u]*sizeof(ShapeAndType)[%zu] but %u.",
node_name_.c_str(), output_num_, sizeof(AicpuShapeAndType), aicpu_ext_info->infoLen); node_name_.c_str(), output_num_, sizeof(AicpuShapeAndType), aicpu_ext_info->infoLen);
return ACL_ERROR_GE_PARAM_INVALID;);
auto output = reinterpret_cast<AicpuShapeAndType *>(aicpu_ext_info->infoMsg); auto output = reinterpret_cast<AicpuShapeAndType *>(aicpu_ext_info->infoMsg);
for (uint32_t index = 0; index < output_num_; ++index) { for (uint32_t index = 0; index < output_num_; ++index) {
@ -137,9 +163,14 @@ Status AicpuExtInfoHandler::ParseExtOutputShape(AicpuExtInfo *aicpu_ext_info) {
} }
Status AicpuExtInfoHandler::ParseExtSessionInfo(AicpuExtInfo *aicpu_ext_info) { Status AicpuExtInfoHandler::ParseExtSessionInfo(AicpuExtInfo *aicpu_ext_info) {
GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == sizeof(AicpuSessionInfo), ACL_ERROR_GE_PARAM_INVALID, GE_IF_BOOL_EXEC(aicpu_ext_info->infoLen != sizeof(AicpuSessionInfo),
"Node[%s] parse ext session info failed as infoLen must be %zu but %u.", REPORT_INNER_ERROR("E19999",
"Node[%s] parse ext session info failed as infoLen must be %zu but %u.",
node_name_.c_str(), sizeof(SessionInfo), aicpu_ext_info->infoLen);
GELOGE(ACL_ERROR_GE_PARAM_INVALID,
"[Check][DataLen]Node[%s] parse ext session info failed as infoLen must be %zu but %u.",
node_name_.c_str(), sizeof(SessionInfo), aicpu_ext_info->infoLen); node_name_.c_str(), sizeof(SessionInfo), aicpu_ext_info->infoLen);
return ACL_ERROR_GE_PARAM_INVALID;);
session_info_ = reinterpret_cast<AicpuSessionInfo *>(aicpu_ext_info->infoMsg); session_info_ = reinterpret_cast<AicpuSessionInfo *>(aicpu_ext_info->infoMsg);
GELOGI("Node[%s] parse session info success infoLen=%u.", node_name_.c_str(), aicpu_ext_info->infoLen); GELOGI("Node[%s] parse session info success infoLen=%u.", node_name_.c_str(), aicpu_ext_info->infoLen);
@ -147,9 +178,14 @@ Status AicpuExtInfoHandler::ParseExtSessionInfo(AicpuExtInfo *aicpu_ext_info) {
} }
Status AicpuExtInfoHandler::ParseExtBitMap(AicpuExtInfo *aicpu_ext_info) { Status AicpuExtInfoHandler::ParseExtBitMap(AicpuExtInfo *aicpu_ext_info) {
GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == sizeof(uint64_t), PARAM_INVALID, GE_IF_BOOL_EXEC(aicpu_ext_info->infoLen != sizeof(uint64_t),
"Node[%s] parse bit_map info failed as infoLen must be %zu but %u.", REPORT_INNER_ERROR("E19999",
"Node[%s] parse bit_map info failed as infoLen must be %zu but %u.",
node_name_.c_str(), sizeof(uint64_t), aicpu_ext_info->infoLen);
GELOGE(PARAM_INVALID,
"[Check][DataLen]Node[%s] parse bit_map info failed as infoLen must be %zu but %u.",
node_name_.c_str(), sizeof(uint64_t), aicpu_ext_info->infoLen); node_name_.c_str(), sizeof(uint64_t), aicpu_ext_info->infoLen);
return PARAM_INVALID;);
bit_map_ = reinterpret_cast<uint64_t *>(aicpu_ext_info->infoMsg); bit_map_ = reinterpret_cast<uint64_t *>(aicpu_ext_info->infoMsg);
GELOGI("Node[%s] bit_map info success infoLen=%u.", node_name_.c_str(), aicpu_ext_info->infoLen); GELOGI("Node[%s] bit_map info success infoLen=%u.", node_name_.c_str(), aicpu_ext_info->infoLen);
@ -157,9 +193,14 @@ Status AicpuExtInfoHandler::ParseExtBitMap(AicpuExtInfo *aicpu_ext_info) {
} }
Status AicpuExtInfoHandler::ParseExtUpdateAddr(AicpuExtInfo *aicpu_ext_info) { Status AicpuExtInfoHandler::ParseExtUpdateAddr(AicpuExtInfo *aicpu_ext_info) {
GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == sizeof(uint32_t), PARAM_INVALID, GE_IF_BOOL_EXEC(aicpu_ext_info->infoLen != sizeof(uint32_t),
"Node[%s] parse update_addr info failed as infoLen must be %zu but %u.", REPORT_INNER_ERROR("E19999",
"Node[%s] parse update_addr info failed as infoLen must be %zu but %u.",
node_name_.c_str(), sizeof(uint32_t), aicpu_ext_info->infoLen);
GELOGE(PARAM_INVALID,
"[Check][DataLen]Node[%s] parse update_addr info failed as infoLen must be %zu but %u.",
node_name_.c_str(), sizeof(uint32_t), aicpu_ext_info->infoLen); node_name_.c_str(), sizeof(uint32_t), aicpu_ext_info->infoLen);
return PARAM_INVALID;);
update_addr_ = reinterpret_cast<uint32_t *>(aicpu_ext_info->infoMsg); update_addr_ = reinterpret_cast<uint32_t *>(aicpu_ext_info->infoMsg);
GELOGI("Node[%s] update_addr info success infoLen=%u.", node_name_.c_str(), aicpu_ext_info->infoLen); GELOGI("Node[%s] update_addr info success infoLen=%u.", node_name_.c_str(), aicpu_ext_info->infoLen);
@ -207,15 +248,19 @@ Status AicpuExtInfoHandler::UpdateInputShapeAndType(uint32_t input_index, const
const auto &shape = input_desc.GetShape(); const auto &shape = input_desc.GetShape();
GE_CHK_STATUS_RET(UpdateShapeAndType(shape, input_desc.GetDataType(), input_shape_and_type_[input_index]), GE_CHK_STATUS_RET(UpdateShapeAndType(shape, input_desc.GetDataType(), input_shape_and_type_[input_index]),
"Node[%s] input[%u] update input shape and type failed.", "[Update][ShapeAndType] failed, Node[%s] input[%u] .",
node_name_.c_str(), input_index); node_name_.c_str(), input_index);
return SUCCESS; return SUCCESS;
} }
Status AicpuExtInfoHandler::UpdateOutputShapeAndType(uint32_t output_index, const GeTensorDesc &output_desc) { Status AicpuExtInfoHandler::UpdateOutputShapeAndType(uint32_t output_index, const GeTensorDesc &output_desc) {
GE_CHK_BOOL_RET_STATUS((unknown_type_ != DEPEND_COMPUTE), ACL_ERROR_GE_INTERNAL_ERROR, GE_IF_BOOL_EXEC((unknown_type_ == DEPEND_COMPUTE),
"Node[%s] is depend compute is no need update output shape and type by ext.", REPORT_INNER_ERROR("E19999", "Node[%s] is depend compute is no need update output shape"
"and type by ext.", node_name_.c_str());
GELOGE(ACL_ERROR_GE_INTERNAL_ERROR,
"[Check][Type]Node[%s] is depend compute is no need update output shape and type by ext.",
node_name_.c_str()); node_name_.c_str());
return ACL_ERROR_GE_INTERNAL_ERROR;);
GE_CHECK_LE(output_index, output_num_); GE_CHECK_LE(output_index, output_num_);
auto shape = output_desc.GetShape(); auto shape = output_desc.GetShape();
@ -223,9 +268,13 @@ Status AicpuExtInfoHandler::UpdateOutputShapeAndType(uint32_t output_index, cons
if (unknown_type_ == DEPEND_SHAPE_RANGE) { if (unknown_type_ == DEPEND_SHAPE_RANGE) {
std::vector<std::pair<int64_t, int64_t>> range; std::vector<std::pair<int64_t, int64_t>> range;
auto range_ret = output_desc.GetShapeRange(range); auto range_ret = output_desc.GetShapeRange(range);
GE_CHK_BOOL_RET_STATUS(range_ret == GRAPH_SUCCESS, ACL_ERROR_GE_INTERNAL_ERROR, GE_IF_BOOL_EXEC(range_ret != GRAPH_SUCCESS,
"Node[%s] is shape range type but get GetShapeRange failed, ret=%u.", REPORT_INNER_ERROR("E19999", "Node[%s] is shape range type but get GetShapeRange failed, ret=%u",
node_name_.c_str(), range_ret);
GELOGE(ACL_ERROR_GE_INTERNAL_ERROR,
"[Invoke][GetShapeRange]Node[%s] is shape range type but get GetShapeRange failed, ret=%u",
node_name_.c_str(), range_ret); node_name_.c_str(), range_ret);
return ACL_ERROR_GE_INTERNAL_ERROR;);
for (size_t k = 0; k < range.size(); ++k) { for (size_t k = 0; k < range.size(); ++k) {
if (shape.GetDim(k) < 0 && k < range.size()) { if (shape.GetDim(k) < 0 && k < range.size()) {
GELOGD("Node[%s] output[%u] update dim[%zu] from %ld to range max %ld.", GELOGD("Node[%s] output[%u] update dim[%zu] from %ld to range max %ld.",
@ -239,9 +288,14 @@ Status AicpuExtInfoHandler::UpdateOutputShapeAndType(uint32_t output_index, cons
} }
Status AicpuExtInfoHandler::GetOutputShapeAndType(uint32_t output_index, GeShape &shape, DataType &data_type) { Status AicpuExtInfoHandler::GetOutputShapeAndType(uint32_t output_index, GeShape &shape, DataType &data_type) {
GE_CHK_BOOL_RET_STATUS((unknown_type_ != DEPEND_COMPUTE), INTERNAL_ERROR, GE_IF_BOOL_EXEC((unknown_type_ == DEPEND_COMPUTE),
"Node[%s] is depend compute type can not get output shape and type by ext.", REPORT_INNER_ERROR("E19999",
"Node[%s] is depend compute type can not get output shape and type by ext.",
node_name_.c_str());
GELOGE(INTERNAL_ERROR,
"[Check][Type]Node[%s] is depend compute type can not get output shape and type by ext.",
node_name_.c_str()); node_name_.c_str());
return INTERNAL_ERROR;);
GetShapeAndType(output_shape_and_type_[output_index], shape, data_type); GetShapeAndType(output_shape_and_type_[output_index], shape, data_type);
return SUCCESS; return SUCCESS;
} }
@ -254,8 +308,11 @@ Status AicpuExtInfoHandler::UpdateShapeAndType(const GeShape &shape, DataType da
AicpuShapeAndType *shape_and_type) { AicpuShapeAndType *shape_and_type) {
auto dim_num = shape.GetDimNum(); auto dim_num = shape.GetDimNum();
if (dim_num > aicpu::FWKAdapter::kMaxShapeDims) { if (dim_num > aicpu::FWKAdapter::kMaxShapeDims) {
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Update shape and type failed, as dim_num %zu is over max shape dims %u.", GELOGE(ACL_ERROR_GE_PARAM_INVALID,
"[Check][DimNum]Update shape and type failed, as dim_num %zu is over max shape dims %u.",
dim_num, aicpu::FWKAdapter::kMaxShapeDims); dim_num, aicpu::FWKAdapter::kMaxShapeDims);
REPORT_INNER_ERROR("E19999", "Update shape and type failed, as dim_num %zu is over max shape dims %u.",
dim_num, aicpu::FWKAdapter::kMaxShapeDims);
return ACL_ERROR_GE_PARAM_INVALID; return ACL_ERROR_GE_PARAM_INVALID;
} }
size_t index = 0; size_t index = 0;

214
ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc
View File

File diff suppressed because it is too large Load Diff

84
ge/ir_build/atc_ir_common.cc
Unescape View File

@ -206,8 +206,8 @@ bool CheckDynamicDimsInputShapeValid(const map<string, vector<int64_t>> &shape_m
ErrorManager::GetInstance().ATCReportErrMessage( ErrorManager::GetInstance().ATCReportErrMessage(
"E10001", {"parameter", "value", "reason"}, "E10001", {"parameter", "value", "reason"},
{"--input_shape's dim", std::to_string(shapes.size()), "Dim num must within [1, 4] when set dynamic_dims"}); {"--input_shape's dim", std::to_string(shapes.size()), "Dim num must within [1, 4] when set dynamic_dims"});
GELOGE(ge::PARAM_INVALID, "[Check][DynamicDimsInputShape]Dim num must within [%zu, %zu] when set dynamic_dims.", GELOGE(ge::PARAM_INVALID, "[Check][DynamicDimsInputShape]Dim num must within [%zu, %zu] when set dynamic_dims.",
kMinNDDimNum, kMaxNDDimNum); kMinNDDimNum, kMaxNDDimNum);
return false; return false;
} }
dynamic_dim += std::count(shapes.begin(), shapes.end(), kDynamicInputDim); dynamic_dim += std::count(shapes.begin(), shapes.end(), kDynamicInputDim);
@ -216,8 +216,9 @@ bool CheckDynamicDimsInputShapeValid(const map<string, vector<int64_t>> &shape_m
ErrorManager::GetInstance().ATCReportErrMessage( ErrorManager::GetInstance().ATCReportErrMessage(
"E10001", {"parameter", "value", "reason"}, "E10001", {"parameter", "value", "reason"},
{"--input_shape's dynamic dim num", "0", "at least one dim should be -1 when set dynamic_dims"}); {"--input_shape's dynamic dim num", "0", "at least one dim should be -1 when set dynamic_dims"});
GELOGE(ge::PARAM_INVALID, GELOGE(ge::PARAM_INVALID,
"[Check][DynamicDimsInputShape]--input_shape invalid, at least one dim should be -1 when set dynamic_dims."); "[Check][DynamicDimsInputShape]--input_shape invalid,"
"at least one dim should be -1 when set dynamic_dims.");
return false; return false;
} }
@ -352,8 +353,8 @@ bool ParseSingleShapeRange(std::string &shape_range, vector<pair<int64_t, int64_
} else { } else {
ErrorManager::GetInstance().ATCReportErrMessage("E10048", {"shape_range", "reason", "sample"}, ErrorManager::GetInstance().ATCReportErrMessage("E10048", {"shape_range", "reason", "sample"},
{shape_range, kInputShapeRangeInvalid, kInputShapeRangeSample3}); {shape_range, kInputShapeRangeInvalid, kInputShapeRangeSample3});
GELOGE(PARAM_INVALID,"[Parse][Parameter]shape_range:%s invalid, reason: %s, correct sample is %s.", GELOGE(PARAM_INVALID, "[Parse][Parameter]shape_range:%s invalid, reason: %s, correct sample is %s.",
shape_range.c_str(), kInputShapeRangeInvalid, kInputShapeRangeSample3); shape_range.c_str(), kInputShapeRangeInvalid, kInputShapeRangeSample3);
return false; return false;
} }
shape_range_vec.emplace_back(range_pair); shape_range_vec.emplace_back(range_pair);
@ -392,19 +393,18 @@ bool ParseInputShapeRange(const std::string &shape_range,
} }
shape_range_map.emplace(make_pair(StringUtils::Trim(shape_range_pair_vec[0]), shape_range_val)); shape_range_map.emplace(make_pair(StringUtils::Trim(shape_range_pair_vec[0]), shape_range_val));
} }
return true; return true;
} }
Status CheckDynamicInputParamValid(string &dynamic_batch_size, string &dynamic_image_size, string &dynamic_dims, Status CheckDynamicInputParamValid(string &dynamic_batch_size, string &dynamic_image_size, string &dynamic_dims,
const string input_shape, const string input_shape_range, const string input_format,bool &is_dynamic_input){ const string input_shape, const string input_shape_range, const string input_format, bool &is_dynamic_input) {
int32_t param_size = static_cast<int32_t>(!dynamic_batch_size.empty()) + int32_t param_size = static_cast<int32_t>(!dynamic_batch_size.empty()) +
static_cast<int32_t>(!dynamic_image_size.empty()) + static_cast<int32_t>(!dynamic_dims.empty()); static_cast<int32_t>(!dynamic_image_size.empty()) + static_cast<int32_t>(!dynamic_dims.empty());
if (param_size > 1) { if (param_size > 1) {
ErrorManager::GetInstance().ATCReportErrMessage("E10009", {"parameter0", "parameter1", "parameter2"}, ErrorManager::GetInstance().ATCReportErrMessage("E10009", {"parameter0", "parameter1", "parameter2"},
{"dynamic_batch_size", "dynamic_image_size", "dynamic_dims"}); {"dynamic_batch_size", "dynamic_image_size", "dynamic_dims"});
GELOGE(ge::PARAM_INVALID, GELOGE(ge::PARAM_INVALID,
"[Parse][Parameter]dynamic_batch_size, dynamic_image_size and dynamic_dims can only be set one"); "[Parse][Parameter]dynamic_batch_size, dynamic_image_size and dynamic_dims can only be set one");
return ge::PARAM_INVALID; return ge::PARAM_INVALID;
} }
@ -424,8 +424,8 @@ Status CheckDynamicInputParamValid(string &dynamic_batch_size, string &dynamic_i
is_dynamic_input = true; is_dynamic_input = true;
if (input_shape.empty()) { if (input_shape.empty()) {
ErrorManager::GetInstance().ATCReportErrMessage("E10004", {"parameter"}, {"input_shape"}); ErrorManager::GetInstance().ATCReportErrMessage("E10004", {"parameter"}, {"input_shape"});
GELOGE(ge::PARAM_INVALID, GELOGE(ge::PARAM_INVALID,
"[Check][Parameter:input_shape]The input_shape can not be empty in dynamic input size scenario."); "[Check][Parameter:input_shape]The input_shape can not be empty in dynamic input size scenario.");
return ge::PARAM_INVALID; return ge::PARAM_INVALID;
} }
@ -443,8 +443,8 @@ Status CheckDynamicInputParamValid(string &dynamic_batch_size, string &dynamic_i
if (!dynamic_image_size.empty()) { if (!dynamic_image_size.empty()) {
if (!CheckDynamicImagesizeInputShapeValid(shape_map, input_format, dynamic_image_size)) { if (!CheckDynamicImagesizeInputShapeValid(shape_map, input_format, dynamic_image_size)) {
GELOGE(ge::PARAM_INVALID, "[Check][DynamicImagesizeInputShape] %s invalid. dynamic_image_size:%s ", GELOGE(ge::PARAM_INVALID, "[Check][DynamicImagesizeInputShape] %s invalid. dynamic_image_size:%s ",
input_shape.c_str(), dynamic_image_size.c_str()); input_shape.c_str(), dynamic_image_size.c_str());
return ge::PARAM_INVALID; return ge::PARAM_INVALID;
} }
} }
@ -452,7 +452,7 @@ Status CheckDynamicInputParamValid(string &dynamic_batch_size, string &dynamic_i
if (!dynamic_dims.empty()) { if (!dynamic_dims.empty()) {
if (!CheckDynamicDimsInputShapeValid(shape_map, input_format, dynamic_dims)) { if (!CheckDynamicDimsInputShapeValid(shape_map, input_format, dynamic_dims)) {
GELOGE(ge::PARAM_INVALID, "[Check][DynamicDimsInputShape]: %s of input shape: %s failed.", dynamic_dims.c_str(), GELOGE(ge::PARAM_INVALID, "[Check][DynamicDimsInputShape]: %s of input shape: %s failed.", dynamic_dims.c_str(),
input_shape.c_str()); input_shape.c_str());
return ge::PARAM_INVALID; return ge::PARAM_INVALID;
} }
} }
@ -504,7 +504,7 @@ bool ParseInputShape(const string &input_shape, map<string, vector<int64_t>> &sh
ErrorManager::GetInstance().ATCReportErrMessage("E10002", {"shape", "reason", "sample"}, ErrorManager::GetInstance().ATCReportErrMessage("E10002", {"shape", "reason", "sample"},
{shape, kDigitError, kInputShapeSample2}); {shape, kDigitError, kInputShapeSample2});
GELOGE(PARAM_INVALID, "[Check][Param]--input_shape's shape value[%s] is not digit", GELOGE(PARAM_INVALID, "[Check][Param]--input_shape's shape value[%s] is not digit",
shape_value_str.c_str()); shape_value_str.c_str());
return false; return false;
} }
} }
@ -547,10 +547,10 @@ bool ParseInputShape(const string &input_shape, map<string, vector<int64_t>> &sh
Status CheckOutputTypeParamValid(const std::string output_type) { Status CheckOutputTypeParamValid(const std::string output_type) {
if ((!output_type.empty()) && (kOutputTypeSupportDatatype.find(output_type) == kOutputTypeSupportDatatype.end())) { if ((!output_type.empty()) && (kOutputTypeSupportDatatype.find(output_type) == kOutputTypeSupportDatatype.end())) {
ErrorManager::GetInstance().ATCReportErrMessage( ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},
"E10001", {"parameter", "value", "reason"}, {"--output_type", output_type, kOutputTypeSupport}); {"--output_type", output_type, kOutputTypeSupport});
GELOGE(ge::PARAM_INVALID, GELOGE(ge::PARAM_INVALID,
"[Check][Param]Invalid value for --output_type[%s], %s.", output_type.c_str(), kOutputTypeSupport); "[Check][Param]Invalid value for --output_type[%s], %s.", output_type.c_str(), kOutputTypeSupport);
return ge::PARAM_INVALID; return ge::PARAM_INVALID;
} }
return ge::SUCCESS; return ge::SUCCESS;
@ -559,10 +559,10 @@ Status CheckOutputTypeParamValid(const std::string output_type) {
Status CheckBufferOptimizeParamValid(const std::string buffer_optimize) { Status CheckBufferOptimizeParamValid(const std::string buffer_optimize) {
if ((!buffer_optimize.empty()) && if ((!buffer_optimize.empty()) &&
(kBufferOptimizeSupportOption.find(buffer_optimize) == kBufferOptimizeSupportOption.end())) { (kBufferOptimizeSupportOption.find(buffer_optimize) == kBufferOptimizeSupportOption.end())) {
ErrorManager::GetInstance().ATCReportErrMessage( ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},
"E10001", {"parameter", "value", "reason"}, {"--buffer_optimize", buffer_optimize, kBufferOptimizeSupport}); {"--buffer_optimize", buffer_optimize, kBufferOptimizeSupport});
GELOGE(ge::PARAM_INVALID, GELOGE(ge::PARAM_INVALID,
"[Check][BufferOptimize]Invalid value for [%s], %s.", buffer_optimize.c_str(), kBufferOptimizeSupport); "[Check][BufferOptimize]Invalid value for [%s], %s.", buffer_optimize.c_str(), kBufferOptimizeSupport);
return ge::PARAM_INVALID; return ge::PARAM_INVALID;
} }
return ge::SUCCESS; return ge::SUCCESS;
@ -573,23 +573,23 @@ Status CheckCompressWeightParamValid(const std::string enable_compress_weight,
if ((!compress_weight_conf.empty()) && if ((!compress_weight_conf.empty()) &&
(!CheckInputPathValid(compress_weight_conf, "--compress_weight_conf"))) { (!CheckInputPathValid(compress_weight_conf, "--compress_weight_conf"))) {
GELOGE(ge::PARAM_INVALID, "[Check][InputPath]compress weight config file not found, file_name:%s", GELOGE(ge::PARAM_INVALID, "[Check][InputPath]compress weight config file not found, file_name:%s",
compress_weight_conf.c_str()); compress_weight_conf.c_str());
return ge::PARAM_INVALID; return ge::PARAM_INVALID;
} }
if ((enable_compress_weight != "") && (enable_compress_weight != "true") && (enable_compress_weight != "false")) { if ((enable_compress_weight != "") && (enable_compress_weight != "true") && (enable_compress_weight != "false")) {
ErrorManager::GetInstance().ATCReportErrMessage( ErrorManager::GetInstance().ATCReportErrMessage("E10005", {"parameter", "value"},
"E10005", {"parameter", "value"}, {"enable_compress_weight", enable_compress_weight}); {"enable_compress_weight", enable_compress_weight});
GELOGE(ge::PARAM_INVALID, GELOGE(ge::PARAM_INVALID, "[Check][Param:enable_compress_weight]"
"[Check][Param:enable_compress_weight]Input parameter[--enable_compress_weight]'s value:%s must be true or false.", "Input parameter[--enable_compress_weight]'s value:%s must be true or false.",
enable_compress_weight.c_str()); enable_compress_weight.c_str());
return ge::PARAM_INVALID; return ge::PARAM_INVALID;
} }
if ((enable_compress_weight == "true") && (!compress_weight_conf.empty())) { if ((enable_compress_weight == "true") && (!compress_weight_conf.empty())) {
ErrorManager::GetInstance().ATCReportErrMessage("E10047", {"parameter0", "parameter1"}, ErrorManager::GetInstance().ATCReportErrMessage("E10047", {"parameter0", "parameter1"},
{"enable_compress_weight", "compress_weight_conf"}); {"enable_compress_weight", "compress_weight_conf"});
GELOGE(ge::PARAM_INVALID, GELOGE(ge::PARAM_INVALID,
"[Check][CompressWeight]enable_compress_weight and compress_weight_conf can not both exist!!"); "[Check][CompressWeight]enable_compress_weight and compress_weight_conf can not both exist!!");
return ge::PARAM_INVALID; return ge::PARAM_INVALID;
} }
return ge::SUCCESS; return ge::SUCCESS;
@ -597,8 +597,8 @@ Status CheckCompressWeightParamValid(const std::string enable_compress_weight,
Status CheckKeepTypeParamValid(const std::string &keep_dtype) { Status CheckKeepTypeParamValid(const std::string &keep_dtype) {
if ((!keep_dtype.empty()) && (!CheckInputPathValid(keep_dtype, "--keep_dtype"))) { if ((!keep_dtype.empty()) && (!CheckInputPathValid(keep_dtype, "--keep_dtype"))) {
ErrorManager::GetInstance().ATCReportErrMessage( ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},
"E10001", {"parameter", "value", "reason"}, {"--keep_dtype", keep_dtype, kKeepDtypeError}); {"--keep_dtype", keep_dtype, kKeepDtypeError});
GELOGE(ge::PARAM_INVALID, "[Check][InputPath::--keep_dtype] file not found, file_name:%s", keep_dtype.c_str()); GELOGE(ge::PARAM_INVALID, "[Check][InputPath::--keep_dtype] file not found, file_name:%s", keep_dtype.c_str());
return ge::PARAM_INVALID; return ge::PARAM_INVALID;
} }
@ -622,12 +622,12 @@ int CheckLogParamValidAndSetLogLevel(const std::string log) {
ret = dlog_setlevel(-1, DLOG_ERROR, 1); ret = dlog_setlevel(-1, DLOG_ERROR, 1);
} else { } else {
GELOGE(ge::PARAM_INVALID, GELOGE(ge::PARAM_INVALID,
"[Check][LogParam]log:%s invalid, only support debug, info, warning, error, null", log.c_str()); "[Check][LogParam]log:%s invalid, only support debug, info, warning, error, null", log.c_str());
REPORT_INPUT_ERROR("E10417", std::vector<std::string>({"loglevel"}), std::vector<std::string>({log})); REPORT_INPUT_ERROR("E10417", std::vector<std::string>({"loglevel"}), std::vector<std::string>({log}));
return ret; return ret;
} }
if (ret != 0) { if (ret != 0) {
GELOGE(ge::PARAM_INVALID, "[Set][LogLevel] fail, level:%s.",log.c_str()); GELOGE(ge::PARAM_INVALID, "[Set][LogLevel] fail, level:%s.", log.c_str());
REPORT_INPUT_ERROR("E10417", std::vector<std::string>({"loglevel"}), std::vector<std::string>({log})); REPORT_INPUT_ERROR("E10417", std::vector<std::string>({"loglevel"}), std::vector<std::string>({log}));
} }
@ -654,10 +654,10 @@ Status CheckDisableReuseMemoryParamValid(const std::string disable_reuse_memory)
Status CheckEnableSingleStreamParamValid(const std::string enable_single_stream) { Status CheckEnableSingleStreamParamValid(const std::string enable_single_stream) {
if ((enable_single_stream != "") && (enable_single_stream != "true") && (enable_single_stream != "false")) { if ((enable_single_stream != "") && (enable_single_stream != "true") && (enable_single_stream != "false")) {
ErrorManager::GetInstance().ATCReportErrMessage( ErrorManager::GetInstance().ATCReportErrMessage("E10005", {"parameter", "value"},
"E10005", {"parameter", "value"}, {"enable_single_stream", enable_single_stream}); {"enable_single_stream", enable_single_stream});
GELOGE(ge::PARAM_INVALID, "[Check][Param:--enable_single_stream] value:%s must be true or false.", GELOGE(ge::PARAM_INVALID, "[Check][Param:--enable_single_stream] value:%s must be true or false.",
enable_single_stream.c_str()); enable_single_stream.c_str());
return ge::PARAM_INVALID; return ge::PARAM_INVALID;
} }
return ge::SUCCESS; return ge::SUCCESS;
@ -667,9 +667,10 @@ Status CheckImplmodeParamValid(const std::string &optypelist_for_implmode, std::
// only appointed op_select_implmode, can user appoint optypelist_for_implmode // only appointed op_select_implmode, can user appoint optypelist_for_implmode
if (optypelist_for_implmode != "" && op_select_implmode == "") { if (optypelist_for_implmode != "" && op_select_implmode == "") {
ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},
{"--op_select_implmode", op_select_implmode.c_str(), kCompressWeightError}); {"--op_select_implmode", op_select_implmode.c_str(),
kCompressWeightError});
GELOGE(ge::PARAM_INVALID, "[Check][Param:--op_select_implmode]value:%s invalid, %s.", GELOGE(ge::PARAM_INVALID, "[Check][Param:--op_select_implmode]value:%s invalid, %s.",
op_select_implmode.c_str(),kCompressWeightError); op_select_implmode.c_str(), kCompressWeightError);
return ge::PARAM_INVALID; return ge::PARAM_INVALID;
} }
// op_select_implmode default value is high_performance // op_select_implmode default value is high_performance
@ -679,9 +680,10 @@ Status CheckImplmodeParamValid(const std::string &optypelist_for_implmode, std::
if (op_select_implmode != IR_OPTION_OP_SELECT_IMPLMODE_DEFAULT && if (op_select_implmode != IR_OPTION_OP_SELECT_IMPLMODE_DEFAULT &&
op_select_implmode != IR_OPTION_OP_SELECT_IMPLMODE_PRECISON) { op_select_implmode != IR_OPTION_OP_SELECT_IMPLMODE_PRECISON) {
ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},
{"--op_select_implmode", op_select_implmode.c_str(), kSelectImplmodeError}); {"--op_select_implmode", op_select_implmode.c_str(),
kSelectImplmodeError});
GELOGE(ge::PARAM_INVALID, "[Check][Implmode]Invalid value for --op_select_implmode[%s], %s.", GELOGE(ge::PARAM_INVALID, "[Check][Implmode]Invalid value for --op_select_implmode[%s], %s.",
op_select_implmode.c_str(), kSelectImplmodeError); op_select_implmode.c_str(), kSelectImplmodeError);
return ge::PARAM_INVALID; return ge::PARAM_INVALID;
} }
} }

5
ge/ir_build/ge_ir_build.cc
Unescape View File

@ -562,7 +562,8 @@ graphStatus Impl::InitDomiOmgContext(const string &input_shape, const string &in
if (iter != ge::input_format_str_to_geformat.end()) { if (iter != ge::input_format_str_to_geformat.end()) {
omg_context_.format = iter->second; omg_context_.format = iter->second;
} else { } else {
GELOGE(GRAPH_PARAM_INVALID, "[Check][Param:InputForamt] %s not support , expect ND/NCHW/NHWC/CHWN/NC1HWC0/NHWC1C0.", GELOGE(GRAPH_PARAM_INVALID,
"[Check][Param:InputForamt] %s not support , expect ND/NCHW/NHWC/CHWN/NC1HWC0/NHWC1C0.",
input_format.c_str()); input_format.c_str());
return GRAPH_PARAM_INVALID; return GRAPH_PARAM_INVALID;
} }
@ -573,7 +574,7 @@ graphStatus Impl::InitDomiOmgContext(const string &input_shape, const string &in
} }
if (!ParseInputShape(input_shape, omg_context_.input_dims, omg_context_.user_input_dims, is_dynamic_input)) { if (!ParseInputShape(input_shape, omg_context_.input_dims, omg_context_.user_input_dims, is_dynamic_input)) {
GELOGE(GRAPH_PARAM_INVALID, "[Parse][InputShape:ImputShape] Failed, shape: %s", input_shape.c_str()); GELOGE(GRAPH_PARAM_INVALID, "[Parse][InputShape:input_shape] Failed, shape: %s", input_shape.c_str());
return GRAPH_PARAM_INVALID; return GRAPH_PARAM_INVALID;
} }
return GRAPH_SUCCESS; return GRAPH_SUCCESS;

6
ge/omm/csa_interact.cc
Unescape View File

@ -108,10 +108,10 @@ Status CsaInteract::WriteJobState(JobState job_state, JobSubState job_sub_state,
content = content_json.dump(); content = content_json.dump();
} catch (const nlohmann::json::exception &e) { } catch (const nlohmann::json::exception &e) {
GELOGE(INTERNAL_ERROR, "[Create][JsonObject] exception:%s job_state:%u job_sub_state:%u.", GELOGE(INTERNAL_ERROR, "[Create][JsonObject] exception:%s job_state:%u job_sub_state:%u.",
e.what(), job_state,job_sub_state); e.what(), job_state, job_sub_state);
REPORT_INNER_ERROR("E19999", "Create json object failed. exception:%s job_state:%u job_sub_state:%u.", REPORT_INNER_ERROR("E19999", "Create json object failed. exception:%s job_state:%u job_sub_state:%u.",
e.what(), job_state,job_sub_state); e.what(), job_state, job_sub_state);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }

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

Write Preview
Loading…
Cancel
Save