You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
330 lines
12 KiB
330 lines
12 KiB
/**
|
|
* 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/passes/folding_pass.h"
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
#include <unordered_set>
|
|
|
|
#include "framework/common/debug/ge_log.h"
|
|
#include "graph/utils/graph_utils.h"
|
|
#include "graph/utils/node_utils.h"
|
|
#include "inc/kernel.h"
|
|
#include "inc/kernel_factory.h"
|
|
#include "graph/debug/ge_attr_define.h"
|
|
#include "ge_local_engine/engine/host_cpu_engine.h"
|
|
|
|
namespace ge {
|
|
namespace folding_pass {
|
|
shared_ptr<Kernel> GetKernelByType(const NodePtr &node) {
|
|
if (node == nullptr) {
|
|
GELOGE(FAILED, "parameter is null.");
|
|
return nullptr;
|
|
}
|
|
KernelFactory &factory = KernelFactory::Instance();
|
|
string type = node->GetType();
|
|
if (type == FRAMEWORKOP) {
|
|
if (!ge::AttrUtils::GetStr(node->GetOpDesc(), ATTR_NAME_FRAMEWORK_ORIGINAL_TYPE, type)) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
return factory.Create(type);
|
|
}
|
|
bool IsNoNeedConstantFolding(const NodePtr &node) {
|
|
auto node_desc = node->GetOpDesc();
|
|
return node_desc == nullptr || node_desc->HasAttr(ATTR_NO_NEED_CONSTANT_FOLDING);
|
|
}
|
|
} // namespace folding_pass
|
|
|
|
namespace {
|
|
IndexsToAnchors GetIndexAndPeerInDataAnchors(NodePtr &node) {
|
|
IndexsToAnchors indexes_to_anchors;
|
|
for (auto &out_anchor : node->GetAllOutDataAnchors()) {
|
|
if (out_anchor == nullptr) {
|
|
continue;
|
|
}
|
|
for (auto &peer_in_anchor : out_anchor->GetPeerInDataAnchors()) {
|
|
if (peer_in_anchor == nullptr) {
|
|
continue;
|
|
}
|
|
const auto &peer_node = peer_in_anchor->GetOwnerNode();
|
|
if (peer_node == nullptr) {
|
|
continue;
|
|
}
|
|
indexes_to_anchors[out_anchor->GetIdx()].push_back(peer_in_anchor);
|
|
}
|
|
}
|
|
|
|
return indexes_to_anchors;
|
|
}
|
|
|
|
NodePtr AddConstNodeToGraph(GeTensorPtr &tensor, ComputeGraphPtr &graph) {
|
|
auto const_desc = OpDescUtils::CreateConstOp(tensor);
|
|
if (const_desc == nullptr) {
|
|
GELOGE(OUT_OF_MEMORY, "Failed to get const desc from tensor");
|
|
return nullptr;
|
|
}
|
|
|
|
GE_IF_BOOL_EXEC(graph == nullptr, GELOGW("input param graph is null"); return nullptr);
|
|
(void)AttrUtils::SetListStr(const_desc, ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, std::move(std::vector<std::string>()));
|
|
return graph->AddNodeFront(const_desc);
|
|
}
|
|
|
|
NodePtr AddIdentityNodeToGraph(const std::string &name, const GeTensorDesc &tensor, ComputeGraphPtr &graph) {
|
|
if (graph == nullptr) {
|
|
GELOGE(INTERNAL_ERROR, "Compute graph ptr is null in creating identity node.");
|
|
return nullptr;
|
|
}
|
|
|
|
OpDescPtr desc = MakeShared<OpDesc>("", "");
|
|
if (desc == nullptr) {
|
|
GELOGE(MEMALLOC_FAILED, "Failed to create op desc.");
|
|
return nullptr;
|
|
}
|
|
|
|
desc->SetName(name);
|
|
desc->SetType(IDENTITY);
|
|
auto ret = desc->AddInputDesc(tensor);
|
|
auto ret2 = desc->AddOutputDesc(tensor);
|
|
if ((ret != GRAPH_SUCCESS) || (ret2 != GRAPH_SUCCESS)) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to add input/output desc in creating Identity.");
|
|
return nullptr;
|
|
}
|
|
|
|
return graph->AddNodeFront(desc);
|
|
}
|
|
} // namespace
|
|
|
|
Status FoldingPass::RunOpKernel(NodePtr &node, const vector<ConstGeTensorPtr> &inputs,
|
|
std::vector<GeTensorPtr> &outputs) {
|
|
return HostCpuEngine::GetInstance().Run(node, inputs, outputs);
|
|
}
|
|
|
|
Status FoldingPass::Folding(NodePtr &node, vector<GeTensorPtr> &outputs) {
|
|
GE_CHECK_NOTNULL(node);
|
|
GELOGD("begin folding node:%s", node->GetName().c_str());
|
|
// Before processing nodes, collect the relations between the out anchor and the peer out data nodes
|
|
// to prepare for const reconnection
|
|
auto indexes_to_anchors = GetIndexAndPeerInDataAnchors(node);
|
|
|
|
auto ret = DealWithInNodes(node);
|
|
if (ret != SUCCESS) {
|
|
return ret;
|
|
}
|
|
if (AddConstNode(node, indexes_to_anchors, outputs) != SUCCESS) {
|
|
return INTERNAL_ERROR;
|
|
}
|
|
|
|
auto in_data_nodes = node->GetInDataNodes();
|
|
std::unordered_set<NodePtr> in_data_nodes_set(in_data_nodes.begin(), in_data_nodes.end());
|
|
if (IsolateAndDeleteNode(node, {}) != SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to isolate and delete node %s, type %s.", node->GetName().c_str(),
|
|
node->GetType().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
for (auto iter = in_data_nodes_set.begin(); iter != in_data_nodes_set.end(); ++iter) {
|
|
auto pre_node = *iter;
|
|
if (pre_node->GetOutDataNodesSize() == 0) {
|
|
if ((pre_node->GetType() == DATA) || (pre_node->GetType() == ENTER)) {
|
|
GELOGI("No need to remove data/enter, node name:%s.", pre_node->GetName().c_str());
|
|
continue;
|
|
}
|
|
if (IsolateAndDeleteNode(pre_node, {}) != SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to isolate and delete in data node %s, type %s.", pre_node->GetName().c_str(),
|
|
pre_node->GetType().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status FoldingPass::DealWithInNodes(NodePtr &node) {
|
|
GE_CHECK_NOTNULL(node);
|
|
GE_CHECK_NOTNULL(node->GetOpDesc());
|
|
auto graph = node->GetOwnerComputeGraph();
|
|
auto in_data_anchors = node->GetAllInDataAnchors();
|
|
for (auto &in_data_anchor : in_data_anchors) {
|
|
if (in_data_anchor == nullptr) {
|
|
continue;
|
|
}
|
|
auto in_node_anchor = in_data_anchor->GetPeerOutAnchor();
|
|
if (in_node_anchor == nullptr) {
|
|
continue;
|
|
}
|
|
auto in_node = in_node_anchor->GetOwnerNode();
|
|
if (in_node == nullptr) {
|
|
continue;
|
|
}
|
|
if ((in_node->GetType() == SWITCH) || (in_node->GetType() == REFSWITCH)) {
|
|
GELOGI("The in_node name is %s, and node type is %s.", in_node->GetName().c_str(), in_node->GetType().c_str());
|
|
auto ret = in_node_anchor->Unlink(in_data_anchor);
|
|
if (ret != SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to unlink anchor between const node %s to constant-folding-node %s, type %s.",
|
|
in_node->GetName().c_str(), node->GetName().c_str(), node->GetType().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
GELOGI("Unlink anchor between in_node %s and node %s success.", in_node->GetName().c_str(),
|
|
node->GetName().c_str());
|
|
auto identity_name = node->GetName() + "_ctrl_identity_" + std::to_string(in_data_anchor->GetIdx());
|
|
auto identity =
|
|
AddIdentityNodeToGraph(identity_name, node->GetOpDesc()->GetInputDesc(in_data_anchor->GetIdx()), graph);
|
|
if (identity == nullptr) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to add identity node to graph.");
|
|
return INTERNAL_ERROR;
|
|
}
|
|
ret = GraphUtils::AddEdge(in_node_anchor, identity->GetInDataAnchor(0));
|
|
if (ret != GRAPH_SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to add edge, from node %s to node %s.", in_node->GetName().c_str(),
|
|
identity->GetName().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
GELOGI("Create new identity node success.");
|
|
ret = GraphUtils::AddEdge(identity->GetOutControlAnchor(), node->GetInControlAnchor());
|
|
if (ret != GRAPH_SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to add edge, from node %s to node %s.", in_node->GetName().c_str(),
|
|
node->GetName().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status FoldingPass::AddConstNode(NodePtr &node, IndexsToAnchors indexes_to_anchors,
|
|
std::vector<GeTensorPtr> &v_weight) {
|
|
if (node == nullptr) {
|
|
GELOGE(PARAM_INVALID, "node is null");
|
|
return FAILED;
|
|
}
|
|
auto graph = node->GetOwnerComputeGraph();
|
|
for (auto &index_to_anchors : indexes_to_anchors) {
|
|
auto index = static_cast<size_t>(index_to_anchors.first);
|
|
if (index >= v_weight.size()) {
|
|
GELOGE(INTERNAL_ERROR,
|
|
"Failed to constant fold on node %s type %s, "
|
|
"the out nodes num %lu calculated is less than the node out anchor index %zu",
|
|
node->GetName().c_str(), node->GetType().c_str(), v_weight.size(), index);
|
|
return INTERNAL_ERROR;
|
|
}
|
|
GeTensorPtr weight = v_weight[index];
|
|
if (weight == nullptr) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to constant fold on node %s type %s, the %lust node calculated is null",
|
|
node->GetName().c_str(), node->GetType().c_str(), index);
|
|
return INTERNAL_ERROR;
|
|
}
|
|
|
|
auto const_node = AddConstNodeToGraph(weight, graph);
|
|
if (const_node == nullptr) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to add dynamic const node, node name:%s, index:%zu.", node->GetName().c_str(),
|
|
index);
|
|
return INTERNAL_ERROR;
|
|
}
|
|
GELOGI("add const_node:%s, replace node %s, type %s, index %zu.", const_node->GetName().c_str(),
|
|
node->GetName().c_str(), node->GetType().c_str(), index);
|
|
// add new const to re-pass node
|
|
for (auto &in_anchor : index_to_anchors.second) {
|
|
if (in_anchor == nullptr) {
|
|
GELOGE(INTERNAL_ERROR, "In anchor is nullptr.");
|
|
return INTERNAL_ERROR;
|
|
}
|
|
auto ret = ConnectNodeToInAnchor(in_anchor, const_node, 0);
|
|
if (ret != SUCCESS) {
|
|
return ret;
|
|
}
|
|
NodeUtils::UpdateIsInputConst(*(in_anchor->GetOwnerNode()));
|
|
}
|
|
Status ret = GraphUtils::AddEdge(node->GetOutControlAnchor(), const_node->GetInControlAnchor());
|
|
if (ret != GRAPH_SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to add control edge, from node %s to const node %s.", node->GetName().c_str(),
|
|
const_node->GetName().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
GE_CHECK_NOTNULL(node->GetOpDesc());
|
|
std::string stream_label;
|
|
if (AttrUtils::GetStr(node->GetOpDesc(), ATTR_NAME_STREAM_LABEL, stream_label)) {
|
|
GE_CHECK_NOTNULL(const_node->GetOpDesc());
|
|
if (!AttrUtils::SetStr(const_node->GetOpDesc(), ATTR_NAME_STREAM_LABEL, stream_label)) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to set stream label on dynamic const node %s, with stream label:%s.",
|
|
const_node->GetName().c_str(), stream_label.c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
}
|
|
GELOGD("Add control edge when insert dynamic const, from node %s to const node %s, with stream label:%s.",
|
|
node->GetName().c_str(), const_node->GetName().c_str(), stream_label.c_str());
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status FoldingPass::RemoveNodeKeepingCtrlEdges(NodePtr &node) {
|
|
GE_IF_BOOL_EXEC(node == nullptr, GELOGE(PARAM_INVALID, "node is null"); return PARAM_INVALID);
|
|
auto ret = GraphUtils::IsolateNode(node, {});
|
|
if (ret != GRAPH_SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to isolate the folding-node %s type %s", node->GetName().c_str(),
|
|
node->GetType().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
|
|
auto graph = node->GetOwnerComputeGraph();
|
|
ret = GraphUtils::RemoveNodeWithoutRelink(graph, node);
|
|
if (ret != GRAPH_SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to remove node %s from graph", node->GetName().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
AddNodeDeleted(node);
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status FoldingPass::ConnectNodeToInAnchor(InDataAnchorPtr &in_anchor, NodePtr &node, int node_index) {
|
|
// the origin edge must be removed before add
|
|
if (in_anchor == nullptr || node == nullptr) {
|
|
GELOGE(PARAM_INVALID, "in anchor or node is null");
|
|
return PARAM_INVALID;
|
|
}
|
|
auto peer_out_anchor = in_anchor->GetPeerOutAnchor();
|
|
if (peer_out_anchor != nullptr) {
|
|
if (ge::GraphUtils::RemoveEdge(peer_out_anchor, in_anchor) != GRAPH_SUCCESS) {
|
|
GELOGW("RemoveEdge failed.");
|
|
}
|
|
}
|
|
|
|
auto new_out_anchor = node->GetOutDataAnchor(node_index);
|
|
if (new_out_anchor == nullptr) {
|
|
GELOGE(INTERNAL_ERROR,
|
|
"Failed to add node to in anchor,"
|
|
" the index %d for node %s, type %s is invalid",
|
|
node_index, node->GetName().c_str(), node->GetType().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
if (GraphUtils::AddEdge(new_out_anchor, in_anchor) != GRAPH_SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR,
|
|
"Failed to add edge between anchors,"
|
|
" new node %s, type %s",
|
|
node->GetName().c_str(), node->GetType().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
AddRePassNodesWithInOut(node);
|
|
return SUCCESS;
|
|
}
|
|
} // namespace ge
|