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

modify INNER error to CALL error when new

Browse Source
pull/1387/head
wangxiaotian22 4 years ago
parent 1adc95ae36
commit 04d17e7a39
5 changed files with 39 additions and 39 deletions
Show Stats Download Patch File Download Diff File

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

@ -118,8 +118,8 @@ Status GraphMemoryAssigner::AssignMemory() {
if (variable_assigner == nullptr) {
GELOGE(ge::FAILED, "[New][Object:VariableMemoryAssigner]graph_id:%u, graph_name:%s",
compute_graph_->GetGraphID(), compute_graph_->GetName().c_str());
REPORT_INNER_ERROR("E19999", "New Object:VariableMemoryAssigner failed when assign graph memory, "
"graph_id:%u, graph_name:%s", compute_graph_->GetGraphID(), compute_graph_->GetName().c_str());
REPORT_CALL_ERROR("E19999", "New Object:VariableMemoryAssigner failed when assign graph memory, "
"graph_id:%u, graph_name:%s", compute_graph_->GetGraphID(), compute_graph_->GetName().c_str());
return ge::FAILED;
}
@ -140,8 +140,8 @@ ge::Status GraphMemoryAssigner::AssignVarAttr2Nodes() {
if (variable_assigner == nullptr) {
GELOGE(ge::FAILED, "[New][Object:VariableMemoryAssigner]graph_id:%u, graph_name:%s",
compute_graph_->GetGraphID(), compute_graph_->GetName().c_str());
REPORT_INNER_ERROR("E19999", "New Object:VariableMemoryAssigner failed when assign graph memory, "
"graph_id:%u, graph_name:%s", compute_graph_->GetGraphID(), compute_graph_->GetName().c_str());
REPORT_CALL_ERROR("E19999", "New Object:VariableMemoryAssigner failed when assign graph memory, "
"graph_id:%u, graph_name:%s", compute_graph_->GetGraphID(), compute_graph_->GetName().c_str());
return ge::FAILED;
}
if (variable_assigner->AssignVarAttr2Nodes() != ge::SUCCESS) {
@ -156,8 +156,8 @@ ge::Status GraphMemoryAssigner::AssignMemory2HasRefAttrNode() {
if (variable_assigner == nullptr) {
GELOGE(ge::FAILED, "[New][Object:VariableMemoryAssigner]graph_id:%u, graph_name:%s",
compute_graph_->GetGraphID(), compute_graph_->GetName().c_str());
REPORT_INNER_ERROR("E19999", "New Object:VariableMemoryAssigner failed when assign graph memory, "
"graph_id:%u, graph_name:%s", compute_graph_->GetGraphID(), compute_graph_->GetName().c_str());
REPORT_CALL_ERROR("E19999", "New Object:VariableMemoryAssigner failed when assign graph memory, "
"graph_id:%u, graph_name:%s", compute_graph_->GetGraphID(), compute_graph_->GetName().c_str());
}
if (variable_assigner->AssignMemory2HasRefAttrNode() != ge::SUCCESS) {
return ge::FAILED;
@ -171,7 +171,7 @@ ge::Status CalculateTensorRealSizeAndOutSize(const ge::ConstGeTensorDescPtr &out
graphStatus graph_status = ge::TensorUtils::GetSize(*output_desc, out_size);
if (graph_status != GRAPH_SUCCESS) {
GELOGE(FAILED, "[Get][TensorSize]");
REPORT_INNER_ERROR("E19999", "New Object:VariableMemoryAssigner failed when assign graph memory");
REPORT_INNER_ERROR("E19999", "Get tensor size failed when %s", __FUNCTION__);
return FAILED;
}

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

@ -301,8 +301,8 @@ Status GraphExecutor::SyncExecuteModel(uint32_t model_id, const std::vector<GeTe
return GE_GRAPH_EXECUTE_FAILED);
std::unique_ptr<uint8_t> outBufTmp(new (std::nothrow) uint8_t[outputDataTmp.length]);
if (outBufTmp == nullptr) {
REPORT_INNER_ERROR("E19999", "New output buffer fail, length:%lu, model:%u, when %s",
outputDataTmp.length, model_id, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New output buffer fail, length:%lu, model:%u, when %s",
outputDataTmp.length, model_id, __FUNCTION__);
GELOGE(FAILED, "Failed to allocate memory.");
return FAILED;
}

36
ge/graph/load/model_manager/davinci_model.cc
Unescape View File

@ -1627,8 +1627,8 @@ Status DavinciModel::CpuModelDequeue(uint32_t queue_id) {
GELOGI("Set CpuKernel model dequeue task enter.");
std::shared_ptr<CpuTaskModelDequeue> dequeue_task = MakeShared<CpuTaskModelDequeue>(rt_entry_stream_);
if (dequeue_task == nullptr) {
REPORT_INNER_ERROR("E19999", "New CpuTaskModelDequeue failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New CpuTaskModelDequeue failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "Make CpuTaskModelDequeue task failed.");
return MEMALLOC_FAILED;
}
@ -1651,8 +1651,8 @@ Status DavinciModel::CpuTaskModelZeroCopy(std::vector<uintptr_t> &mbuf_list,
GELOGI("Set CpuKernel model zero_copy task enter.");
std::shared_ptr<CpuTaskZeroCopy> zero_copy = MakeShared<CpuTaskZeroCopy>(rt_entry_stream_);
if (zero_copy == nullptr) {
REPORT_INNER_ERROR("E19999", "New CpuTaskZeroCopy failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New CpuTaskZeroCopy failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "Make CpuTaskZeroCopy task failed.");
return MEMALLOC_FAILED;
}
@ -1726,8 +1726,8 @@ Status DavinciModel::CpuModelPrepareOutput(uintptr_t addr, uint32_t size) {
std::shared_ptr<CpuTaskPrepareOutput> prepare_output = MakeShared<CpuTaskPrepareOutput>(rt_entry_stream_);
if (prepare_output == nullptr) {
REPORT_INNER_ERROR("E19999", "New CpuTaskPrepareOutput failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New CpuTaskPrepareOutput failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "Make CpuTaskPrepareOutput task failed.");
return MEMALLOC_FAILED;
}
@ -1752,8 +1752,8 @@ Status DavinciModel::CpuActiveStream() {
GELOGI("Set CpuKernel active stream task enter.");
std::shared_ptr<CpuTaskActiveEntry> active_entry = MakeShared<CpuTaskActiveEntry>(rt_entry_stream_);
if (active_entry == nullptr) {
REPORT_INNER_ERROR("E19999", "New CpuTaskActiveEntry failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New CpuTaskActiveEntry failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "Make CpuTaskActiveEntry task failed.");
return MEMALLOC_FAILED;
}
@ -1775,8 +1775,8 @@ Status DavinciModel::CpuWaitEndGraph() {
GELOGI("Set CpuKernel wait end graph task enter.");
std::shared_ptr<CpuTaskWaitEndGraph> wait_endgraph = MakeShared<CpuTaskWaitEndGraph>(rt_entry_stream_);
if (wait_endgraph == nullptr) {
REPORT_INNER_ERROR("E19999", "New CpuTaskWaitEndGraph failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New CpuTaskWaitEndGraph failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "Make CpuTaskWaitEndGraph task failed.");
return MEMALLOC_FAILED;
}
@ -1813,8 +1813,8 @@ Status DavinciModel::CpuModelEnqueue(uint32_t queue_id, uintptr_t out_mbuf) {
GELOGI("Set CpuKernel model enqueue task enter.");
std::shared_ptr<CpuTaskModelEnqueue> model_enqueue = MakeShared<CpuTaskModelEnqueue>(rt_entry_stream_);
if (model_enqueue == nullptr) {
REPORT_INNER_ERROR("E19999", "New CpuTaskModelEnqueue failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New CpuTaskModelEnqueue failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "Make CpuTaskModelEnqueue task failed.");
return MEMALLOC_FAILED;
}
@ -1835,8 +1835,8 @@ Status DavinciModel::CpuModelRepeat() {
GELOGI("Set CpuKernel repeat task enter.");
std::shared_ptr<CpuTaskModelRepeat> model_repeat = MakeShared<CpuTaskModelRepeat>(rt_entry_stream_);
if (model_repeat == nullptr) {
REPORT_INNER_ERROR("E19999", "New CpuTaskModelRepeat failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New CpuTaskModelRepeat failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "Make CpuTaskModelRepeat task failed.");
return MEMALLOC_FAILED;
}
@ -2608,8 +2608,8 @@ Status DavinciModel::GenOutputTensorInfo(OutputData *output_data, vector<OutputT
for (size_t i = 0; i < output_buffer_size.size(); ++i) {
std::unique_ptr<uint8_t[]> data_buf(new (std::nothrow) uint8_t[output_buffer_size[i]]);
if (data_buf == nullptr) {
REPORT_INNER_ERROR("E19999", "New buffer failed, size:%ld, model_id:%u when DavinciModel %s",
output_buffer_size[i], model_id_, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New buffer failed, size:%ld, model_id:%u when DavinciModel %s",
output_buffer_size[i], model_id_, __FUNCTION__);
GELOGE(GE_GRAPH_MALLOC_FAILED, "Malloc buffer failed.");
return GE_GRAPH_MALLOC_FAILED;
}
@ -3926,8 +3926,8 @@ Status DavinciModel::AddHeadStream() {
for (auto s : active_stream_list_) {
std::shared_ptr<CpuTaskActiveEntry> active_entry = MakeShared<CpuTaskActiveEntry>(rt_head_stream_);
if (active_entry == nullptr) {
REPORT_INNER_ERROR("E19999", "New CpuTaskActiveEntry failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New CpuTaskActiveEntry failed, model_id:%u, when DavinciModel %s",
model_id_, __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "Make CpuTaskActiveEntry task failed.");
return MEMALLOC_FAILED;
}

8
ge/graph/load/model_manager/task_info/kernel_task_info.cc
Unescape View File

@ -782,8 +782,8 @@ Status KernelTaskInfo::InitAICPUCustomTask(uint32_t op_index, const domi::Kernel
const uint32_t kCustomAicpuArgsLen = 5;
ctx_.argsOffset = new (std::nothrow) uint16_t[kCustomAicpuArgsLen]();
if (ctx_.argsOffset == nullptr) {
REPORT_INNER_ERROR("E19999", "New ctx_.argsOffset fail, size:%u, op:%s(%s), when KernelTaskInfo %s",
kCustomAicpuArgsLen, op_desc->GetName().c_str(), op_desc->GetType().c_str(), __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New ctx_.argsOffset fail, size:%u, op:%s(%s), when KernelTaskInfo %s",
kCustomAicpuArgsLen, op_desc->GetName().c_str(), op_desc->GetType().c_str(), __FUNCTION__);
GELOGE(PARAM_INVALID, "ctx_.argsOffset is null!");
return PARAM_INVALID;
}
@ -1273,8 +1273,8 @@ Status KernelTaskInfo::SetContext(const domi::KernelDef &kernel_def) {
// ctx_.argsOffset stores the offset of the internal information of agrs_, equal to the ctx_.argsCount
ctx_.argsOffset = new (std::nothrow) uint16_t[ctx_.argsCount]();
if (ctx_.argsOffset == nullptr) {
REPORT_INNER_ERROR("E19999", "New ctx_.argsOffset fail, size:%u, when KernelTaskInfo %s",
ctx_.argsCount, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New ctx_.argsOffset fail, size:%u, when KernelTaskInfo %s",
ctx_.argsCount, __FUNCTION__);
GELOGE(PARAM_INVALID, "(param [ctx_.argsOffset] must not be null.");
return PARAM_INVALID;
}

16
ge/graph/manager/graph_manager.cc
Unescape View File

@ -166,14 +166,14 @@ Status GraphManager::Initialize(const std::map<string, string> &options) {
// malloc
graph_run_listener_ = MakeShared<GraphModelListener>(sync_run_mutex_, condition_);
if (graph_run_listener_ == nullptr) {
REPORT_INNER_ERROR("E19999", "New GraphModelListener fail when GraphManager %s", __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New GraphModelListener fail when GraphManager %s", __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "Make shared failed");
return MEMALLOC_FAILED;
}
// graph context
graph_context_ = MakeShared<GraphContext>();
if (graph_context_ == nullptr) {
REPORT_INNER_ERROR("E19999", "New GraphModelListener fail when GraphManager %s", __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New GraphModelListener fail when GraphManager %s", __FUNCTION__);
GELOGE(MEMALLOC_FAILED, "Make shared failed.");
return MEMALLOC_FAILED;
}
@ -366,14 +366,14 @@ Status GraphManager::AddGraph(const GraphId &graph_id, const Graph &graph,
GraphNodePtr graph_node = MakeShared<ge::GraphNode>(graph_id);
GE_IF_BOOL_EXEC(graph_node == nullptr,
REPORT_INNER_ERROR("E19999", "New GraphNode fail, graph_id:%u, when GraphManager %s",
graph_id, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New GraphNode fail, graph_id:%u, when GraphManager %s",
graph_id, __FUNCTION__);
GELOGE(FAILED, "GraphNode make shared failed");
return FAILED);
std::shared_ptr<Graph> graph_ptr = MakeShared<ge::Graph>(graph);
GE_IF_BOOL_EXEC(graph_ptr == nullptr,
REPORT_INNER_ERROR("E19999", "New Graph fail, graph_id:%u, when GraphManager %s",
graph_id, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New Graph fail, graph_id:%u, when GraphManager %s",
graph_id, __FUNCTION__);
GELOGE(FAILED, "GraphPtr make shared failed");
return FAILED);
// update option about tuning graph
@ -457,8 +457,8 @@ Status GraphManager::AddGraphWithCopy(const GraphId &graph_id, const Graph &grap
}
std::shared_ptr<Graph> graph_ptr = GraphUtils::CreateGraphPtrFromComputeGraph(new_compute_graph);
if (graph_ptr == nullptr) {
REPORT_INNER_ERROR("E19999", "New Graph fail, graph_id:%u, when GraphManager %s",
graph_id, __FUNCTION__);
REPORT_CALL_ERROR("E19999", "New Graph fail, graph_id:%u, when GraphManager %s",
graph_id, __FUNCTION__);
GELOGE(FAILED, "GraphPtr make shared failed");
return FAILED;
}

Write Preview
Loading…
Cancel
Save