From 56a3ac21aa60d58cea0ecbf440ceff4a15233a16 Mon Sep 17 00:00:00 2001 From: lianghao Date: Tue, 11 May 2021 14:40:24 +0800 Subject: [PATCH] atomic and davinci_model --- ge/graph/load/model_manager/model_manager.cc | 42 +++++++++++--------- ge/graph/passes/atomic_addr_clean_pass.cc | 20 +++++++--- ge/graph/passes/atomic_addr_clean_pass.h | 6 ++- ge/ir_build/option_utils.cc | 3 +- 4 files changed, 44 insertions(+), 27 deletions(-) diff --git a/ge/graph/load/model_manager/model_manager.cc b/ge/graph/load/model_manager/model_manager.cc index b731aefe..73a427df 100755 --- a/ge/graph/load/model_manager/model_manager.cc +++ b/ge/graph/load/model_manager/model_manager.cc @@ -398,26 +398,32 @@ void ModelManager::InsertModel(uint32_t model_id, shared_ptr lock(map_mutex_); + // These two pointers are used to unbind erase() and model destruction process. + std::shared_ptr tmp_model; + std::shared_ptr tmp_hybrid_model; + { + std::lock_guard lock(map_mutex_); - auto it = model_map_.find(id); - auto hybrid_model_it = hybrid_model_map_.find(id); - if (it != model_map_.end()) { - uint64_t session_id = it->second->GetSessionId(); - std::string model_key = std::to_string(session_id) + "_" + std::to_string(id) + "_" + - std::to_string(it->second->SubModelId()); - auto iter_aicpu_kernel = model_aicpu_kernel_.find(model_key); - if (iter_aicpu_kernel != model_aicpu_kernel_.end()) { - (void)model_aicpu_kernel_.erase(iter_aicpu_kernel); + auto it = model_map_.find(id); + auto hybrid_model_it = hybrid_model_map_.find(id); + if (it != model_map_.end()) { + uint64_t session_id = it->second->GetSessionId(); + std::string model_key = std::to_string(session_id) + "_" + std::to_string(id) + "_" + + std::to_string(it->second->SubModelId()); + auto iter_aicpu_kernel = model_aicpu_kernel_.find(model_key); + if (iter_aicpu_kernel != model_aicpu_kernel_.end()) { + (void)model_aicpu_kernel_.erase(iter_aicpu_kernel); + } + tmp_model = it->second; + (void)model_map_.erase(it); + } else if (hybrid_model_it != hybrid_model_map_.end()) { + tmp_hybrid_model = hybrid_model_it->second; + (void)hybrid_model_map_.erase(hybrid_model_it); + } else { + REPORT_INNER_ERROR("E19999", "model_id:%u not exist in model_map, check invalid", id); + GELOGE(ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, "model id %u does not exists.", id); + return ACL_ERROR_GE_EXEC_MODEL_ID_INVALID; } - (void)model_map_.erase(it); - } else if (hybrid_model_it != hybrid_model_map_.end()) { - (void)hybrid_model_map_.erase(hybrid_model_it); - } else { - REPORT_INNER_ERROR("E19999", "model_id:%u not exist in model_map, check invalid", - id); - GELOGE(ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, "model id %u does not exists.", id); - return ACL_ERROR_GE_EXEC_MODEL_ID_INVALID; } return SUCCESS; diff --git a/ge/graph/passes/atomic_addr_clean_pass.cc b/ge/graph/passes/atomic_addr_clean_pass.cc index 24b84fa0..1bc6e9c9 100755 --- a/ge/graph/passes/atomic_addr_clean_pass.cc +++ b/ge/graph/passes/atomic_addr_clean_pass.cc @@ -182,10 +182,11 @@ Status AtomicAddrCleanPass::HandleLoopGraph(ComputeGraphPtr &graph, const vector } Status AtomicAddrCleanPass::HandleNormalGraph(ComputeGraphPtr &graph, const vector &atomic_node_vec) { - GELOGD("Not loop graph and unknown graph. It will insert only 1 clean node."); + GELOGD("Not loop graph and unknown graph. It will insert atomic clean nodes."); vector common_atomic_nodes; - auto ret = HandleDispersedAtomicNodes(graph, atomic_node_vec, common_atomic_nodes); + vector dispersed_atomic_nodes; + auto ret = HandleDispersedAtomicNodes(graph, atomic_node_vec, common_atomic_nodes, dispersed_atomic_nodes); if (ret != SUCCESS) { GELOGE(ret, "Handle dispersed atomic nodes failed, graph name is %s.", graph->GetName().c_str()); return ret; @@ -222,7 +223,7 @@ Status AtomicAddrCleanPass::HandleNormalGraph(ComputeGraphPtr &graph, const vect } } } - return LinkToPotentialPrecedenceNode(graph, clean_addr_node); + return LinkToPotentialPrecedenceNode(graph, clean_addr_node, dispersed_atomic_nodes); } // Add control edges from atomic clean node to all potential precedence nodes which may execute before atomic clean @@ -231,7 +232,8 @@ Status AtomicAddrCleanPass::HandleNormalGraph(ComputeGraphPtr &graph, const vect // edges from atomic clean node to the nodes that may be the first node on each stream. Generally, the first nodes on // each stream are successors of Data/Variable, and Data/Variable won't generate task or execute, so we link to the // successors of Data/Variable. -Status AtomicAddrCleanPass::LinkToPotentialPrecedenceNode(ComputeGraphPtr &graph, NodePtr &atomic_clean_node) { +Status AtomicAddrCleanPass::LinkToPotentialPrecedenceNode(ComputeGraphPtr &graph, NodePtr &atomic_clean_node, + const vector &dispersed_atomic_nodes) { GELOGD("Start to add control edges from %s to all second-nodes behind first-nodes which have no input.", atomic_clean_node->GetName().c_str()); auto out_ctrl_anchor = atomic_clean_node->GetOutControlAnchor(); @@ -246,6 +248,10 @@ Status AtomicAddrCleanPass::LinkToPotentialPrecedenceNode(ComputeGraphPtr &graph auto second_nodes = node->GetOutAllNodes(); for (const auto &second_node : second_nodes) { GE_CHECK_NOTNULL(second_node); + if ((std::find(dispersed_atomic_nodes.begin(), dispersed_atomic_nodes.end(), second_node) != + dispersed_atomic_nodes.end()) || (second_node->GetType() == NETOUTPUT)) { + continue; + } auto in_ctrl_anchor = second_node->GetInControlAnchor(); GE_CHECK_NOTNULL(in_ctrl_anchor); if (!out_ctrl_anchor->IsLinkedWith(in_ctrl_anchor)) { @@ -260,7 +266,8 @@ Status AtomicAddrCleanPass::LinkToPotentialPrecedenceNode(ComputeGraphPtr &graph Status AtomicAddrCleanPass::HandleDispersedAtomicNodes(ComputeGraphPtr &graph, const std::vector &atomic_node_vec, - std::vector &common_atomic_nodes) { + std::vector &common_atomic_nodes, + vector &dispersed_atomic_nodes) { int index = 0; for (const auto &node : atomic_node_vec) { vector node_anchors_connect_netoutput; @@ -280,7 +287,7 @@ Status AtomicAddrCleanPass::HandleDispersedAtomicNodes(ComputeGraphPtr &graph, oss << node_name << "_" << index; node_name = oss.str(); dispersed_node_op_desc->SetName(node_name); - GELOGD("Inserted dispersed atomic clean node name is %s", node_name.c_str()); + GELOGD("Inserted dispersed atomic clean node [%s] before [%s]", node_name.c_str(), node->GetName().c_str()); ++index; Status ret = LinkToAtomicNode(node, dispersed_clean_addr_node); if (ret != SUCCESS) { @@ -288,6 +295,7 @@ Status AtomicAddrCleanPass::HandleDispersedAtomicNodes(ComputeGraphPtr &graph, node->GetName().c_str(), dispersed_clean_addr_node->GetName().c_str()); return ret; } + dispersed_atomic_nodes.emplace_back(node); } else { common_atomic_nodes.emplace_back(node); } diff --git a/ge/graph/passes/atomic_addr_clean_pass.h b/ge/graph/passes/atomic_addr_clean_pass.h index 96147fa2..0d0b8fff 100755 --- a/ge/graph/passes/atomic_addr_clean_pass.h +++ b/ge/graph/passes/atomic_addr_clean_pass.h @@ -73,7 +73,8 @@ class AtomicAddrCleanPass : public GraphPass { * @param atomic_clean_node * @return */ - Status LinkToPotentialPrecedenceNode(ComputeGraphPtr &graph, NodePtr &atomic_clean_node); + Status LinkToPotentialPrecedenceNode(ComputeGraphPtr &graph, NodePtr &atomic_clean_node, + const std::vector &dispersed_atomic_nodes); /** * Check if this node is atomic op. @@ -90,7 +91,8 @@ class AtomicAddrCleanPass : public GraphPass { Status CompileUnknownGraphOp(const vector &atomic_node_vec); Status HandleDispersedAtomicNodes(ComputeGraphPtr &graph, const std::vector &atomic_node_vec, - std::vector &common_atomic_nodes); + std::vector &common_atomic_nodes, + std::vector &dispersed_atomic_nodes); bool CheckAtomicFromOpsKernel(const NodePtr &node); diff --git a/ge/ir_build/option_utils.cc b/ge/ir_build/option_utils.cc index 1be996b2..2ad1577b 100755 --- a/ge/ir_build/option_utils.cc +++ b/ge/ir_build/option_utils.cc @@ -239,7 +239,8 @@ bool CheckDynamicImagesizeInputShapeValid(map> shape_map bool is_char_valid = isdigit(c) || (c == ',') || (c == ' ') || (c == ';'); if (!is_char_valid) { ErrorManager::GetInstance().ATCReportErrMessage( - "E10033", {"value", "reason"}, {dynamic_image_size, kDynamicImageSizeError}); + "E10001", {"parameter", "value", "reason"}, + {"dynamic_image_size", dynamic_image_size.c_str(), kDynamicImageSizeError}); GELOGE(ge::PARAM_INVALID, "[Check][DynamicImageSizeInputShape] --dynamic_image_size:%s is invalid. reason: %s", dynamic_image_size.c_str(), kDynamicImageSizeError); return false;