From aaee4d203484228b2684d63588c6a615550d3068 Mon Sep 17 00:00:00 2001 From: medivh-x Date: Thu, 8 Jul 2021 16:59:58 +0800 Subject: [PATCH 1/5] optimize model manager::ExecuteModel --- ge/graph/execute/graph_execute.cc | 2 +- ge/graph/load/model_manager/model_manager.cc | 72 ++++++++++++++++++++++++++++ ge/graph/load/model_manager/model_manager.h | 3 ++ 3 files changed, 76 insertions(+), 1 deletion(-) diff --git a/ge/graph/execute/graph_execute.cc b/ge/graph/execute/graph_execute.cc index 03abf91f..3beb8f0e 100755 --- a/ge/graph/execute/graph_execute.cc +++ b/ge/graph/execute/graph_execute.cc @@ -454,7 +454,7 @@ Status GraphExecutor::ExecuteGraphWithStream(GraphId graph_id, auto async_mode = true; auto model_manager = ge::ModelManager::GetInstance(); GE_CHECK_NOTNULL(model_manager); - ret = model_manager->ExecuteModel(model_id, stream, async_mode, input_data, input_desc, output_data, output_desc); + ret = model_manager->ExecuteModel(model_id, stream, async_mode, input_tensor, output_tensor); if (ret != SUCCESS) { return ret; } diff --git a/ge/graph/load/model_manager/model_manager.cc b/ge/graph/load/model_manager/model_manager.cc index d0d88e66..fb4af267 100755 --- a/ge/graph/load/model_manager/model_manager.cc +++ b/ge/graph/load/model_manager/model_manager.cc @@ -1332,6 +1332,78 @@ Status ModelManager::ExecuteModel(uint32_t model_id, rtStream_t stream, bool asy return status; } +namespace { +void GetGeTensorBlobs(const std::vector &tensors, std::vector &blobs) { + blobs.resize(tensors.size()); + for (size_t i = 0; i < tensors.size(); i++) { + auto &tensor = tensors[i]; + auto &buf = blobs[i]; + buf.data = const_cast(tensor.GetData().data()); + buf.length = tensor.GetData().size(); + buf.isDataSupportMemShare = false; + } +} + +void GetGeTensorDescs(const std::vector &tensors, std::vector &descs) { + descs.reserve(tensors.size()); + for (auto &tensor : tensors) { + descs.emplace_back(std::move(tensor.GetTensorDesc())); + } +} +} + +ge::Status ExecuteModel(uint32_t model_id, rtStream_t stream, bool async_mode, const std::vector &input_tensor, + std::vector &output_tensor) { + InputData input_data; + input_data.index = 0; + input_data.model_id = model_id; + + OutputData output_data; + output_data.index = 0; + output_data.model_id = model_id; + + GetGeTensorBlobs(input_tensor, input_data.blobs); + GetGeTensorBlobs(output_tensor, output_data.blobs); + + std::shared_ptr hybrid_davinci_model = GetHybridModel(model_id); + if (hybrid_davinci_model != nullptr) { + std::vector input_desc; + std::vector output_desc; + GetGeTensorDescs(input_tensor, input_desc); + GetGeTensorDescs(output_tensor, output_desc); + + Status status = hybrid_davinci_model->Execute(input_data.blobs, input_desc, output_data.blobs, output_desc, stream); + if (status == SUCCESS) { + GELOGI("Execute model %u success.", model_id); + } + return status; + } + + std::shared_ptr davinci_model = GetModel(model_id); + GE_CHK_BOOL_RET_STATUS(davinci_model != nullptr, ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, + "[Get][Model] Invalid model id %u, check whether model has been loaded or not.", model_id); + + if (davinci_model->NeedDestroyAicpuKernel()) { + GELOGI("Start to destroy specified aicpu kernel."); + // Zero copy is enabled by default, no need to judge. + uint64_t session_id_davinci = davinci_model->GetSessionId(); + uint32_t model_id_davinci = davinci_model->GetModelId(); + uint32_t sub_model_id = davinci_model->SubModelId(); + Status status = DestroyAicpuKernel(session_id_davinci, model_id_davinci, sub_model_id); + if (status != SUCCESS) { + GELOGW("Destroy specified aicpu kernel failed, session id is %lu, model id is %u.", session_id_davinci, + model_id_davinci); + } + } + + Status status = davinci_model->NnExecute(stream, async_mode, input_data, output_data); + if (status == SUCCESS) { + GELOGD("Execute model %u success.", model_id); + } + + return status; +} + Status ModelManager::CreateAicpuSession(uint64_t session_id) { std::lock_guard lock(map_mutex_); auto it = sess_ids_.find(session_id); diff --git a/ge/graph/load/model_manager/model_manager.h b/ge/graph/load/model_manager/model_manager.h index 6389d6db..b160ba3b 100755 --- a/ge/graph/load/model_manager/model_manager.h +++ b/ge/graph/load/model_manager/model_manager.h @@ -157,6 +157,9 @@ class FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ModelManager { const std::vector &input_desc, OutputData &output_data, std::vector &output_desc); + ge::Status ExecuteModel(uint32_t model_id, rtStream_t stream, bool async_mode, const std::vector &inputs, + std::vector &outputs); + ge::Status SyncExecuteModel(uint32_t model_id, const std::vector &inputs, std::vector &outputs); /// From 13066c7009fc74b6f448f16e10deda33049d5435 Mon Sep 17 00:00:00 2001 From: medivh-x Date: Thu, 8 Jul 2021 17:17:44 +0800 Subject: [PATCH 2/5] add move version for InnerSession::RunGraphWithStreamAsync --- ge/session/inner_session.cc | 47 +++++++++++++++++++++++++++++++++++++++++++++ ge/session/inner_session.h | 3 +++ 2 files changed, 50 insertions(+) diff --git a/ge/session/inner_session.cc b/ge/session/inner_session.cc index b9c44ef1..9b7bef25 100755 --- a/ge/session/inner_session.cc +++ b/ge/session/inner_session.cc @@ -371,6 +371,53 @@ Status InnerSession::RunGraphWithStreamAsync(uint32_t graph_id, rtStream_t strea } } +Status InnerSession::RunGraphWithStreamAsync(uint32_t graph_id, rtStream_t stream, + std::vector &&inputs, std::vector &&outputs) { + GELOGI("Run graph with stream, session id = %lu, graph id = %u, stream = %p in move mode", + session_id_, graph_id, stream); + if (mutex_.try_lock()) { + std::lock_guard lock(mutex_, std::adopt_lock); + if (!init_flag_) { + GELOGE(GE_SESS_INIT_FAILED, "[Run][GraphWithStream]failed because GraphManager not Init," + "session id = %lu, graph id = %u, stream = %p.", session_id_, graph_id, stream); + REPORT_INNER_ERROR("E19999", "RunGraphWithStreamAsync failed because GraphManager not Init," + "session id = %lu, graph id = %u, stream = %p.", session_id_, graph_id, stream); + return GE_SESS_INIT_FAILED; + } + UpdateThreadContext(graph_id); + vector ge_inputs; + ge_inputs.reserve(inputs.size()); + for (auto &item : inputs) { + ge_inputs.emplace_back(TensorAdapter::AsGeTensor(std::move(item))); + } + vector ge_outputs; + ge_outputs.reserve(outputs.size()); + for (auto &item : outputs) { + ge_outputs.emplace_back(TensorAdapter::AsGeTensor(std::move(item))); + } + Status ret = graph_manager_.RunGraphWithStreamAsync(graph_id, stream, session_id_, ge_inputs, ge_outputs); + domi::GetContext().out_nodes_map.clear(); + domi::GetContext().user_out_nodes.clear(); + if (ret != SUCCESS) { + GELOGE(ret, "[Run][GraphWithStreamAsync]failed," + "session id = %lu, graph id = %u, stream = %p.", session_id_, graph_id, stream); + REPORT_CALL_ERROR("E19999", "GraphManager RunGrapWithStreamhAsync failed," + "session id = %lu, graph id = %u, stream = %p.", session_id_, graph_id, stream); + return ret; + } + + GELOGI("Run graph with stream success, session id = %lu, graph id = %u, stream = %p.", + session_id_, graph_id, stream); + return SUCCESS; + } else { + GELOGE(GE_SESS_ALREADY_RUNNING, "[Run][GraphWithStreamAsync]failed because mutex try_lock false," + "session id = %lu, graph id = %u, stream = %p.", session_id_, graph_id, stream); + REPORT_INNER_ERROR("E19999", "[Run][GraphWithStreamAsync]failed failed because mutex try_lock false," + "session id = %lu, graph id = %u, stream = %p.", session_id_, graph_id, stream); + return GE_SESS_ALREADY_RUNNING; + } +} + Status InnerSession::RemoveGraph(uint32_t graph_id) { std::lock_guard lock(resource_mutex_); if (!init_flag_) { diff --git a/ge/session/inner_session.h b/ge/session/inner_session.h index afc273ac..b9e34142 100644 --- a/ge/session/inner_session.h +++ b/ge/session/inner_session.h @@ -45,6 +45,9 @@ class InnerSession { Status RunGraphWithStreamAsync(uint32_t graph_id, rtStream_t stream, const std::vector &inputs, std::vector &outputs); + Status RunGraphWithStreamAsync(uint32_t graph_id, rtStream_t stream, std::vector &&inputs, + std::vector &&outputs); + Status RemoveGraph(uint32_t graph_id); Status BuildGraph(uint32_t graph_id, const std::vector &inputs); From 8806f733a2989c23173c106acc6398e9a27c9ea9 Mon Sep 17 00:00:00 2001 From: medivh-x Date: Thu, 8 Jul 2021 17:43:40 +0800 Subject: [PATCH 3/5] add lookup table for fast search zero copy tasks --- ge/graph/load/model_manager/davinci_model.cc | 27 +++++++++++++++++++++++++++ ge/graph/load/model_manager/davinci_model.h | 8 ++++++++ ge/graph/load/model_manager/zero_copy_task.cc | 4 ++++ ge/graph/load/model_manager/zero_copy_task.h | 2 ++ 4 files changed, 41 insertions(+) diff --git a/ge/graph/load/model_manager/davinci_model.cc b/ge/graph/load/model_manager/davinci_model.cc index 495ec28e..14e824bd 100755 --- a/ge/graph/load/model_manager/davinci_model.cc +++ b/ge/graph/load/model_manager/davinci_model.cc @@ -3530,6 +3530,31 @@ Status DavinciModel::CopyModelData(const InputData &input_data, OutputData &outp return SUCCESS; } +void DavinciModel::BuildZeroCopyTasksLookupTable() { + std::lock_guard lk(lookup_table_build_lock_); + if (lookup_table_built_) { + return; + } + + const auto default_label_hash = std::hash{}(kDefaultBatchLable); + for (auto &task : zero_copy_tasks_) { + auto label_hash = std::hash{}(task.GetBatchLabel()); + auto addr2offsets = task.GetTaskArgsOffset(); + + label_hash2tasks_[label_hash].insert(&task); + if (label_hash == default_label_hash) { + for (auto &addr2offset : addr2offsets) { + addr2default_label_tasks_[addr2offset.first].insert(&task); + } + } else { + for (auto &addr2offset : addr2offsets) { + addr2specific_label_tasks_[addr2offset.first].insert(&task); + } + } + } + lookup_table_built_ = true; +} + /// /// @ingroup ge /// @brief Copy Data addr to model for direct use. @@ -3551,6 +3576,8 @@ Status DavinciModel::UpdateIoTaskArgs(const std::map & return ACL_ERROR_GE_PARAM_INVALID; } + BuildZeroCopyTasksLookupTable(); + for (const auto &data : data_info) { if (data.first >= blobs.size()) { // check data index. REPORT_INNER_ERROR("E19999", "is_input:%d, data index:%u from model >= blobs.size:%zu from user, mode_id:%u" diff --git a/ge/graph/load/model_manager/davinci_model.h b/ge/graph/load/model_manager/davinci_model.h index 76b0beef..dc9fba85 100755 --- a/ge/graph/load/model_manager/davinci_model.h +++ b/ge/graph/load/model_manager/davinci_model.h @@ -917,6 +917,7 @@ class DavinciModel { Status GetGearAndRealOutSizeInfo(const ComputeGraphPtr &graph, const NodePtr &node); Status GetRealOutputSizeOfCase(const ComputeGraphPtr &graph, size_t input_index, const NodePtr &case_node); Status GetGearAndRealOutShapeInfo(const ComputeGraphPtr &graph, const NodePtr &node); + void BuildZeroCopyTasksLookupTable(); bool is_weight_mem_has_inited_; bool is_feature_map_mem_has_inited_; @@ -1112,6 +1113,13 @@ class DavinciModel { // op name to attrs mapping std::map>> op_name_to_attrs_; + // fields for build fast search hash table for zero copy tasks + std::mutex lookup_table_build_lock_; + bool lookup_table_built_{false}; + std::unordered_map> label_hash2tasks_; + std::unordered_map> addr2specific_label_tasks_; + std::unordered_map> addr2default_label_tasks_; + std::map stream_2_event_; }; } // namespace ge diff --git a/ge/graph/load/model_manager/zero_copy_task.cc b/ge/graph/load/model_manager/zero_copy_task.cc index 85be6d7b..61a9713f 100755 --- a/ge/graph/load/model_manager/zero_copy_task.cc +++ b/ge/graph/load/model_manager/zero_copy_task.cc @@ -54,6 +54,10 @@ Status ZeroCopyTask::SetTaskArgsOffset(uintptr_t addr, size_t offset) { return SUCCESS; } +const std::map>& ZeroCopyTask::GetTaskArgsOffset() const { + return task_addr_offset_; +} + /** * @ingroup ge * @brief Save orignal data of task args. diff --git a/ge/graph/load/model_manager/zero_copy_task.h b/ge/graph/load/model_manager/zero_copy_task.h index efabc814..6420c91c 100644 --- a/ge/graph/load/model_manager/zero_copy_task.h +++ b/ge/graph/load/model_manager/zero_copy_task.h @@ -46,6 +46,8 @@ class ZeroCopyTask { */ ge::Status SetTaskArgsOffset(uintptr_t addr, size_t offset); + const std::map>& GetTaskArgsOffset() const; + /** * @ingroup ge * @brief Is need zero copy. From 9dc8e04f8dd7c0268535cd3399e57cfddcf87cb9 Mon Sep 17 00:00:00 2001 From: medivh-x Date: Thu, 8 Jul 2021 18:01:26 +0800 Subject: [PATCH 4/5] optimize ZeroCopyTask::UpdateTaskParam --- ge/graph/load/model_manager/davinci_model.cc | 29 +++++++++++----- ge/graph/load/model_manager/model_manager.cc | 4 +-- ge/graph/load/model_manager/zero_copy_task.cc | 15 ++++---- ge/session/inner_session.cc | 49 ++------------------------- ge/session/inner_session.h | 3 -- 5 files changed, 32 insertions(+), 68 deletions(-) diff --git a/ge/graph/load/model_manager/davinci_model.cc b/ge/graph/load/model_manager/davinci_model.cc index 14e824bd..ec814eaf 100755 --- a/ge/graph/load/model_manager/davinci_model.cc +++ b/ge/graph/load/model_manager/davinci_model.cc @@ -3619,21 +3619,34 @@ Status DavinciModel::UpdateIoTaskArgs(const std::map & continue; } + const static auto kDefaultLabelHash = std::hash{}(kDefaultBatchLable); + auto batch_label_hash = std::hash{}(batch_label); + std::unordered_set same_batch_label_tasks; + if (batch_label_hash != kDefaultLabelHash) { + auto iter = label_hash2tasks_.find(batch_label_hash); + if (iter != label_hash2tasks_.end()) { + same_batch_label_tasks = iter->second; + } + } + for (size_t count = 0; count < data.second.GetDataCount(); ++count) { - void *addr = data.second.GetDataInfo().at(count).second; + auto addr = reinterpret_cast(data.second.GetDataInfo().at(count).second); void *buffer_addr = reinterpret_cast(reinterpret_cast(buffer.data) + data.second.GetRelativeOffset().at(count)); - GELOGI("[ZCPY] Copy %s blobs_index %u, virtual_addr: %p, size: %ld, user_data_addr: %p, batch_label: %s", + GELOGI("[ZCPY] Copy %s blobs_index %u, virtual_addr: 0x%lx, size: %ld, user_data_addr: %p, batch_label: %s", is_input ? "input" : "output", data.first, addr, data.second.GetDataInfo().at(count).first, buffer_addr, batch_label.c_str()); // For input data, just copy for rts task. - for (auto &task : zero_copy_tasks_) { - bool not_same_batch = (task.GetBatchLabel() != kDefaultBatchLable && task.GetBatchLabel() != batch_label); - if (not_same_batch) { - continue; + for (auto &task : addr2default_label_tasks_[addr]) { // always update default label tasks + (void)task->UpdateTaskParam(addr, buffer_addr); + } + + if (batch_label_hash != kDefaultLabelHash) { + for (auto &task : addr2specific_label_tasks_[addr]) { + if (same_batch_label_tasks.count(task) > 0) { + (void)task->UpdateTaskParam(addr, buffer_addr); + } } - uintptr_t addr_val = reinterpret_cast(addr); - (void)task.UpdateTaskParam(addr_val, buffer_addr); } } } diff --git a/ge/graph/load/model_manager/model_manager.cc b/ge/graph/load/model_manager/model_manager.cc index fb4af267..3e45300a 100755 --- a/ge/graph/load/model_manager/model_manager.cc +++ b/ge/graph/load/model_manager/model_manager.cc @@ -1352,8 +1352,8 @@ void GetGeTensorDescs(const std::vector &tensors, std::vector &input_tensor, - std::vector &output_tensor) { +ge::Status ModelManager::ExecuteModel(uint32_t model_id, rtStream_t stream, bool async_mode, + const std::vector &input_tensor, std::vector &output_tensor) { InputData input_data; input_data.index = 0; input_data.model_id = model_id; diff --git a/ge/graph/load/model_manager/zero_copy_task.cc b/ge/graph/load/model_manager/zero_copy_task.cc index 61a9713f..2e4c212c 100755 --- a/ge/graph/load/model_manager/zero_copy_task.cc +++ b/ge/graph/load/model_manager/zero_copy_task.cc @@ -84,17 +84,16 @@ void ZeroCopyTask::SetOriginalArgs(const void *info, size_t size) { Status ZeroCopyTask::UpdateTaskParam(uintptr_t addr, void *buffer_addr) { auto iter = task_addr_offset_.find(addr); if (iter != task_addr_offset_.end()) { - auto &cur_pair = *iter; + auto dst_addr = reinterpret_cast(static_cast(buffer_addr)); uint8_t *args_info = args_info_.data(); - for (auto offset : cur_pair.second) { - auto dst_addr = static_cast(buffer_addr); - GELOGI("[ZCPY] %s update task, args_addr: %p, size: %zu, offset: %zu, virtual_addr: 0x%lx, user_data_addr: %p", - name_.c_str(), args_addr_, args_size_, offset, addr, buffer_addr); - *reinterpret_cast(args_info + offset)= reinterpret_cast(dst_addr); - is_updated_ = true; + for (auto offset : iter->second) { + auto ¤t_addr = *reinterpret_cast(args_info + offset); + if (current_addr != dst_addr) { + current_addr = dst_addr; + is_updated_ = true; + } } } - return SUCCESS; } diff --git a/ge/session/inner_session.cc b/ge/session/inner_session.cc index 9b7bef25..8a402c77 100755 --- a/ge/session/inner_session.cc +++ b/ge/session/inner_session.cc @@ -341,59 +341,14 @@ Status InnerSession::RunGraphWithStreamAsync(uint32_t graph_id, rtStream_t strea } UpdateThreadContext(graph_id); vector ge_inputs; - for (auto &item : inputs) { - ge_inputs.emplace_back(TensorAdapter::AsGeTensor(item)); - } - vector ge_outputs; - for (auto &item : outputs) { - ge_outputs.emplace_back(TensorAdapter::AsGeTensor(item)); - } - Status ret = graph_manager_.RunGraphWithStreamAsync(graph_id, stream, session_id_, ge_inputs, ge_outputs); - domi::GetContext().out_nodes_map.clear(); - domi::GetContext().user_out_nodes.clear(); - if (ret != SUCCESS) { - GELOGE(ret, "[Run][GraphWithStreamAsync]failed," - "session id = %lu, graph id = %u, stream = %p.", session_id_, graph_id, stream); - REPORT_CALL_ERROR("E19999", "GraphManager RunGrapWithStreamhAsync failed," - "session id = %lu, graph id = %u, stream = %p.", session_id_, graph_id, stream); - return ret; - } - - GELOGI("Run graph with stream success, session id = %lu, graph id = %u, stream = %p.", - session_id_, graph_id, stream); - return SUCCESS; - } else { - GELOGE(GE_SESS_ALREADY_RUNNING, "[Run][GraphWithStreamAsync]failed because mutex try_lock false," - "session id = %lu, graph id = %u, stream = %p.", session_id_, graph_id, stream); - REPORT_INNER_ERROR("E19999", "[Run][GraphWithStreamAsync]failed failed because mutex try_lock false," - "session id = %lu, graph id = %u, stream = %p.", session_id_, graph_id, stream); - return GE_SESS_ALREADY_RUNNING; - } -} - -Status InnerSession::RunGraphWithStreamAsync(uint32_t graph_id, rtStream_t stream, - std::vector &&inputs, std::vector &&outputs) { - GELOGI("Run graph with stream, session id = %lu, graph id = %u, stream = %p in move mode", - session_id_, graph_id, stream); - if (mutex_.try_lock()) { - std::lock_guard lock(mutex_, std::adopt_lock); - if (!init_flag_) { - GELOGE(GE_SESS_INIT_FAILED, "[Run][GraphWithStream]failed because GraphManager not Init," - "session id = %lu, graph id = %u, stream = %p.", session_id_, graph_id, stream); - REPORT_INNER_ERROR("E19999", "RunGraphWithStreamAsync failed because GraphManager not Init," - "session id = %lu, graph id = %u, stream = %p.", session_id_, graph_id, stream); - return GE_SESS_INIT_FAILED; - } - UpdateThreadContext(graph_id); - vector ge_inputs; ge_inputs.reserve(inputs.size()); for (auto &item : inputs) { - ge_inputs.emplace_back(TensorAdapter::AsGeTensor(std::move(item))); + ge_inputs.emplace_back(TensorAdapter::AsGeTensorShared(item)); } vector ge_outputs; ge_outputs.reserve(outputs.size()); for (auto &item : outputs) { - ge_outputs.emplace_back(TensorAdapter::AsGeTensor(std::move(item))); + ge_outputs.emplace_back(TensorAdapter::AsGeTensorShared(item)); } Status ret = graph_manager_.RunGraphWithStreamAsync(graph_id, stream, session_id_, ge_inputs, ge_outputs); domi::GetContext().out_nodes_map.clear(); diff --git a/ge/session/inner_session.h b/ge/session/inner_session.h index b9e34142..afc273ac 100644 --- a/ge/session/inner_session.h +++ b/ge/session/inner_session.h @@ -45,9 +45,6 @@ class InnerSession { Status RunGraphWithStreamAsync(uint32_t graph_id, rtStream_t stream, const std::vector &inputs, std::vector &outputs); - Status RunGraphWithStreamAsync(uint32_t graph_id, rtStream_t stream, std::vector &&inputs, - std::vector &&outputs); - Status RemoveGraph(uint32_t graph_id); Status BuildGraph(uint32_t graph_id, const std::vector &inputs); From b80dba916d6d49d825e241a4bf0e948605bd6027 Mon Sep 17 00:00:00 2001 From: medivh-x Date: Wed, 14 Jul 2021 18:07:42 +0800 Subject: [PATCH 5/5] update submodule metadef --- ge/graph/execute/graph_execute.cc | 19 +------------------ 1 file changed, 1 insertion(+), 18 deletions(-) diff --git a/ge/graph/execute/graph_execute.cc b/ge/graph/execute/graph_execute.cc index 3beb8f0e..c97a4fbc 100755 --- a/ge/graph/execute/graph_execute.cc +++ b/ge/graph/execute/graph_execute.cc @@ -434,27 +434,10 @@ Status GraphExecutor::ExecuteGraphWithStream(GraphId graph_id, GE_CHECK_NOTNULL_EXEC(ge_root_model, return FAILED); auto model_id = ge_root_model->GetModelId(); - InputData input_data; - input_data.index = 0; - input_data.model_id = model_id; - std::vector input_desc; - auto ret = GetExecuteData(input_tensor, input_data.blobs, input_desc); - if (ret != SUCCESS) { - return ret; - } - OutputData output_data; - output_data.index = 0; - output_data.model_id = model_id; - std::vector output_desc; - ret = GetExecuteData(output_tensor, output_data.blobs, output_desc); - if (ret != SUCCESS) { - return ret; - } - auto async_mode = true; auto model_manager = ge::ModelManager::GetInstance(); GE_CHECK_NOTNULL(model_manager); - ret = model_manager->ExecuteModel(model_id, stream, async_mode, input_tensor, output_tensor); + auto ret = model_manager->ExecuteModel(model_id, stream, async_mode, input_tensor, output_tensor); if (ret != SUCCESS) { return ret; }