/** * Copyright 2019-2020 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "graph/partition/graph_partition.h" #include #include #include #include #include #include "analyzer/analyzer.h" #include "common/ge/ge_util.h" #include "common/op/ge_op_utils.h" #include "framework/common/types.h" #include "graph/debug/ge_attr_define.h" #include "graph/manager/graph_manager_utils.h" #include "graph/common/ge_call_wrapper.h" #include "graph/utils/graph_utils.h" #include "graph/utils/op_desc_utils.h" #include "graph/utils/type_utils.h" #include "init/gelib.h" #include "opskernel_manager/ops_kernel_manager.h" namespace { const char *const kEngineDefaultData = "ENGINE_DEFAULT_DATA"; const char *const kEndType = "End"; const char *const kPlaceHolderType = "PlaceHolder"; const int kOneGraph = 1; // only one graph const int kRankOne = 1; // order of graph list is 0,1,2,3..., 1 means second order const int kRankZero = 0; // order of graph list is 0,1,2,3..., 0 means first order } // namespace namespace ge { Status ge::GraphPartitioner::CheckIfEnd2PldEmpty(ge::ComputeGraphPtr &output_merged_compute_graph) { // only one condition:no data node, one engine, there is only one graph + input graph if (graph_info_.partitions_.size() == kOneGraph) { auto partition = (*graph_info_.partitions_.begin()); if (partition.first == nullptr) { GELOGE(GE_GRAPH_EMPTY_PARTITION, "[GraphPartitioner]: partition.first is null, engine name is %s", partition.second.c_str()); return FAILED; } output_merged_compute_graph = partition.first; } else { // if placeholder to end map is empty, it should be an exception condition GELOGE(GE_GRAPH_EMPTY_PARTITION, "[GraphPartitioner]: placeholder to end map is empty, partitions size is not 1."); return FAILED; } return SUCCESS; } Status ge::GraphPartitioner::MergeAllSubGraph(ge::ComputeGraphPtr &output_merged_compute_graph, const std::vector &sub_graph_list) { for (size_t rank = 0; rank < graph_info_.rank_2_partitions_.size(); rank++) { string temp_stream; // sub_graph_list index is one ahead of rank_2_partitions_list index if (rank > 0) { temp_stream = sub_graph_list[rank - 1]->GetStreamLabel(); } for (const auto &node : graph_info_.rank_2_partitions_[rank]->GetDirectNode()) { if (node == nullptr) { continue; } if ((node->GetType() == kEndType) || (node->GetType() == kPlaceHolderType)) { continue; } if (!temp_stream.empty() && !AttrUtils::HasAttr(node->GetOpDesc(), ATTR_NAME_STREAM_LABEL)) { (void)AttrUtils::SetStr(node->GetOpDesc(), ATTR_NAME_STREAM_LABEL, temp_stream); } if (node->SetOwnerComputeGraph(output_merged_compute_graph) != GRAPH_SUCCESS) { GELOGE(GE_GRAPH_PARAM_NULLPTR, "SetownerComputeGraph failed, node %s", node->GetName().c_str()); return FAILED; } (void)output_merged_compute_graph->AddNode(node); } } // get session graph id from subgraph SetMergedGraphId(output_merged_compute_graph); return SUCCESS; } void ge::GraphPartitioner::SetMergedGraphId(ge::ComputeGraphPtr &output_merged_compute_graph) { string session_graph_id; // get session graph id from subgraph if (graph_info_.rank_2_partitions_.empty() || !AttrUtils::GetStr(*(graph_info_.rank_2_partitions_[0]), ATTR_NAME_SESSION_GRAPH_ID, session_graph_id)) { GELOGW("Get graph session_graph_id attr failed."); } // set session graph id into merged subgraph if (!session_graph_id.empty()) { GELOGI("Set session graph id %s in merged compute graph", session_graph_id.c_str()); // private function, promise output_merged_compute_graph not null GE_IF_BOOL_EXEC(!AttrUtils::SetStr(*output_merged_compute_graph, ATTR_NAME_SESSION_GRAPH_ID, session_graph_id), GELOGW("SetStr ATTR_NAME_SESSION_GRAPH_ID failed");) } } Status ge::GraphPartitioner::RemoveNodeAndEdgeBetweenEndPld(ge::ComputeGraphPtr &output_merged_compute_graph, const std::vector &sub_graph_list) { if ((output_merged_compute_graph == nullptr) || (MergeAllSubGraph(output_merged_compute_graph, sub_graph_list) != SUCCESS)) { GELOGE(GE_GRAPH_PARAM_NULLPTR, "[GraphPartitioner]: MergeAllSubGraph failed."); return FAILED; } for (const auto &it : graph_info_.index_2_end_) { auto &end = it.second; auto &pld = graph_info_.end_2_pld_[it.second]; if ((end != nullptr) && (pld != nullptr) && (end->GetInDataAnchor(0) != nullptr) && (pld->GetOutDataAnchor(0) != nullptr)) { AnchorPtr end_in_anchor = (end->GetInDataAnchor(0)->GetFirstPeerAnchor() == nullptr) ? Anchor::DynamicAnchorCast(end->GetInControlAnchor()) : Anchor::DynamicAnchorCast(end->GetInDataAnchor(0)); AnchorPtr pld_out_anchor = (pld->GetOutDataAnchor(0)->GetFirstPeerAnchor() == nullptr) ? Anchor::DynamicAnchorCast(pld->GetOutControlAnchor()) : Anchor::DynamicAnchorCast(pld->GetOutDataAnchor(0)); auto src_anchor = end_in_anchor->GetFirstPeerAnchor(); // src_anchor should be only 1 if (GraphUtils::RemoveEdge(src_anchor, end_in_anchor) != GRAPH_SUCCESS) { GELOGE(GE_GRAPH_PARAM_NULLPTR, "[GraphPartitioner]: RemoveEdge failed. node_name:%s, graph_name:%s", end->GetName().c_str(), end->GetOwnerComputeGraph()->GetName().c_str()); return FAILED; } GE_CHECK_NOTNULL(pld_out_anchor); for (const auto &peer_in_anchor : pld_out_anchor->GetPeerAnchors()) { if (GraphUtils::RemoveEdge(pld_out_anchor, peer_in_anchor) != GRAPH_SUCCESS) { GELOGE(GE_GRAPH_PARAM_NULLPTR, "[GraphPartitioner]: RemoveEdge failed. node_name:%s, graph_name:%s", pld->GetName().c_str(), pld->GetOwnerComputeGraph()->GetName().c_str()); return FAILED; } if (GraphUtils::AddEdge(src_anchor, peer_in_anchor) != GRAPH_SUCCESS) { GELOGE(GE_GRAPH_PARAM_NULLPTR, "merge two subgraph fail."); return FAILED; } } } else { GELOGW("End or pld is nullptr or in data anchor of end is nullptr or out data anchor of pld is nullptr"); } } return SUCCESS; } Status ge::GraphPartitioner::MergeAfterSubGraphOptimization(ge::ComputeGraphPtr &output_merged_compute_graph, const ge::ComputeGraphPtr &original_compute_graph) { Status real_ret = SUCCESS; auto ret = MergeSubGraph(output_merged_compute_graph, original_compute_graph); if (ret != SUCCESS) { // even though failed, ensure all op do finish check support real_ret = FAILED; GELOGE(ret, "Graph merging Failed"); } GE_CHECK_NOTNULL(original_compute_graph); // partition sub graph for (const auto &sub_graph : original_compute_graph->GetAllSubgraphs()) { ComputeGraphPtr merged_sub_graph = nullptr; ret = MergeSubGraph(merged_sub_graph, sub_graph); if (ret != SUCCESS) { real_ret = FAILED; GELOGE(ret, "Sub graph merging Failed"); continue; } // add sub graph output_merged_compute_graph->SetName(original_compute_graph->GetName()); merged_sub_graph->SetName(sub_graph->GetName()); merged_sub_graph->SetInputSize(sub_graph->GetInputSize()); merged_sub_graph->SetOutputSize(sub_graph->GetOutputSize()); auto parent_node = sub_graph->GetParentNode(); GE_IF_BOOL_EXEC(parent_node == nullptr, GELOGE(FAILED, "Parent node is null, graph name is %s", sub_graph->GetName().c_str()); return FAILED;) auto original_graph = parent_node->GetOwnerComputeGraph(); GE_IF_BOOL_EXEC(graph_2_graph_partition_info_.find(original_graph) == graph_2_graph_partition_info_.end(), GELOGE(FAILED, "Find graph info failed, graph name is %s", original_graph->GetName().c_str()); return FAILED;) auto graph_info = graph_2_graph_partition_info_[original_graph]; GE_IF_BOOL_EXEC(graph_info.corresponding_node_in_partitions_.count(parent_node) == 0, GELOGE(FAILED, "Find corresponding node failed, parent node name is %s", parent_node->GetName().c_str()); return FAILED;) auto corresponding_node = graph_info.corresponding_node_in_partitions_[parent_node]; GE_IF_BOOL_EXEC(corresponding_node == nullptr, GELOGE(FAILED, "Get null node, node name is %s", parent_node->GetName().c_str()); return FAILED;); merged_sub_graph->SetParentNode(corresponding_node); auto subgraph_parent_graph = corresponding_node->GetOwnerComputeGraph(); merged_sub_graph->SetParentGraph(subgraph_parent_graph); ret = output_merged_compute_graph->AddSubgraph(sub_graph->GetName(), merged_sub_graph); GE_IF_BOOL_EXEC(ret != GRAPH_SUCCESS, return ret;) } ClearAllPartitionData(); if (real_ret != SUCCESS) { auto root_graph = ge::GraphUtils::FindRootGraph(original_compute_graph); GE_CHECK_NOTNULL(root_graph); (void)Analyzer::GetInstance()->SaveAnalyzerDataToFile(root_graph->GetSessionID(), root_graph->GetGraphID()); } return real_ret; } Status ge::GraphPartitioner::MergeSubGraph(ge::ComputeGraphPtr &output_merged_compute_graph, const ge::ComputeGraphPtr &original_compute_graph) { if (original_compute_graph == nullptr) { GELOGE(GE_GRAPH_NULL_INPUT, "[GraphPartitioner]: compute_graph is null."); return FAILED; } if ((graph_2_graph_partition_info_.find(original_compute_graph) == graph_2_graph_partition_info_.end()) || (graph_2_subgraph_list_.find(original_compute_graph) == graph_2_subgraph_list_.end())) { GELOGE(GE_GRAPH_NULL_INPUT, "[GraphPartitioner]: compute_graph is error."); return FAILED; } GraphPartitionInfo &subgraph_info = graph_2_graph_partition_info_[original_compute_graph]; const auto &sub_graph_list = graph_2_subgraph_list_[original_compute_graph]; graph_info_ = subgraph_info; if (graph_info_.mode_ != kMerging) { GELOGE(GE_GRAPH_UNSUPPORTED, "Cannot call merging in partition mode"); return FAILED; } GELOGD("Graph merge starts."); // check input param for (const auto &it : sub_graph_list) { if (it == nullptr) { GELOGE(GE_GRAPH_PARAM_NULLPTR, "[GraphPartitioner]: merging sub-graphs failed, sub-graph is null"); return FAILED; } } bool is_map_empty = graph_info_.end_2_pld_.empty() || graph_info_.pld_2_end_.empty(); if (is_map_empty) { if (CheckIfEnd2PldEmpty(output_merged_compute_graph) != SUCCESS) { return FAILED; } } ComputeGraphPtr new_sub_graph = MakeShared(original_compute_graph->GetName()); GE_CHECK_NOTNULL(new_sub_graph); output_merged_compute_graph = new_sub_graph; GE_TIMESTAMP_START(MergeSubGraphRemoveNode); if (RemoveNodeAndEdgeBetweenEndPld(output_merged_compute_graph, sub_graph_list) != ge::SUCCESS) { GELOGE(GE_GRAPH_PARAM_NULLPTR, "[GraphPartitioner]: merging sub-graphs failed"); return FAILED; } GE_TIMESTAMP_END(MergeSubGraphRemoveNode, "GraphPartitioner::MergeGraphRemoveNodeAndEdge"); GE_TIMESTAMP_START(MergeSubGraphTopologicalSorting); Status ret = output_merged_compute_graph->TopologicalSorting(); if (ret != SUCCESS) { GELOGE(GE_GRAPH_TOPO_SORT_FAILED, "[GraphPartitioner]: output_merged_compute_graph->TopologicalSorting failed"); return FAILED; } GE_TIMESTAMP_END(MergeSubGraphTopologicalSorting, "GraphPartitioner::MergeGraphTopologicalSorting"); // flush all nodes' engine of merged graph GE_TIMESTAMP_START(MergeSubGraphEnginePlacerRun); graph_info_.engine_placer_.SetComputeGraph(output_merged_compute_graph); if (graph_info_.engine_placer_.Run() != SUCCESS) { GELOGE(GE_GRAPH_INIT_FAILED, "[GraphPartitioner]: engine_placer run failed"); return FAILED; } GE_TIMESTAMP_END(MergeSubGraphEnginePlacerRun, "GraphPartitioner::MergeGraphEnginePlacerRun"); GELOGD("Graph merge ends."); return SUCCESS; } Status ge::GraphPartitioner::UpdatePldOpDesc(const NodePtr &dst_node, int input_index, OpDescPtr &pld_op_desc) { if ((dst_node == nullptr) || (pld_op_desc == nullptr) || (dst_node->GetOpDesc() == nullptr)) { GELOGE(FAILED, "parameter ptr is null."); return FAILED; } const auto &input_desc = dst_node->GetOpDesc()->GetInputDesc(static_cast(input_index)); GE_IF_BOOL_EXEC(pld_op_desc->AddOutputDesc(input_desc) != GRAPH_SUCCESS, GELOGE(FAILED, "AddOutputDesc failed"); return FAILED;) if (pld_op_desc->MutableOutputDesc(0) != nullptr) { ge::TensorUtils::SetRealDimCnt(*(pld_op_desc->MutableOutputDesc(0).get()), static_cast(input_desc.GetShape().GetDims().size())); } else { GELOGE(GE_GRAPH_ADD_PLC_END_FAILED, "[GraphPartitioner]: pld_op_desc is null."); return FAILED; } return SUCCESS; } Status ge::GraphPartitioner::UpdateEndOpDesc(const NodePtr &src_node, int output_index, OpDescPtr &end_op_desc) { if ((src_node == nullptr) || (end_op_desc == nullptr) || (src_node->GetOpDesc() == nullptr)) { GELOGE(FAILED, "parameter ptr is null."); return FAILED; } const auto &output_desc = src_node->GetOpDesc()->GetOutputDesc(static_cast(output_index)); GE_IF_BOOL_EXEC(end_op_desc->AddInputDesc(output_desc) != GRAPH_SUCCESS, GELOGE(FAILED, "AddInputDesc failed"); return FAILED;) if (end_op_desc->MutableInputDesc(0) != nullptr) { ge::TensorUtils::SetRealDimCnt(*(end_op_desc->MutableInputDesc(0).get()), static_cast(output_desc.GetShape().GetDims().size())); } else { GELOGE(GE_GRAPH_ADD_PLC_END_FAILED, "[GraphPartitioner]: pld_op_desc is null."); return FAILED; } return SUCCESS; } graphStatus ge::GraphPartitioner::AddPlaceHolderEndInSrcDstGraph(const AnchorPtr &out_anchor, const AnchorPtr &peer_in_anchor, const ge::ComputeGraphPtr &pld_graph, const ge::ComputeGraphPtr &end_graph) { GE_CHECK_NOTNULL(peer_in_anchor); GE_CHECK_NOTNULL(pld_graph); GE_CHECK_NOTNULL(out_anchor); GE_CHECK_NOTNULL(end_graph); const auto &src_node = out_anchor->GetOwnerNode(); const auto &dst_node = peer_in_anchor->GetOwnerNode(); // link input -> end string end_name = kEndType + std::to_string(graph_info_.num_of_pld_end_); auto end_op_desc = MakeShared(end_graph->GetName() + "_" + end_name, END); if (end_op_desc == nullptr) { GELOGE(GRAPH_PARAM_INVALID, "pld_op_desc is nullptr."); return FAILED; } GE_IF_BOOL_EXEC(!AttrUtils::SetInt(end_op_desc, "peerIndex", graph_info_.num_of_pld_end_), GELOGW("SetInt peerIndex failed");) GE_IF_BOOL_EXEC(!AttrUtils::SetStr(end_op_desc, "parentOpType", dst_node->GetType()), GELOGW("SetStr parentOpType failed");) GE_IF_BOOL_EXEC(!end_op_desc->SetExtAttr("parentNode", dst_node), GELOGW("SetEndExtAttr parentNode failed");) OpDescPtr dst_node_op_desc = dst_node->GetOpDesc(); GE_CHECK_NOTNULL(dst_node_op_desc); GE_IF_BOOL_EXEC(!AttrUtils::SetStr(end_op_desc, ATTR_NAME_END_REAR_NODE_ENGINE_NAME, dst_node_op_desc->GetOpEngineName()), GELOGW("SetStr rearNodeEngineName failed");) // replace input_desc of end with owner node's desc int output_index = ge::AnchorUtils::GetIdx(out_anchor); bool is_need_update_desc = (output_index >= 0) && (graph_info_.mode_ == kPartitioning); if (is_need_update_desc) { if (UpdateEndOpDesc(src_node, output_index, end_op_desc) != SUCCESS) { GELOGE(GRAPH_PARAM_INVALID, "UpdateEndOpDesc failed, input index %d", output_index); return FAILED; } } else { GeTensorDesc input_desc; if (end_op_desc->AddInputDesc(input_desc) != SUCCESS) { GELOGE(GRAPH_PARAM_INVALID, "AddInputDesc failed, input index %d", output_index); return FAILED; } } NodePtr new_end_node = end_graph->AddNode(end_op_desc); if (new_end_node == nullptr) { GELOGE(GRAPH_PARAM_INVALID, "new_end_node is nullptr."); return FAILED; } GE_IF_BOOL_EXEC(new_end_node->SetOwnerComputeGraph(end_graph) != GRAPH_SUCCESS, GELOGE(GRAPH_PARAM_INVALID, "SetOwnerComputeGraph failed"); return FAILED;) AnchorPtr end_dst_anchor = GetEndInAnchor(out_anchor, new_end_node); if (GraphUtils::AddEdge(out_anchor, end_dst_anchor) != GRAPH_SUCCESS) { GELOGE(GE_GRAPH_ADD_PLC_END_FAILED, "add end node : %s node %dth out-anchor --> end in %s subgraph fail.", src_node->GetName().c_str(), AnchorUtils::GetIdx(out_anchor), end_graph->GetName().c_str()); return FAILED; } /// For fe, op id has been set in AddNode, /// we can take op id of srcNode as the mark of parentId now const auto &src_node_opdesc = src_node->GetOpDesc(); GE_CHECK_NOTNULL(src_node_opdesc); int64_t node_id = src_node_opdesc->GetId(); const string pld_name = kPlaceHolderType + std::to_string(graph_info_.num_of_pld_end_); auto pld_op_desc = MakeShared(pld_graph->GetName() + "_" + pld_name, PLACEHOLDER); if (pld_op_desc == nullptr) { GELOGE(GRAPH_PARAM_INVALID, "pld_op_desc is nullptr."); return FAILED; } GE_IF_BOOL_EXEC(!AttrUtils::SetInt(pld_op_desc, "peerIndex", graph_info_.num_of_pld_end_), GELOGW("SetInt peerIndex failed");) GE_IF_BOOL_EXEC(!AttrUtils::SetStr(pld_op_desc, "_peerNodeName", new_end_node->GetName()), GELOGW("SetStr _peerNodeName failed");) GE_IF_BOOL_EXEC(!AttrUtils::SetStr(pld_op_desc, "parentOpType", src_node->GetType()), GELOGW("SetStr parentOpType failed");) GE_IF_BOOL_EXEC(!AttrUtils::SetStr(pld_op_desc, "_parentNodeName", src_node->GetName()), GELOGW("SetStr parentOpName failed");) GE_IF_BOOL_EXEC(!AttrUtils::SetStr(pld_op_desc, "parentId", end_graph->GetName() + ":" + std::to_string(node_id)), GELOGW("SetStr parentId failed");) GE_IF_BOOL_EXEC(!AttrUtils::SetInt(pld_op_desc, "anchorIndex", AnchorUtils::GetIdx(out_anchor)), GELOGW("SetInt anchorIndex failed");) GE_IF_BOOL_EXEC(!pld_op_desc->SetExtAttr("parentNode", src_node), GELOGW("SetPldExtAttr parentNode failed");) GE_IF_BOOL_EXEC(!AttrUtils::SetStr(pld_op_desc, ATTR_NAME_PLD_FRONT_NODE_ENGINE_NAME, src_node_opdesc->GetOpEngineName()), GELOGW("SetStr frontNodeEngineName failed");) std::string l2_info_attr; if (AttrUtils::GetStr(src_node_opdesc, "_task_L2FusionInfo", l2_info_attr)) { GE_IF_BOOL_EXEC(!AttrUtils::SetStr(pld_op_desc, "_task_L2FusionInfo", l2_info_attr), GELOGW("SetStr l2_info_attr failed");) } int64_t anchor_index_for_lxfusion; if (AttrUtils::GetInt(src_node_opdesc, "_data_anchor_index_for_lxfusion", anchor_index_for_lxfusion)) { GE_IF_BOOL_EXEC(!AttrUtils::SetInt(pld_op_desc, "_data_anchor_index_for_lxfusion", anchor_index_for_lxfusion), GELOGW("SetInt anchor_index_for_lxfusion failed");) } // do not care over flow graph_info_.num_of_pld_end_++; // replace output_desc of pld with input node's output desc int input_index = ge::AnchorUtils::GetIdx(peer_in_anchor); is_need_update_desc = (input_index >= 0) && (graph_info_.mode_ == kPartitioning); if (is_need_update_desc) { if (UpdatePldOpDesc(dst_node, input_index, pld_op_desc) != SUCCESS) { GELOGE(GRAPH_PARAM_INVALID, "UpdateEndOpDesc failed, output index %d", input_index); return FAILED; } } else { GeTensorDesc output_desc; if (pld_op_desc->AddOutputDesc(output_desc) != SUCCESS) { GELOGE(GRAPH_PARAM_INVALID, "AddOutputDesc failed, input index %d", input_index); return FAILED; } } NodePtr new_pld_node = pld_graph->AddNode(pld_op_desc); if (new_pld_node == nullptr) { GELOGE(GRAPH_PARAM_INVALID, "new_pld_node is nullptr."); return FAILED; } GE_IF_BOOL_EXEC(new_pld_node->SetOwnerComputeGraph(pld_graph) != GRAPH_SUCCESS, GELOGE(GRAPH_PARAM_INVALID, "SetOwnerComputeGraph failed"); return FAILED;) AnchorPtr pld_src_anchor = GetPldOutAnchor(new_pld_node, peer_in_anchor); // link placeHolder -> computeNode if (GraphUtils::AddEdge(pld_src_anchor, peer_in_anchor) != GRAPH_SUCCESS) { GELOGE(GE_GRAPH_ADD_PLC_END_FAILED, "add placeholder node : placeholder --> %s node %dth in-anchor in %s subgraph fail.", dst_node->GetName().c_str(), AnchorUtils::GetIdx(peer_in_anchor), pld_graph->GetName().c_str()); return FAILED; } graph_info_.index_2_end_[graph_info_.num_of_pld_end_] = new_end_node; graph_info_.pld_2_end_[new_pld_node] = new_end_node; graph_info_.end_2_pld_[new_end_node] = new_pld_node; return SUCCESS; } Status ge::GraphPartitioner::LinkInput2EndRemoveOrginalLink(ge::NodePtr input_node, ge::ComputeGraphPtr src_graph, ge::ComputeGraphPtr dst_graph) { if ((input_node == nullptr) || (src_graph == nullptr) || (dst_graph == nullptr)) { GELOGE(FAILED, "parameter ptr is null."); return FAILED; } // get the original anchors and remove the original link for (const auto &out_data_anchor : input_node->GetAllOutAnchors()) { for (auto &peer_in_anchor : out_data_anchor->GetPeerAnchors()) { if (peer_in_anchor->GetOwnerNode()->GetType() != kEndType) { if (GraphUtils::RemoveEdge(out_data_anchor, peer_in_anchor) != GRAPH_SUCCESS) { GELOGE(FAILED, "[GraphPartitioner]: RemoveEdge() failed."); return FAILED; } // link input -> end auto ret = AddPlaceHolderEndInSrcDstGraph(out_data_anchor, peer_in_anchor, src_graph, dst_graph); if (ret != SUCCESS) { GELOGE(GE_GRAPH_ADD_PLC_END_FAILED, "[GraphPartitioner]: AddPlaceHolderEndInSrcDstGraph() failed."); return ret; } } else { auto end_node = peer_in_anchor->GetOwnerNode(); if (GraphUtils::RemoveJustNode(src_graph, end_node) != GRAPH_SUCCESS) { GELOGE(FAILED, "[GraphPartitioner]: RemoveJustNode() failed."); return FAILED; } if (end_node->SetOwnerComputeGraph(dst_graph) != GRAPH_SUCCESS) { GELOGE(FAILED, "[GraphPartitioner]: RemoveJustNode() failed."); return FAILED; } if (dst_graph->AddNode(end_node) == nullptr) { GELOGE(FAILED, "[GraphPartitioner]: AddNode() failed."); return FAILED; } } } } return SUCCESS; } Status ge::GraphPartitioner::PutInputNodesInSubGraph(const ge::ComputeGraphPtr &src_graph, const ge::ComputeGraphPtr &dst_graph) { if ((src_graph == nullptr) || (dst_graph == nullptr)) { GELOGE(FAILED, "parameter ptr is null."); return FAILED; } for (auto &input_node : src_graph->GetDirectNode()) { if (IsDataLike(input_node)) { if (input_node->SetOwnerComputeGraph(dst_graph) != GRAPH_SUCCESS) { GELOGE(FAILED, "[GraphPartitioner]: SetOwnerComputeGraph failed."); return FAILED; } // remove input node from src_graph if (GraphUtils::RemoveJustNode(src_graph, input_node) != GRAPH_SUCCESS) { GELOGE(FAILED, "[GraphPartitioner]: RemoveJustNode() failed."); return FAILED; } // add input node to dst_graph if (dst_graph->AddNode(input_node) == nullptr) { GELOGE(FAILED, "[GraphPartitioner]: AddNode() failed."); return FAILED; } if (LinkInput2EndRemoveOrginalLink(input_node, src_graph, dst_graph) != ge::SUCCESS) { GELOGE(FAILED, "[GraphPartitioner]: LinkInput2EndRemoveOrginalLink() failed."); return FAILED; } } } return SUCCESS; } void ge::GraphPartitioner::AddNewGraphToPartition(ge::ComputeGraphPtr &input_graph, const std::string &engine_name) { if (input_graph == nullptr) { GELOGW("[GraphPartitioner]: input_graph is null, engine name is %s", engine_name.c_str()); return; } graph_info_.partitions_[input_graph] = engine_name; } bool ge::GraphPartitioner::IsDataLike(ge::NodePtr node) { return (node->GetType() == CONSTANT) || (node->GetType() == DATA) || (node->GetType() == AIPPDATA) || (node->GetType() == CONSTANTOP) || (node->GetType() == VARIABLE); } bool ge::GraphPartitioner::HasNoInput(ge::NodePtr node) { if (node == nullptr) { GELOGE(FAILED, "node_ptr is null."); return true; } return node->GetInNodes().empty(); } Status ge::GraphPartitioner::Initialize(ge::ComputeGraphPtr compute_graph) { GELOGI("Initialize starts."); std::shared_ptr instance_ptr = ge::GELib::GetInstance(); if (instance_ptr == nullptr || compute_graph == nullptr) { GELOGE(GE_GRAPH_NOT_INIT, "Graph partitioner initialize failed."); return FAILED; } graph_info_.engine_placer_.SetComputeGraph(compute_graph); if (graph_info_.engine_placer_.Run() != SUCCESS) { GELOGE(FAILED, "Engine placer run failed."); return FAILED; } const NodeEngineMap *node_engine_map = graph_info_.engine_placer_.GetNodeEngineMap(); size_t temp_index = 0; // travese nodes by topo order one by one for (const auto &node : compute_graph->GetDirectNode()) { std::string temp_stream; // node opdesc has been checked before (void)AttrUtils::GetStr(node->GetOpDesc(), ATTR_NAME_STREAM_LABEL, temp_stream); ClusterPtr new_cluster; // data like node without input should be handle specific if (HasNoInput(node) && IsDataLike(node)) { ClusterPtr cluster = MakeShared(temp_index, kEngineDefaultData, temp_stream); new_cluster = cluster; } else { if (node_engine_map->count(node) == 0) { GELOGE(FAILED, "node[%s] does not owner engine!", node->GetName().c_str()); return FAILED; } ClusterPtr cluster = MakeShared(temp_index, node_engine_map->at(node), temp_stream); new_cluster = cluster; } if (new_cluster == nullptr) { GELOGE(FAILED, "[GraphPartitioner]: failed to allocate new_cluster"); return FAILED; } new_cluster->nodes_.push_back(node); if (!HasNoInput(node)) { auto node_id = node->GetOpDesc()->GetId(); for (const auto &parent : node->GetInAllNodes()) { auto parent_id = parent->GetOpDesc()->GetId(); if (parent_id < node_id) { auto iter = graph_info_.node_2_cluster_.find(parent); if (iter == graph_info_.node_2_cluster_.end()) { GELOGE(FAILED, "[GraphPartitioner]: node[%s]id[%ld]'s parent_node[%s]id[%ld]" "should make cluster in advance", node->GetOpDesc()->GetName().c_str(), node_id, parent->GetOpDesc()->GetName().c_str(), parent_id); return FAILED; } new_cluster->in_clu_.insert(iter->second->index_); iter->second->out_clu_.insert(temp_index); } } } graph_info_.node_2_cluster_[node] = new_cluster; graph_info_.clusters_[temp_index] = new_cluster; GELOGD("Node name is %s, engine is %s, cluster index is %zu, stream label is %s", node->GetName().c_str(), new_cluster->engine_name_.c_str(), new_cluster->index_, new_cluster->stream_label_.c_str()); temp_index++; } GELOGD("Initialize ends."); return SUCCESS; } Status ge::GraphPartitioner::AddPartitionsToGraphNode(vector &output_subgraphs, ge::ComputeGraphPtr compute_graph) { const std::string &input_subgraph_name = "inputNodesSubGraph"; string session_graph_id; if (!AttrUtils::GetStr(*compute_graph, ATTR_NAME_SESSION_GRAPH_ID, session_graph_id)) { GELOGW("Get graph session_graph_id attr failed."); return INTERNAL_ERROR; } // the output_subgraphs have topological order for (const auto &sub_graph : graph_info_.rank_2_partitions_) { if (graph_info_.partitions_.find(sub_graph) == graph_info_.partitions_.end()) { GELOGE(GE_GRAPH_EMPTY_PARTITION, "[GraphPartitioner]: partition is null."); return FAILED; } auto &engine_name = graph_info_.partitions_.at(sub_graph); (void)AttrUtils::SetStr(sub_graph, ATTR_NAME_PARENT_GRAPH_NAME, compute_graph->GetName()); GELOGD("set attr success. subgraph(%s) with parent graph(%s)", sub_graph->GetName().c_str(), compute_graph->GetName().c_str()); GE_DUMP(sub_graph, sub_graph->GetName() + "_" + mode_2_str_[graph_info_.mode_]); if (!session_graph_id.empty()) { GE_IF_BOOL_EXEC(!AttrUtils::SetStr(sub_graph, ATTR_NAME_SESSION_GRAPH_ID, session_graph_id), GELOGW("SetStr ATTR_NAME_SESSION_GRAPH_ID failed");) } // flush parent node of subgraph sub_graph->SetParentNode(compute_graph->GetParentNode()); auto sgi = MakeShared(); if (sgi == nullptr) { GELOGE(GE_GRAPH_PARAM_NULLPTR, "[GraphPartitioner]: MakeShared sub graph info failed."); return FAILED; } // set engine name sgi->SetEngineName(engine_name); // set stream label string sub_graph_stream; if (AttrUtils::GetStr(sub_graph->GetDirectNode().at(0)->GetOpDesc(), ATTR_NAME_STREAM_LABEL, sub_graph_stream)) { sgi->SetStreamLabel(sub_graph_stream); } /// for now inputFlag is the same before and after partition. It should /// be changed according to the real partition std::vector sub_graph_input(graph_info_.input_size_, true); std::vector sub_graph_output(graph_info_.output_size_, true); sgi->SetSubGraph(sub_graph); sgi->SetOutputFlag(sub_graph_output); sgi->SetInputFlag(sub_graph_input); sgi->SetOutputContext(graph_info_.output_name_); AddEndPldInformationToSubGraphInfo(sgi); GELOGI("[GraphPartitioner]: subGraph engine name is %s, graph name is %s, stream label is %s", engine_name.c_str(), sub_graph->GetName().c_str(), sgi->GetStreamLabel().empty() ? "null" : sgi->GetStreamLabel().c_str()); if (engine_name != input_subgraph_name) { // do not add Data subGraph into SubGraphInfo output_subgraphs.push_back(sgi); } else { graph_2_input_subgraph_[compute_graph] = sgi; } } return SUCCESS; } // check if two clusters can merge bool ge::GraphPartitioner::IsMergeable(size_t parent_cluster, size_t child_cluster, size_t upper_bound) { if ((graph_info_.clusters_[parent_cluster] == nullptr) || (graph_info_.clusters_[parent_cluster]->nodes_.empty()) || (graph_info_.clusters_[child_cluster] == nullptr) || (graph_info_.clusters_[child_cluster]->nodes_.empty())) { return false; } // Check if parent_cluster,child_cluster has same engine or stream label if ((graph_info_.clusters_[parent_cluster]->engine_name_ != graph_info_.clusters_[child_cluster]->engine_name_) || (graph_info_.clusters_[parent_cluster]->stream_label_ != graph_info_.clusters_[child_cluster]->stream_label_)) { GELOGD("Parent cluster %zu engine %s stream label %s, child cluster %zu engine %s stream label %s can not merge", parent_cluster, graph_info_.clusters_[parent_cluster]->engine_name_.c_str(), graph_info_.clusters_[parent_cluster]->stream_label_.c_str(), child_cluster, graph_info_.clusters_[child_cluster]->engine_name_.c_str(), graph_info_.clusters_[child_cluster]->stream_label_.c_str()); return false; } // Check if parent_cluster,child_cluster is reachable RemoveEdge(parent_cluster, child_cluster); // Check if there is a path between parent and child, if return true, can not merge if (HasSecondPath(parent_cluster, child_cluster, upper_bound)) { GELOGD("Find second path from %zu to %zu, upper bound is %zu", parent_cluster, child_cluster, upper_bound); InsertEdge(parent_cluster, child_cluster); return false; } InsertEdge(parent_cluster, child_cluster); return true; } void ge::GraphPartitioner::MergeTwoClusters(size_t parent_cluster, size_t &child_cluster) { // check which index is bigger size_t big_cluster, small_cluster; size_t child_cluster_original = child_cluster; if (parent_cluster > child_cluster) { small_cluster = child_cluster; big_cluster = parent_cluster; } else { big_cluster = child_cluster; small_cluster = parent_cluster; // flush child_cluster, because it has been modified child_cluster = small_cluster; } // update node_2_cluster_ map for (auto &node : graph_info_.clusters_[big_cluster]->nodes_) { graph_info_.node_2_cluster_[node] = graph_info_.clusters_[small_cluster]; } // merge nodes graph_info_.clusters_[small_cluster]->nodes_.splice(graph_info_.clusters_[small_cluster]->nodes_.end(), graph_info_.clusters_[big_cluster]->nodes_); // merge all input & output to small cluster graph_info_.clusters_[small_cluster]->in_clu_.insert(graph_info_.clusters_[big_cluster]->in_clu_.begin(), graph_info_.clusters_[big_cluster]->in_clu_.end()); graph_info_.clusters_[small_cluster]->out_clu_.insert(graph_info_.clusters_[big_cluster]->out_clu_.begin(), graph_info_.clusters_[big_cluster]->out_clu_.end()); // remove child_cluster's out parent_cluster's in between child_cluster and parent_cluster RemoveEdge(parent_cluster, child_cluster_original); // update in/out of the cluster with bigger index for (auto in_clu : graph_info_.clusters_[big_cluster]->in_clu_) { graph_info_.clusters_[in_clu]->out_clu_.insert(small_cluster); graph_info_.clusters_[in_clu]->out_clu_.erase(big_cluster); } for (auto out_clu : graph_info_.clusters_[big_cluster]->out_clu_) { graph_info_.clusters_[out_clu]->in_clu_.insert(small_cluster); graph_info_.clusters_[out_clu]->in_clu_.erase(big_cluster); } graph_info_.clusters_[big_cluster] = graph_info_.clusters_[small_cluster]; } void ge::GraphPartitioner::RemoveEdge(size_t parent_cluster, size_t child_cluster) { graph_info_.clusters_[child_cluster]->in_clu_.erase(parent_cluster); graph_info_.clusters_[parent_cluster]->out_clu_.erase(child_cluster); } void ge::GraphPartitioner::InsertEdge(size_t from, size_t to) { if (from == to) { return; } if (!graph_info_.clusters_[from]->out_clu_.insert(to).second) { // edge has already exists return; } graph_info_.clusters_[to]->in_clu_.insert(from); } void ge::GraphPartitioner::MarkClusters() { GELOGI("MarkClusters starts. cluster size is %zu", graph_info_.clusters_.size()); size_t cluster_size = graph_info_.clusters_.size(); for (size_t child_cluster = 0; child_cluster < cluster_size; child_cluster++) { auto found_child_cluster = graph_info_.clusters_[child_cluster]; if (found_child_cluster == nullptr) { GELOGW("can not found child_cluster is %zu", child_cluster); continue; } auto copy_parents_clusters = found_child_cluster->in_clu_; vector ordered_cluster; for (const auto &parent_cluster : copy_parents_clusters) { ordered_cluster.emplace_back(parent_cluster); } // sort cluster according to it's output amount auto comp_func = [this](const size_t &parent_cluster1, const size_t &parent_cluster2) -> bool { return graph_info_.clusters_[parent_cluster1]->out_clu_.size() < graph_info_.clusters_[parent_cluster2]->out_clu_.size(); }; std::sort(ordered_cluster.begin(), ordered_cluster.end(), comp_func); auto child_merged = child_cluster; for (const auto &parent_cluster : ordered_cluster) { if (IsMergeable(parent_cluster, child_merged, child_cluster)) { MergeTwoClusters(parent_cluster, child_merged); GELOGD("Merging cluster %zu and %zu to %zu", parent_cluster, child_cluster, child_merged); } } } GELOGD("MarkClusters ends."); } Status ge::GraphPartitioner::SplitSubGraphs(ge::ComputeGraphPtr compute_graph) { GELOGD("SplitSubGraphs starts."); if (compute_graph == nullptr) { GELOGE(FAILED, "parameter ptr is null."); return FAILED; } // Create graphs for all clusters std::unordered_set cluster_set; // add pld&end for (auto &node : compute_graph->GetDirectNode()) { GELOGD("Node name is %s.", node->GetName().c_str()); auto child_cluster = graph_info_.node_2_cluster_[node]; ge::ComputeGraphPtr corresponding_graph; // unordered_set's insert returns a pair, second of pair is bool if (!cluster_set.insert(child_cluster).second) { GELOGD("Old sub graph, child_cluster is %zu", child_cluster->index_); corresponding_graph = graph_info_.cluster_2_partition_.at(child_cluster); } else { std::string graph_name = "new_sub_graph" + std::to_string(graph_info_.partitions_.size()); ComputeGraphPtr new_sub_graph = MakeShared(graph_name); if (new_sub_graph == nullptr) { GELOGE(GE_GRAPH_PARAM_NULLPTR, "[GraphPartitioner]: MakeShared() failed."); return FAILED; } AddNewGraphToPartition(new_sub_graph, child_cluster->engine_name_); corresponding_graph = new_sub_graph; graph_info_.cluster_2_partition_[child_cluster] = corresponding_graph; GELOGD("New sub graph, name is %s", graph_name.c_str()); } // build node to corresponding node map NodePtr corresponding_node = corresponding_graph->AddNode(node->GetOpDesc()); if (corresponding_node == nullptr) { GELOGE(GE_GRAPH_PARAM_NULLPTR, "[GraphPartitioner]: AddNode() failed."); return FAILED; } graph_info_.corresponding_node_in_partitions_[node] = corresponding_node; GE_CHK_STATUS_RET(corresponding_node->SetOwnerComputeGraph(corresponding_graph)) for (const auto &in_anchor : node->GetAllInAnchors()) { GELOGD("In anchor index is %d", AnchorUtils::GetIdx(in_anchor)); for (auto &peer_out_anchor : in_anchor->GetPeerAnchors()) { GELOGD("Peer out anchor index is %d", AnchorUtils::GetIdx(peer_out_anchor)); // Normally, all nodes have a copy in corresponding_node_in_partitions_, so function at can not be exception auto iter = graph_info_.corresponding_node_in_partitions_.find(peer_out_anchor->GetOwnerNode()); if (iter == graph_info_.corresponding_node_in_partitions_.end()) { GELOGE(GRAPH_FAILED, "[SpiltSubGraphs]: node[%s]id[%ld]'s parent_node[%s]id[%ld]" "should make corresponding in advance", node->GetOpDesc()->GetName().c_str(), node->GetOpDesc()->GetId(), peer_out_anchor->GetOwnerNode()->GetOpDesc()->GetName().c_str(), peer_out_anchor->GetOwnerNode()->GetOpDesc()->GetId()); return GRAPH_FAILED; } auto parent_node = iter->second; GE_CHECK_NOTNULL(parent_node); GELOGD("Parent node name is %s", parent_node->GetName().c_str()); // add edge auto src_anchor = parent_node->GetOutAnchor(AnchorUtils::GetIdx(peer_out_anchor)); auto dst_anchor = corresponding_node->GetInAnchor(AnchorUtils::GetIdx(in_anchor)); // if child and parent's cluster is not same, add plc and end auto parent_cluster = graph_info_.node_2_cluster_[peer_out_anchor->GetOwnerNode()]; if (parent_cluster != child_cluster) { GELOGD("Parent cluster is %zu, child_cluster is %zu", parent_cluster->index_, child_cluster->index_); if (AddPlaceHolderEnd(peer_out_anchor, in_anchor) != ge::SUCCESS) { GELOGE(GE_GRAPH_ADD_PLC_END_FAILED, "[GraphPartitioner]: AddPlaceHolderEndInSrcDstGraph() failed."); return FAILED; } } else { // parent and child in the same cluster, add edge GELOGD("AddEdge from parent cluster %zu to child %zu", parent_cluster->index_, child_cluster->index_); if (GraphUtils::AddEdge(src_anchor, dst_anchor) != GRAPH_SUCCESS) { GELOGE(GRAPH_FAILED, "AddEdge fail, from %s to %s", peer_out_anchor->GetOwnerNode()->GetName().c_str(), in_anchor->GetOwnerNode()->GetName().c_str()); return FAILED; } } } } } GELOGD("SplitSubGraphs ends."); return SUCCESS; } /// before calling this function, the direct path between src and dst are already removed. /// return true if a second path is found bool ge::GraphPartitioner::HasSecondPath(size_t src, size_t dst, size_t upper_bound) { if (graph_info_.clusters_.at(src)->out_clu_.empty() || graph_info_.clusters_.at(dst)->in_clu_.empty()) { return false; } /// Avoid recursion since stack space might be limited. /// We instead keep a stack of nodes to visit. std::vector temp_stack; std::set visited; temp_stack.push_back(src); while (!temp_stack.empty()) { size_t cluster = temp_stack.back(); temp_stack.pop_back(); ClusterPtr cur_cluster = graph_info_.clusters_[cluster]; if (!visited.insert(cluster).second) { continue; } for (auto out : cur_cluster->out_clu_) { if (out == dst) { return true; // There is cycle } if (out < upper_bound) { temp_stack.push_back(out); } } } return false; } Status ge::GraphPartitioner::Partition(ge::ComputeGraphPtr compute_graph, Mode mode) { ClearAllPartitionData(); auto real_ret = SUCCESS; auto ret = PartitionSubGraph(compute_graph, mode); if (ret != SUCCESS) { GELOGE(ret, "Sub graph partition Failed"); real_ret = ret; } GE_CHECK_NOTNULL(compute_graph); // partition sub graph for (const auto &sub_graph : compute_graph->GetAllSubgraphs()) { ret = PartitionSubGraph(sub_graph, mode); if (ret != SUCCESS) { GELOGE(ret, "Sub graph partition Failed"); real_ret = ret; } } if (real_ret != SUCCESS) { auto root_graph = ge::GraphUtils::FindRootGraph(compute_graph); GE_CHECK_NOTNULL(root_graph); (void)Analyzer::GetInstance()->SaveAnalyzerDataToFile(root_graph->GetSessionID(), root_graph->GetGraphID()); } return real_ret; } Status ge::GraphPartitioner::PartitionSubGraph(ge::ComputeGraphPtr compute_graph, Mode mode) { if (compute_graph == nullptr) { GELOGE(GE_GRAPH_NULL_INPUT, "[GraphPartitioner]: compute_graph is null."); return FAILED; } // clear graph_info graph_info_.ClearAllData(mode); graph_info_.output_name_ = compute_graph->GetOutput(); graph_info_.output_size_ = compute_graph->GetOutputSize(); graph_info_.input_size_ = compute_graph->GetInputSize(); if (graph_info_.output_size_ == 0) { GELOGE(GE_GRAPH_NULL_INPUT, "The output size need to be greater than 0."); return FAILED; } GELOGI("Graph Partition starts, graph nodes size is %zu", compute_graph->GetDirectNodesSize()); Status ret = compute_graph->TopologicalSorting(); if (ret != SUCCESS) { GELOGE(GE_GRAPH_TOPO_SORT_FAILED, "[GraphPartitioner]: subGraphPtr->TopologicalSorting failed"); return FAILED; } GE_TIMESTAMP_START(PartitionSubGraphInitialize); if (Initialize(compute_graph) != SUCCESS) { GELOGE(GE_GRAPH_INIT_FAILED, "[GraphPartitioner]: initialize failed"); return FAILED; } GE_TIMESTAMP_END(PartitionSubGraphInitialize, "GraphPartitioner::PartitionInitialize"); GE_TIMESTAMP_START(PartitionSubGraphMarkClusters); MarkClusters(); GE_TIMESTAMP_END(PartitionSubGraphMarkClusters, "GraphPartitioner::PartitionMarkClusters"); GE_TIMESTAMP_START(PartitionSubGraphSplitSubGraphs); if (SplitSubGraphs(compute_graph) != SUCCESS) { GELOGE(FAILED, "[GraphPartitioner]: SplitSubGraphs failed"); return FAILED; } GE_TIMESTAMP_END(PartitionSubGraphSplitSubGraphs, "GraphPartitioner::PartitionSplitSubGraphs"); GE_TIMESTAMP_START(PartitionSubGraphSortSubGraphs); if (SortSubGraphs(compute_graph) != ge::SUCCESS) { GELOGE(GE_GRAPH_TOPO_SORT_FAILED, "Graph Partition SortSubGraphs failed."); return ge::FAILED; } GE_TIMESTAMP_END(PartitionSubGraphSortSubGraphs, "GraphPartitioner::PartitionSortSubGraphs"); GE_TIMESTAMP_START(PartitionSubGraphAddPartitionsToGraphNode); vector output_subgraphs; if (AddPartitionsToGraphNode(output_subgraphs, compute_graph) != ge::SUCCESS) { GELOGE(GE_GRAPH_EMPTY_PARTITION, "Graph Partition AddPartitionsToGraphNode failed."); return ge::FAILED; } GE_TIMESTAMP_END(PartitionSubGraphAddPartitionsToGraphNode, "GraphPartitioner::PartitionAddPartitionsToGraphNode"); GELOGI("Graph Partition ends. Adding partitions to SubGraphInfo, got %zu sub graphs", output_subgraphs.size()); graph_info_.mode_ = kMerging; // do not care over flow partition_times_++; graph_2_graph_partition_info_[compute_graph] = graph_info_; graph_2_subgraph_list_[compute_graph] = output_subgraphs; return SUCCESS; } // all the inputs are the nodes and anchors in the original graph Status ge::GraphPartitioner::AddPlaceHolderEnd(const AnchorPtr &out_anchor, const AnchorPtr &in_anchor) { if ((out_anchor == nullptr) || (in_anchor == nullptr)) { GELOGE(GE_GRAPH_PARAM_NULLPTR, "src_node or dst_node is null."); return FAILED; } // nodes in original graph const auto &src_node = out_anchor->GetOwnerNode(); const auto &dst_node = in_anchor->GetOwnerNode(); if ((src_node == nullptr) || (dst_node == nullptr)) { GELOGE(GE_GRAPH_PARAM_NULLPTR, "src_node or dst_node is null."); return FAILED; } // All nodes have a copy in corresponding_node_in_partitions_, so function at can not be execption auto src_anchor = graph_info_.corresponding_node_in_partitions_.at(src_node)->GetOutAnchor(AnchorUtils::GetIdx(out_anchor)); auto dst_anchor = graph_info_.corresponding_node_in_partitions_.at(dst_node)->GetInAnchor(AnchorUtils::GetIdx(in_anchor)); if ((src_anchor == nullptr) || (dst_anchor == nullptr)) { GELOGE(GE_GRAPH_PARAM_NULLPTR, "src_anchor or dst_anchor is null."); return FAILED; } // anchors in subGraph const ComputeGraphPtr &src_subgraph = src_anchor->GetOwnerNode()->GetOwnerComputeGraph(); const ComputeGraphPtr &dst_subgraph = dst_anchor->GetOwnerNode()->GetOwnerComputeGraph(); // add end and pld node auto ret = AddPlaceHolderEndInSrcDstGraph(src_anchor, dst_anchor, dst_subgraph, src_subgraph); if (ret != SUCCESS) { GELOGE(GE_GRAPH_ADD_PLC_END_FAILED, "[GraphPartitioner]: add placeholder end failed."); return ret; } return SUCCESS; } Status ge::GraphPartitioner::SortSubGraphs(const ge::ComputeGraphPtr &compute_graph) { uint32_t rank = kRankOne; // rank 0 for data graph ComputeGraphPtr new_input_nodes_sub_graph = MakeShared("inputNodeGraph"); if ((new_input_nodes_sub_graph == nullptr) || (compute_graph == nullptr)) { GELOGE(FAILED, "[GraphPartitioner]: new_input_nodes_sub_graph or compute_graph is null."); return FAILED; } for (const auto &node : compute_graph->GetDirectNode()) { // All nodes in original graph have a copy in corresponding_node_in_partitions_, so it can not be null auto sub_graph = graph_info_.corresponding_node_in_partitions_.at(node)->GetOwnerComputeGraph(); if ((graph_info_.partitions_2_rank_.find(sub_graph) == graph_info_.partitions_2_rank_.end()) && (graph_info_.partitions_[sub_graph] != kEngineDefaultData)) { graph_info_.partitions_2_rank_[sub_graph] = rank; graph_info_.rank_2_partitions_.push_back(sub_graph); rank++; } else if (graph_info_.partitions_[sub_graph] == kEngineDefaultData) { // merge data graph if (PutInputNodesInSubGraph(sub_graph, new_input_nodes_sub_graph) != SUCCESS) { GELOGE(FAILED, "[GraphPartitioner]: putInputNodesInSubGraph failed."); return FAILED; } auto to_be_del = graph_info_.partitions_.find(sub_graph); graph_info_.partitions_.erase(to_be_del); } } if (!new_input_nodes_sub_graph->GetDirectNode().empty()) { graph_info_.rank_2_partitions_.insert(graph_info_.rank_2_partitions_.begin(), new_input_nodes_sub_graph); graph_info_.partitions_2_rank_[new_input_nodes_sub_graph] = 0; AddNewGraphToPartition(new_input_nodes_sub_graph, "inputNodesSubGraph"); } // reinit rank rank = kRankZero; for (const auto &it : graph_info_.rank_2_partitions_) { // rename subGraph based on rank if (it != nullptr) { // rename subGraph based on rank string graph_name = "partition" + std::to_string(partition_times_) + "_rank" + std::to_string(rank) + "_" + it->GetName(); it->SetName(graph_name); } rank++; } return SUCCESS; } AnchorPtr ge::GraphPartitioner::GetEndInAnchor(const AnchorPtr &src_anchor, const NodePtr &end_node) { if ((src_anchor == nullptr) || (end_node == nullptr)) { GELOGE(FAILED, "parameter ptr is null."); return nullptr; } AnchorPtr end_in_anchor; if (Anchor::DynamicAnchorCast(src_anchor) != nullptr) { end_in_anchor = end_node->GetInDataAnchor(0); } else { end_in_anchor = end_node->GetInControlAnchor(); } return end_in_anchor; } AnchorPtr ge::GraphPartitioner::GetPldOutAnchor(const NodePtr &pld_node, const AnchorPtr &dst_anchor) { if ((pld_node == nullptr) || (dst_anchor == nullptr)) { GELOGE(FAILED, "parameter ptr is null."); return nullptr; } AnchorPtr pld_out_anchor; if (Anchor::DynamicAnchorCast(dst_anchor) != nullptr) { pld_out_anchor = pld_node->GetOutDataAnchor(0); } else { pld_out_anchor = pld_node->GetOutControlAnchor(); } return pld_out_anchor; } void ge::GraphPartitioner::AddEndPldInformationToSubGraphInfo(ge::SubGraphInfoPtr &subgraph_info) { if (subgraph_info == nullptr) { GELOGE(FAILED, "parameter ptr is null."); return; } auto subgraph = subgraph_info->GetSubGraph(); GE_CHECK_NOTNULL_JUST_RETURN(subgraph); NodetoNodeMap end_map; NodetoNodeMap pld_map; for (const auto &node : subgraph->GetDirectNode()) { if (node->GetType() == kEndType) { end_map[node] = graph_info_.end_2_pld_.at(node); } if (node->GetType() == kPlaceHolderType) { pld_map[node] = graph_info_.pld_2_end_.at(node); } } subgraph_info->SetEnd2PldMap(end_map); subgraph_info->SetPld2EndMap(pld_map); } const Graph2SubGraphInfoList &ge::GraphPartitioner::GetSubGraphMap() { return graph_2_subgraph_list_; } void ge::GraphPartitioner::ClearAllPartitionData() { graph_2_graph_partition_info_.clear(); graph_2_subgraph_list_.clear(); graph_2_input_subgraph_.clear(); GELOGD("Clear all partition data success."); return; } } // namespace ge