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.
812 lines
33 KiB
812 lines
33 KiB
/**
|
|
* Copyright 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/variable_op_pass.h"
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "common/formats/formats.h"
|
|
#include "common/formats/utils/formats_trans_utils.h"
|
|
#include "graph/ge_context.h"
|
|
#include "graph/graph.h"
|
|
#include "graph/manager/graph_var_manager.h"
|
|
#include "graph/utils/graph_utils.h"
|
|
#include "graph/utils/tensor_utils.h"
|
|
#include "graph/utils/type_utils.h"
|
|
|
|
namespace ge {
|
|
namespace {
|
|
const int kTransOpOutIndex = 0;
|
|
|
|
Status ByPassTransNode(NodePtr &front_node, NodePtr &back_node) {
|
|
GE_CHECK_NOTNULL(front_node);
|
|
GE_CHECK_NOTNULL(back_node);
|
|
GELOGD("Begin to bypass trans node %s", front_node->GetName().c_str());
|
|
auto ret = GraphUtils::CopyInCtrlEdges(front_node, back_node);
|
|
if (ret != GRAPH_SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR,
|
|
"Failed to move control edges from trans "
|
|
"node %s to var-ref %s",
|
|
front_node->GetName().c_str(), back_node->GetName().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
auto back_node_in_anchor = back_node->GetInDataAnchor(0);
|
|
if (back_node_in_anchor == nullptr) {
|
|
GELOGE(INTERNAL_ERROR,
|
|
"The back node %s does not have an "
|
|
"input anchor",
|
|
back_node->GetName().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
back_node_in_anchor->UnlinkAll();
|
|
auto trans_in_anchor = front_node->GetInDataAnchor(0);
|
|
if (trans_in_anchor == nullptr) {
|
|
GELOGE(INTERNAL_ERROR,
|
|
"Failed to get the in data anchor from trans"
|
|
" node %s type %s",
|
|
front_node->GetName().c_str(), front_node->GetType().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
auto prev_trans_node_out_anchor = trans_in_anchor->GetPeerOutAnchor();
|
|
if (prev_trans_node_out_anchor == nullptr) {
|
|
GELOGW(
|
|
"The trans node %s does not have an input, so the ref node %s does"
|
|
" not have any inputs after bypass",
|
|
front_node->GetName().c_str(), front_node->GetName().c_str());
|
|
} else {
|
|
ret = GraphUtils::AddEdge(prev_trans_node_out_anchor, back_node_in_anchor);
|
|
if (ret != GRAPH_SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR,
|
|
"Failed to add edge between ref node %s "
|
|
"and the prev node of trans node %s",
|
|
back_node->GetName().c_str(), front_node->GetName().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
bool IsTransSupport(const TransNodeInfo &trans_info) {
|
|
if (trans_info.output.GetShape().IsUnknownShape()) {
|
|
return false;
|
|
}
|
|
if (trans_info.node_type == RESHAPE || trans_info.node_type == REFORMAT) {
|
|
return true;
|
|
} else if (trans_info.node_type == TRANSDATA || trans_info.node_type == TRANSPOSED) {
|
|
formats::TransArgs args{nullptr,
|
|
trans_info.input.GetFormat(),
|
|
trans_info.output.GetFormat(),
|
|
trans_info.input.GetShape().GetDims(),
|
|
trans_info.output.GetShape().GetDims(),
|
|
trans_info.input.GetDataType()};
|
|
return formats::IsTransFormatSupport(args);
|
|
} else if (trans_info.node_type == CAST) {
|
|
formats::CastArgs datatype_args{nullptr, static_cast<size_t>(trans_info.input.GetShape().GetShapeSize()),
|
|
trans_info.input.GetDataType(), trans_info.output.GetDataType()};
|
|
return formats::IsTransDataTypeSupport(datatype_args);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
std::string GetInAndOutDecsDiff(NodePtr &trans_node, bool reverse = false) {
|
|
int tran_in_index = TransOpUtil::GetTransOpDataIndex(trans_node->GetType());
|
|
auto op_desc = trans_node->GetOpDesc();
|
|
GeTensorDesc input_desc = op_desc->GetInputDesc(tran_in_index);
|
|
GeTensorDesc output_desc = op_desc->GetOutputDesc(kTransOpOutIndex);
|
|
if (reverse) {
|
|
GeTensorDesc tmp_desc = input_desc;
|
|
input_desc = output_desc;
|
|
output_desc = tmp_desc;
|
|
}
|
|
auto input_format = input_desc.GetFormat();
|
|
auto input_type = input_desc.GetDataType();
|
|
auto input_shape = input_desc.GetShape();
|
|
auto output_format = output_desc.GetFormat();
|
|
auto output_type = output_desc.GetDataType();
|
|
auto output_shape = output_desc.GetShape();
|
|
std::stringstream diff_key;
|
|
diff_key.str("");
|
|
if (input_format != output_format) {
|
|
diff_key << static_cast<int>(input_format) << '-' << static_cast<int>(output_format) << '-';
|
|
} else {
|
|
diff_key << "*-";
|
|
}
|
|
if (input_type != output_type) {
|
|
diff_key << static_cast<int>(input_type) << '-' << static_cast<int>(output_type) << '-';
|
|
} else {
|
|
diff_key << "*-";
|
|
}
|
|
if (!ge::formats::IsShapeEqual(input_shape, output_shape)) {
|
|
for (auto dim : input_shape.GetDims()) {
|
|
diff_key << dim << '-';
|
|
}
|
|
for (auto dim : output_shape.GetDims()) {
|
|
diff_key << dim << '-';
|
|
}
|
|
} else {
|
|
diff_key << "*";
|
|
}
|
|
return diff_key.str();
|
|
}
|
|
} // namespace
|
|
|
|
Status VariableOpPass::Run(ge::ComputeGraphPtr graph) {
|
|
if (graph == nullptr) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to run variable op pass, null graph");
|
|
return INTERNAL_ERROR;
|
|
}
|
|
|
|
GELOGD("Begin to run variable op pass on graph %s, session %lu, graph id %u", graph->GetName().c_str(),
|
|
GetContext().SessionId(), graph->GetGraphID());
|
|
|
|
if (var_accelerate_ctrl_ == nullptr) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to run var op pass, the variable accelerate control is null");
|
|
return INTERNAL_ERROR;
|
|
}
|
|
|
|
GELOGD("Begin to generate ref map for variable and refs, graph name:%s.", graph->GetName().c_str());
|
|
if (RenewVarDesc(graph) != SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to renew var desc on graph");
|
|
return GE_GRAPH_VARIABLE_OP_PASS_FAILED;
|
|
}
|
|
|
|
if (GenerateVariableVariableRefMap(graph) != SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to generate variable map for graph %s", graph->GetName().c_str());
|
|
return GE_GRAPH_VARIABLE_OP_PASS_FAILED;
|
|
}
|
|
|
|
GELOGD("Begin to fusion variables and trans nodes");
|
|
for (auto &var_to_refs : var_and_var_ref_map_) {
|
|
auto &node = var_to_refs.first;
|
|
GE_CHECK_NOTNULL(node);
|
|
GE_CHECK_NOTNULL(var_accelerate_ctrl_);
|
|
if (!var_accelerate_ctrl_->IsVarPermitToChangeFormats(node->GetName())) {
|
|
GELOGD("The var %s does not permit to change formats, skip it", node->GetName().c_str());
|
|
continue;
|
|
}
|
|
|
|
VarTransRoad fusion_road;
|
|
auto ret = FusionIfNeed(node, fusion_road);
|
|
if (ret != SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
if (fusion_road.empty()) {
|
|
GELOGD("No need to fusion variable %s because it's fusion road is empty", node->GetName().c_str());
|
|
continue;
|
|
}
|
|
|
|
ret = RenewTransRoadDesc(node, fusion_road);
|
|
if (ret != SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to renew description fusion road for var %s", node->GetName().c_str());
|
|
return GE_GRAPH_VARIABLE_OP_PASS_FAILED;
|
|
}
|
|
|
|
auto start_iter = fusion_road.begin();
|
|
auto end_iter = fusion_road.rbegin();
|
|
GELOGD(
|
|
"Trans variable data for %s from format %s to %s, shape %s to %s "
|
|
"data-type %s to %s, path len %zu success",
|
|
node->GetName().c_str(), TypeUtils::FormatToSerialString(start_iter->input.GetFormat()).c_str(),
|
|
TypeUtils::FormatToSerialString(end_iter->output.GetFormat()).c_str(),
|
|
formats::ShapeToString(start_iter->input.GetShape().GetDims()).c_str(),
|
|
formats::ShapeToString(end_iter->output.GetShape().GetDims()).c_str(),
|
|
TypeUtils::DataTypeToSerialString(start_iter->input.GetDataType()).c_str(),
|
|
TypeUtils::DataTypeToSerialString(end_iter->output.GetDataType()).c_str(), fusion_road.size());
|
|
|
|
ret = VarManager::Instance(graph->GetSessionID())->SetTransRoad(node->GetName(), fusion_road);
|
|
if (ret != SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to update the format fusion road for var %s", node->GetName().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
ret = VarManager::Instance(graph->GetSessionID())->SetChangedGraphId(node->GetName(), graph->GetGraphID());
|
|
if (ret != SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to update the graph id for var %s", node->GetName().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
var_accelerate_ctrl_->SetVarChanged(node->GetName());
|
|
|
|
GELOGD("Begin to update format info for var %s.", node->GetName().c_str());
|
|
std::set<ge::NodePtr> node_set({node});
|
|
if (UpdateIOFormatInfo(end_iter->output, node_set) != SUCCESS) {
|
|
return GE_GRAPH_VARIABLE_OP_PASS_FAILED;
|
|
}
|
|
|
|
// renew var desc if the trans_road is all reshape or reformat
|
|
ret = RenewVarDesc(graph->GetSessionID(), node, fusion_road);
|
|
if (ret != SUCCESS) {
|
|
GELOGE(FAILED, "var manager renew var[%s] descriptor failed!", node->GetName().c_str());
|
|
return FAILED;
|
|
}
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::RenewTransRoadDesc(const NodePtr &var, VarTransRoad &fusion_road) {
|
|
auto var_desc = var->GetOpDesc();
|
|
GE_CHECK_NOTNULL(var_desc);
|
|
TransNodeInfo prev_node_info;
|
|
prev_node_info.node_type = var->GetType();
|
|
prev_node_info.output = var_desc->GetOutputDesc(0);
|
|
// two cases
|
|
// fisrt Var->cast->transdata which transdata in fusion road
|
|
// the input of transdata is not equal with output of var
|
|
// case 1 : suppose input dtype of transdata equal with out dtype
|
|
// but not equal with var
|
|
// so we make input dtype and output dytpe of transroad equal with var
|
|
// case 2: suppose input format of transdata not equal with out format
|
|
// and input format not equal with var
|
|
// so we make input format equal with var
|
|
for (auto &cur_trans : fusion_road) {
|
|
if (cur_trans.input.GetFormat() == cur_trans.output.GetFormat()) {
|
|
cur_trans.output.SetFormat(prev_node_info.output.GetFormat());
|
|
}
|
|
if (cur_trans.input.GetDataType() == cur_trans.output.GetDataType()) {
|
|
cur_trans.output.SetDataType(prev_node_info.output.GetDataType());
|
|
}
|
|
if (ge::formats::IsShapeEqual(cur_trans.input.GetShape(), cur_trans.output.GetShape())) {
|
|
cur_trans.output.SetShape(prev_node_info.output.GetShape());
|
|
}
|
|
cur_trans.input = prev_node_info.output;
|
|
prev_node_info.output = cur_trans.output;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::FusionIfNeed(const NodePtr &var, VarTransRoad &fusion_road) {
|
|
bool can_fusion = false;
|
|
while (true) {
|
|
map<string, vector<NodePtr>> trans_type_to_trans_ops ;
|
|
map<string, pair<string, bool>> trans_type_to_changed_desc;
|
|
// record the order of trans op in first path
|
|
vector<string> first_path_trans_order;
|
|
auto ret = CheckIfCouldBeOptimized(var, first_path_trans_order, trans_type_to_changed_desc,
|
|
trans_type_to_trans_ops, can_fusion);
|
|
if (ret != SUCCESS) {
|
|
GELOGE(FAILED, "Check trans ops after vatiable could be optimized or not failed");
|
|
return ret;
|
|
}
|
|
|
|
if (!can_fusion) {
|
|
break;
|
|
}
|
|
|
|
vector<pair<NodePtr, NodePtr>> delete_var_ref_trans_nodes;
|
|
ret = GetAndCheckTransOpOfVarRef(var, can_fusion, trans_type_to_changed_desc, delete_var_ref_trans_nodes);
|
|
if (ret != SUCCESS) {
|
|
GELOGE(FAILED, "get and check trans op of varref failed");
|
|
return ret;
|
|
}
|
|
|
|
if (!can_fusion) {
|
|
break;
|
|
}
|
|
|
|
ret = UpdateTransRoad(fusion_road, first_path_trans_order,
|
|
trans_type_to_changed_desc, trans_type_to_trans_ops);
|
|
if (ret != SUCCESS) {
|
|
GELOGE(FAILED, "Update trans road failed");
|
|
return ret;
|
|
}
|
|
|
|
if (fusion_road.empty()) {
|
|
return SUCCESS;
|
|
}
|
|
|
|
ret = DealFusion(var, fusion_road, trans_type_to_changed_desc,
|
|
trans_type_to_trans_ops, delete_var_ref_trans_nodes);
|
|
if (ret != SUCCESS) {
|
|
return ret;
|
|
}
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::UpdateTransRoad(VarTransRoad &fusion_road, vector<std::string> &first_path_trans_order,
|
|
map<std::string, std::pair<std::string, bool>> &trans_type_to_changed_desc,
|
|
map<std::string, vector<NodePtr>> &trans_type_to_trans_ops){
|
|
vector<std::string> delete_trans_type;
|
|
for (auto &trans_type : first_path_trans_order) {
|
|
if (trans_type_to_changed_desc.find(trans_type) == trans_type_to_changed_desc.end()) {
|
|
continue;
|
|
}
|
|
bool delete_flag = false;
|
|
for (auto &trans_node : trans_type_to_trans_ops[trans_type]) {
|
|
int tran_in_index = TransOpUtil::GetTransOpDataIndex(trans_node->GetType());
|
|
auto out_op_desc = trans_node->GetOpDesc();
|
|
GE_CHECK_NOTNULL(out_op_desc);
|
|
TransNodeInfo trans_node_info;
|
|
trans_node_info.node_type = trans_node->GetType();
|
|
trans_node_info.input = out_op_desc->GetInputDesc(tran_in_index);
|
|
trans_node_info.output = out_op_desc->GetOutputDesc(kTransOpOutIndex);
|
|
if (!IsTransSupport(trans_node_info)) {
|
|
delete_flag = true;
|
|
GELOGD("The trans node %s does not support, skip the variable accelerating", trans_node_info.node_type.c_str());
|
|
break;
|
|
}
|
|
}
|
|
if (delete_flag) {
|
|
delete_trans_type.push_back(trans_type);
|
|
} else {
|
|
auto &trans_node = *trans_type_to_trans_ops[trans_type].begin();
|
|
auto out_op_desc = trans_node->GetOpDesc();
|
|
int tran_in_index = TransOpUtil::GetTransOpDataIndex(trans_node->GetType());
|
|
TransNodeInfo trans_node_info;
|
|
trans_node_info.node_type = trans_node->GetType();
|
|
trans_node_info.input = out_op_desc->GetInputDesc(tran_in_index);
|
|
trans_node_info.output = out_op_desc->GetOutputDesc(kTransOpOutIndex);
|
|
fusion_road.emplace_back(trans_node_info);
|
|
}
|
|
}
|
|
for (auto &trans_type : delete_trans_type) {
|
|
trans_type_to_changed_desc.erase(trans_type);
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::DealFusion(const ge::NodePtr &var_node, VarTransRoad &fusion_road,
|
|
map<std::string, std::pair<std::string, bool>> trans_type_to_changed_desc,
|
|
map<std::string, vector<NodePtr>> trans_type_to_trans_ops,
|
|
vector<pair<NodePtr, NodePtr>> &delete_trans_nodes) {
|
|
GE_CHECK_NOTNULL(var_node);
|
|
GELOGD("Begin to fusion var %s with trans", var_node->GetName().c_str());
|
|
auto graph = var_node->GetOwnerComputeGraph();
|
|
for (auto &trans_type : trans_type_to_changed_desc) {
|
|
for (auto &trans_node : trans_type_to_trans_ops[trans_type.first]) {
|
|
GELOGD("Remove node %s type %s when fusion with variable %s", trans_node->GetName().c_str(),
|
|
trans_node->GetType().c_str(), var_node->GetName().c_str());
|
|
if (RenewTransOpDesc(trans_node, true) != SUCCESS) {
|
|
return GE_GRAPH_VARIABLE_OP_PASS_FAILED;
|
|
}
|
|
|
|
if (GraphUtils::IsolateNode(trans_node, {0}) != SUCCESS) {
|
|
return GE_GRAPH_VARIABLE_OP_PASS_FAILED;
|
|
}
|
|
|
|
if (GraphUtils::RemoveNodeWithoutRelink(graph, trans_node) != SUCCESS) {
|
|
return GE_GRAPH_VARIABLE_OP_PASS_FAILED;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Iterate delete_trans_nodes backward, eg a->b->c, delete_trans_nodes:{{b,c},{a,b}}
|
|
// we should delete {a,b} first , then b->c,then we can delete {b,c}
|
|
// if we delete {b,c} first, then a->c, then we can not get b when we delete {a,b}
|
|
for (auto iter = delete_trans_nodes.rbegin(); iter != delete_trans_nodes.rend(); ++iter) {
|
|
auto front_node = iter->first;
|
|
auto back_node = iter->second;
|
|
if (RenewTransOpDesc(front_node, false) != SUCCESS) {
|
|
return GE_GRAPH_VARIABLE_OP_PASS_FAILED;
|
|
}
|
|
if (front_node->GetOutDataNodes().size() > 1) {
|
|
GELOGD("The trans node %s type %s connecting with var-ref %s has more"
|
|
" than one output data nodes, unlink the edge between them",
|
|
front_node->GetName().c_str(), front_node->GetType().c_str(), back_node->GetName().c_str());
|
|
if (ByPassTransNode(front_node, back_node) != SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to bypass trans node %s to node %s", front_node->GetName().c_str(),
|
|
back_node->GetName().c_str());
|
|
return INTERNAL_ERROR;
|
|
}
|
|
} else {
|
|
GELOGD("The trans node %s type %s connecting with %s has only"
|
|
" one output data nodes, isolate and remove it.",
|
|
front_node->GetName().c_str(), front_node->GetType().c_str(), back_node->GetName().c_str());
|
|
if (GraphUtils::IsolateNode(front_node, {0}) != SUCCESS) {
|
|
return GE_GRAPH_VARIABLE_OP_PASS_FAILED;
|
|
}
|
|
if (GraphUtils::RemoveNodeWithoutRelink(graph, front_node) != SUCCESS) {
|
|
return GE_GRAPH_VARIABLE_OP_PASS_FAILED;
|
|
}
|
|
}
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::RenewTransOpDesc(ge::NodePtr &node, bool is_reverse) {
|
|
int tran_in_index = TransOpUtil::GetTransOpDataIndex(node->GetType());
|
|
auto op_desc = node->GetOpDesc();
|
|
GE_CHECK_NOTNULL(op_desc);
|
|
GeTensorDesc input_desc = op_desc->GetInputDesc(tran_in_index);
|
|
GeTensorDesc output_desc = op_desc->GetOutputDesc(kTransOpOutIndex);
|
|
GeTensorDesc renew_desc = is_reverse ? output_desc : input_desc;
|
|
bool format_changed = false;
|
|
bool shape_changed = false;
|
|
bool dtype_changed = false;
|
|
if (input_desc.GetFormat() != output_desc.GetFormat()) {
|
|
format_changed = true;
|
|
}
|
|
if (input_desc.GetDataType() != output_desc.GetDataType()) {
|
|
dtype_changed = true;
|
|
}
|
|
if (!ge::formats::IsShapeEqual(input_desc.GetShape(), output_desc.GetShape())) {
|
|
shape_changed = true;
|
|
}
|
|
auto cur_node = node;
|
|
while (TransOpUtil::IsTransOp(cur_node)) {
|
|
tran_in_index = TransOpUtil::GetTransOpDataIndex(cur_node->GetType());
|
|
auto next_node = is_reverse ? NodeUtils::GetInDataNodeByIndex(*cur_node, tran_in_index) :
|
|
cur_node->GetOutDataNodes().at(kTransOpOutIndex);
|
|
if (!TransOpUtil::IsTransOp(next_node)) {
|
|
break;
|
|
}
|
|
auto prev_desc = next_node->GetOpDesc();
|
|
tran_in_index = TransOpUtil::GetTransOpDataIndex(next_node->GetType());
|
|
auto mutable_output_desc = prev_desc->MutableOutputDesc(kTransOpOutIndex);
|
|
auto mutable_input_desc = prev_desc->MutableInputDesc(tran_in_index);
|
|
GE_CHECK_NOTNULL(prev_desc->MutableOutputDesc(kTransOpOutIndex));
|
|
GE_CHECK_NOTNULL(prev_desc->MutableInputDesc(tran_in_index));
|
|
if (shape_changed) {
|
|
mutable_input_desc->SetShape(renew_desc.GetShape());
|
|
mutable_output_desc->SetShape(renew_desc.GetShape());
|
|
}
|
|
if (dtype_changed) {
|
|
mutable_input_desc->SetDataType(renew_desc.GetDataType());
|
|
mutable_output_desc->SetDataType(renew_desc.GetDataType());
|
|
}
|
|
if (format_changed) {
|
|
mutable_input_desc->SetFormat(renew_desc.GetFormat());
|
|
mutable_output_desc->SetFormat(renew_desc.GetFormat());
|
|
}
|
|
cur_node = next_node;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::CheckIfCouldBeOptimized(const NodePtr &var, vector<string> &first_path_trans_order,
|
|
map<string, pair<string, bool>> &trans_type_to_changed_desc,
|
|
map<string, vector<NodePtr>> &trans_type_to_trans_ops, bool &flag) {
|
|
bool is_match = true;
|
|
auto ret = GetSameTransOP(var, first_path_trans_order, trans_type_to_changed_desc,
|
|
trans_type_to_trans_ops, is_match);
|
|
|
|
if (ret != SUCCESS) {
|
|
GELOGE(FAILED, "Get same trans op of variable node: %s failed", var->GetName().c_str());
|
|
return GE_GRAPH_VARIABLE_OP_PASS_FAILED;
|
|
}
|
|
|
|
if (!is_match) {
|
|
flag = false;
|
|
GELOGI("trans nodes after variable do not meet the condition");
|
|
return SUCCESS;
|
|
}
|
|
|
|
flag = true;
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::GetSameTransOP(const NodePtr &var, vector<string> &first_path_trans_order,
|
|
map<string, pair<string, bool>> &trans_type_to_changed_desc,
|
|
map<string, vector<NodePtr>> &trans_type_to_trans_ops, bool &is_match) {
|
|
GELOGD("Begin to get Node: %s trans op info of first path", var->GetName().c_str());
|
|
auto ret = GetFisrtPathTransInfo(var, first_path_trans_order,
|
|
trans_type_to_changed_desc, trans_type_to_trans_ops);
|
|
if (ret != SUCCESS) {
|
|
GELOGE(FAILED, "Get var: %s first path trans info failed", var->GetName().c_str());
|
|
return FAILED;
|
|
}
|
|
|
|
if (first_path_trans_order.empty()) {
|
|
GELOGD("var %s first path has no trans op, not need to pass", var->GetName().c_str());
|
|
is_match = false;
|
|
return SUCCESS;
|
|
}
|
|
|
|
GELOGD("Begin to depth first search Node: %s ", var->GetName().c_str());
|
|
VariableDFS(var, trans_type_to_changed_desc, trans_type_to_trans_ops, is_match);
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
void VariableOpPass::VariableDFS(const NodePtr &node, map<string, pair<string, bool>> &trans_type_to_changed_desc,
|
|
map<string, vector<NodePtr>> &trans_type_to_trans_ops, bool &is_match) {
|
|
std::stack<NodePtr> node_stack;
|
|
std::stack<vector<NodePtr>> path_stack;
|
|
for (auto &out_node : node->GetOutDataNodes()) {
|
|
if (!is_match) {
|
|
break;
|
|
}
|
|
if (out_node->GetOutDataNodesSize() == 0 || !ge::TransOpUtil::IsTransOp(out_node)) {
|
|
is_match = false;
|
|
break;
|
|
}
|
|
node_stack.push(out_node);
|
|
path_stack.emplace(vector<NodePtr>{out_node});
|
|
while (!node_stack.empty() && is_match) {
|
|
auto cur_node = node_stack.top();
|
|
auto cur_path = path_stack.top();
|
|
node_stack.pop();
|
|
path_stack.pop();
|
|
if (cur_node->GetOutDataNodesSize() == 0 || !ge::TransOpUtil::IsTransOp(cur_node)) {
|
|
UpdateTransInfo(cur_path, is_match, trans_type_to_changed_desc, trans_type_to_trans_ops);
|
|
continue;
|
|
}
|
|
for (auto &next_node : cur_node->GetOutDataNodes()) {
|
|
node_stack.push(next_node);
|
|
auto next_path = cur_path;
|
|
next_path.push_back(next_node);
|
|
path_stack.emplace(next_path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Status VariableOpPass::UpdateTransInfo(vector<NodePtr> &cur_path, bool& is_match,
|
|
map<string, pair<string, bool>> &trans_type_to_changed_desc,
|
|
map<string, vector<NodePtr>> &trans_type_to_trans_ops) {
|
|
GELOGD("Begin to update trans info by path");
|
|
std::set<string> trans_op_occured;
|
|
for (auto &trans_node : cur_path) {
|
|
auto trans_node_type = trans_node->GetType();
|
|
if (trans_op_occured.find(trans_node_type) != trans_op_occured.end() ||
|
|
!ge::TransOpUtil::IsTransOp(trans_node_type)) {
|
|
continue;
|
|
}
|
|
trans_op_occured.insert(trans_node_type);
|
|
auto desc_diff = GetInAndOutDecsDiff(trans_node);
|
|
if (trans_type_to_changed_desc.find(trans_node_type) != trans_type_to_changed_desc.end() &&
|
|
desc_diff == trans_type_to_changed_desc[trans_node_type].first) {
|
|
trans_type_to_changed_desc[trans_node_type].second = true;
|
|
auto iter = find(trans_type_to_trans_ops[trans_node_type].begin(),
|
|
trans_type_to_trans_ops[trans_node_type].end(),
|
|
trans_node);
|
|
if (iter == trans_type_to_trans_ops[trans_node_type].end()) {
|
|
trans_type_to_trans_ops[trans_node_type].push_back(trans_node);
|
|
}
|
|
}
|
|
}
|
|
std::set<string> delete_trans_types;
|
|
for (auto &trans_item : trans_type_to_changed_desc) {
|
|
if (!trans_item.second.second) {
|
|
delete_trans_types.insert(trans_item.first);
|
|
} else {
|
|
trans_item.second.second = false;
|
|
}
|
|
}
|
|
for (auto& delete_item : delete_trans_types) {
|
|
trans_type_to_changed_desc.erase(delete_item);
|
|
}
|
|
if (trans_type_to_changed_desc.empty()) {
|
|
is_match = false;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::GetFisrtPathTransInfo(const NodePtr &var, vector<string> &first_path_trans_order,
|
|
map<string, pair<string, bool>> &trans_type_to_changed_desc,
|
|
map<string, vector<NodePtr>> &trans_type_to_trans_ops) {
|
|
auto cur_node = var;
|
|
while (cur_node->GetOutDataNodesSize() != 0) {
|
|
cur_node = cur_node->GetOutDataNodes().at(0);
|
|
GE_CHECK_NOTNULL(cur_node);
|
|
if (!ge::TransOpUtil::IsTransOp(cur_node)) {
|
|
break;
|
|
}
|
|
auto cur_node_type = cur_node->GetType();
|
|
// only get the the first occurrence operator of same type
|
|
if (trans_type_to_changed_desc.find(cur_node_type) == trans_type_to_changed_desc.end()) {
|
|
auto desc_diff = GetInAndOutDecsDiff(cur_node);
|
|
trans_type_to_changed_desc[cur_node->GetType()] = make_pair(desc_diff, false);
|
|
trans_type_to_trans_ops[cur_node->GetType()] = vector<NodePtr>{cur_node};
|
|
first_path_trans_order.push_back(cur_node->GetType());
|
|
}
|
|
}
|
|
GELOGD("get var %s first path trans info success", var->GetName().c_str());
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::GetAndCheckTransOpOfVarRef(const ge::NodePtr &var_node, bool &pass_check,
|
|
map<string, pair<string, bool>> &trans_type_to_changed_desc,
|
|
vector<pair<NodePtr, NodePtr>> &delete_var_ref_trans_nodes) {
|
|
auto iterator = var_and_var_ref_map_.find(var_node);
|
|
if (iterator == var_and_var_ref_map_.end()) {
|
|
GELOGD("there is no var_ref of node %s", var_node->GetName().c_str());
|
|
return SUCCESS;
|
|
}
|
|
vector<string> delete_trans_type;
|
|
for (auto &trans_type : trans_type_to_changed_desc) {
|
|
delete_trans_type.push_back(trans_type.first);
|
|
}
|
|
for (auto &ref_node : iterator->second) {
|
|
GE_CHECK_NOTNULL(ref_node);
|
|
auto cur_node = *ref_node->GetInDataNodes().begin();
|
|
auto behind_node = ref_node;
|
|
GE_CHECK_NOTNULL(cur_node);
|
|
vector<string> tmp_delete_trans_type = delete_trans_type;
|
|
while (TransOpUtil::IsTransOp(cur_node)) {
|
|
GE_CHECK_NOTNULL(cur_node);
|
|
auto iter = find(tmp_delete_trans_type.begin(), tmp_delete_trans_type.end(), cur_node->GetType());
|
|
if (iter != tmp_delete_trans_type.end()) {
|
|
CheckTransOpOfVarAndVarRefSymmetry(cur_node, trans_type_to_changed_desc[cur_node->GetType()].first,
|
|
pass_check);
|
|
if (!pass_check) {
|
|
GELOGD("trans op : %s of var ref %s is illegal", cur_node->GetName().c_str(), ref_node->GetName().c_str());
|
|
return SUCCESS;
|
|
}
|
|
tmp_delete_trans_type.erase(iter);
|
|
delete_var_ref_trans_nodes.emplace_back(std::make_pair(cur_node, behind_node));
|
|
}
|
|
int tran_in_index = TransOpUtil::GetTransOpDataIndex(cur_node->GetType());
|
|
behind_node = cur_node;
|
|
cur_node = cur_node->GetInDataNodes().at(tran_in_index);
|
|
}
|
|
if (!tmp_delete_trans_type.empty()) {
|
|
pass_check = false;
|
|
return SUCCESS;
|
|
}
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::CheckTransOpOfVarAndVarRefSymmetry(NodePtr &var_ref_trans_op, const string &desc_diff,
|
|
bool &is_symmetry){
|
|
auto var_ref_trans_op_desc_diff = GetInAndOutDecsDiff(var_ref_trans_op, true);
|
|
is_symmetry = (var_ref_trans_op_desc_diff == desc_diff);
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::UpdateVarAndRefOutputFormatInfo(const GeTensorDesc &final_output, const ge::NodePtr &node) {
|
|
if (node == nullptr || node->GetOpDesc() == nullptr) {
|
|
GELOGE(FAILED, "node or opdesc is nullptr");
|
|
return FAILED;
|
|
}
|
|
const Format &format = final_output.GetFormat();
|
|
const DataType &data_type = final_output.GetDataType();
|
|
const GeShape &shape = final_output.GetShape();
|
|
GELOGD("last ref is (%s, %s, %lu), var_ref_name is %s.", TypeUtils::DataTypeToSerialString(data_type).c_str(),
|
|
TypeUtils::FormatToSerialString(format).c_str(), shape.GetDims().size(), node->GetName().c_str());
|
|
|
|
auto node_desc = node->GetOpDesc()->GetOutputDesc(0);
|
|
CopyVariableFormatDataTypeAndShape(final_output, node_desc);
|
|
if (node->GetOpDesc()->UpdateOutputDesc(0, node_desc) != GRAPH_SUCCESS) {
|
|
GELOGE(FAILED, "update output desc fail.");
|
|
return FAILED;
|
|
}
|
|
GELOGD("node ref is (%s, %s, %lu), var_ref_name is %s.",
|
|
TypeUtils::DataTypeToSerialString(node->GetOpDesc()->GetOutputDesc(0).GetDataType()).c_str(),
|
|
TypeUtils::FormatToSerialString(node->GetOpDesc()->GetOutputDesc(0).GetFormat()).c_str(),
|
|
node->GetOpDesc()->GetOutputDesc(0).GetShape().GetDims().size(), node->GetName().c_str());
|
|
|
|
auto iterator = var_and_var_ref_map_.find(node);
|
|
if (iterator == var_and_var_ref_map_.end()) {
|
|
auto graph = node->GetOwnerComputeGraph();
|
|
if (GenerateVariableVariableRefMap(graph) != SUCCESS) {
|
|
GELOGE(INTERNAL_ERROR, "Failed to generate variable map for graph %s", graph->GetName().c_str());
|
|
return GE_GRAPH_VARIABLE_OP_PASS_FAILED;
|
|
}
|
|
}
|
|
iterator = var_and_var_ref_map_.find(node);
|
|
if (iterator == var_and_var_ref_map_.end()) {
|
|
GELOGW("The var node %s which belongs to graph %s can not be found on the graph", node->GetName().c_str(),
|
|
node->GetOwnerComputeGraph()->GetName().c_str());
|
|
return SUCCESS;
|
|
}
|
|
|
|
for (const auto &var_ref_node : iterator->second) {
|
|
auto var_ref_node_description = var_ref_node->GetOpDesc();
|
|
GE_CHECK_NOTNULL(var_ref_node_description);
|
|
|
|
GELOGD("var_ref_node before is (%s, %s, %zu), var_ref_name is %s.",
|
|
TypeUtils::DataTypeToSerialString(data_type).c_str(), TypeUtils::FormatToSerialString(format).c_str(),
|
|
shape.GetDims().size(), var_ref_node->GetName().c_str());
|
|
if (var_ref_node_description->UpdateOutputDesc(0, node_desc) != GRAPH_SUCCESS) {
|
|
GELOGW("UpdateOutputDesc fail.");
|
|
}
|
|
if (var_ref_node_description->UpdateInputDesc(0, node_desc) != GRAPH_SUCCESS) {
|
|
GELOGW("UpdateInputDesc fail.");
|
|
}
|
|
const auto &input_desc = var_ref_node_description->MutableInputDesc(0);
|
|
const auto &output_desc = var_ref_node_description->MutableOutputDesc(0);
|
|
GE_CHECK_NOTNULL(input_desc);
|
|
GE_CHECK_NOTNULL(output_desc);
|
|
GELOGD("var_ref_node ref is (%s, %s, %zu), var_ref_name is %s.",
|
|
TypeUtils::DataTypeToSerialString(input_desc->GetDataType()).c_str(),
|
|
TypeUtils::FormatToSerialString(input_desc->GetFormat()).c_str(), output_desc->GetShape().GetDims().size(),
|
|
var_ref_node->GetName().c_str());
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::GenerateVariableVariableRefMap(const ComputeGraphPtr &compute_graph) {
|
|
std::map<std::string, NodePtr> names_to_var;
|
|
std::map<std::string, std::set<NodePtr>> names_to_refs;
|
|
GE_CHECK_NOTNULL(compute_graph);
|
|
for (auto &node : compute_graph->GetDirectNode()) {
|
|
if (node->GetType() != VARIABLE) {
|
|
continue;
|
|
}
|
|
std::string ref_var_name;
|
|
if (!ge::AttrUtils::GetStr(node->GetOpDesc(), REF_VAR_SRC_VAR_NAME, ref_var_name)) {
|
|
names_to_var[node->GetName()] = node;
|
|
} else {
|
|
names_to_refs[ref_var_name].insert(node);
|
|
}
|
|
}
|
|
|
|
for (auto &name_to_var : names_to_var) {
|
|
var_and_var_ref_map_[name_to_var.second] = names_to_refs[name_to_var.first];
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
void VariableOpPass::CopyVariableFormatDataTypeAndShape(const GeTensorDesc &src_tensor_desc,
|
|
GeTensorDesc &dst_tensor_desc) {
|
|
dst_tensor_desc.SetShape(src_tensor_desc.GetShape());
|
|
dst_tensor_desc.SetFormat(src_tensor_desc.GetFormat());
|
|
dst_tensor_desc.SetDataType(src_tensor_desc.GetDataType());
|
|
}
|
|
|
|
Status VariableOpPass::UpdateIOFormatInfo(const GeTensorDesc &final_output, std::set<NodePtr> &nodes) {
|
|
for (auto &need_set_node : nodes) {
|
|
auto ret = UpdateVarAndRefOutputFormatInfo(final_output, need_set_node);
|
|
if (ret != SUCCESS) {
|
|
return GE_GRAPH_VARIABLE_OP_PASS_FAILED;
|
|
}
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::RenewVarDesc(ge::ComputeGraphPtr &graph) {
|
|
GE_CHECK_NOTNULL(graph);
|
|
// renew var manager desc
|
|
Status ret = SUCCESS;
|
|
for (auto &node : graph->GetDirectNode()) {
|
|
bool is_var_node =
|
|
(node->GetType() == VARIABLE) || (node->GetType() == VARIABLEV2) || (node->GetType() == VARHANDLEOP);
|
|
if (is_var_node) {
|
|
if (!ge::VarManager::Instance(graph->GetSessionID())->IsVarExist(node->GetName())) {
|
|
GELOGD("var manager does not exist var node[%s]", node->GetName().c_str());
|
|
continue;
|
|
}
|
|
GELOGD("var manager exist var node[%s], graph name[%s]", node->GetName().c_str(), graph->GetName().c_str());
|
|
GE_CHECK_NOTNULL(node->GetOpDesc());
|
|
ret = ge::VarManager::Instance(graph->GetSessionID())->RenewCurVarDesc(node->GetName(), node->GetOpDesc());
|
|
if (ret != SUCCESS) {
|
|
GELOGE(FAILED, "var manager renew var[%s] descriptor failed!", node->GetName().c_str());
|
|
return FAILED;
|
|
}
|
|
}
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
Status VariableOpPass::RenewVarDesc(uint64_t session_id, const NodePtr &node, const VarTransRoad &fusion_road) {
|
|
// renew var desc if the trans_road is all reshape or reformat
|
|
for (auto &road : fusion_road) {
|
|
if (road.node_type != RESHAPE && road.node_type != REFORMAT) {
|
|
return SUCCESS;
|
|
}
|
|
}
|
|
|
|
if (!ge::VarManager::Instance(session_id)->IsVarExist(node->GetName())) {
|
|
GELOGD("var manager does not exist var node[%s]", node->GetName().c_str());
|
|
return SUCCESS;
|
|
}
|
|
GELOGD("var manager exist var node[%s]", node->GetName().c_str());
|
|
GE_CHECK_NOTNULL(node->GetOpDesc());
|
|
Status ret = ge::VarManager::Instance(session_id)->RenewCurVarDesc(node->GetName(), node->GetOpDesc());
|
|
if (ret != SUCCESS) {
|
|
GELOGE(FAILED, "var manager renew var[%s] descriptor failed!", node->GetName().c_str());
|
|
return FAILED;
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
} // namespace ge
|