From 281fe39508b919a767ca7b80b88114f33c52ff05 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=8E=8B=E6=B6=9B?= Date: Thu, 25 Aug 2022 11:15:07 +0000 Subject: [PATCH 1/3] =?UTF-8?q?!632=20update=20submodule=20Merge=20pull=20?= =?UTF-8?q?request=20!632=20from=20=E7=8E=8B=E6=B6=9B/code=5Freview1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- metadef | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/metadef b/metadef index 5894aaa..5d062a3 160000 --- a/metadef +++ b/metadef @@ -1 +1 @@ -Subproject commit 5894aaa3c0cb12565e5e57a0a49f3e732e608f3d +Subproject commit 5d062a35640733026457c91966a558769570b0f8 From ba2067c447a1bbed1ffc39f19d1b3e66ad664387 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=96=9B=E9=B9=8F?= Date: Thu, 25 Aug 2022 13:40:01 +0000 Subject: [PATCH 2/3] =?UTF-8?q?!623=20=E4=BF=AE=E5=A4=8DPartitionedCall?= =?UTF-8?q?=E5=AD=90=E5=9B=BE=E4=B8=8A=E7=9A=84=E8=8A=82=E7=82=B9dump?= =?UTF-8?q?=E6=95=B0=E6=8D=AE=E6=97=A0=E6=B3=95=E6=AF=94=E5=AF=B9=E7=9A=84?= =?UTF-8?q?=E9=97=AE=E9=A2=98=20Merge=20pull=20request=20!623=20from=20?= =?UTF-8?q?=E8=96=9B=E9=B9=8F/bugfix?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- parser/tensorflow/tensorflow_parser.cc | 24 ++++---- tests/st/testcase/test_tensorflow_parser.cc | 66 ++++++++++++---------- .../tensorflow_parser_unittest.cc | 60 +++++++++++--------- 3 files changed, 85 insertions(+), 65 deletions(-) diff --git a/parser/tensorflow/tensorflow_parser.cc b/parser/tensorflow/tensorflow_parser.cc index 3e5fdf8..90373df 100644 --- a/parser/tensorflow/tensorflow_parser.cc +++ b/parser/tensorflow/tensorflow_parser.cc @@ -191,21 +191,25 @@ graphStatus aclgrphParseTensorFlow(const char *model_file, const std::map original_names; - auto parend_desc = parent_node->GetOpDesc(); - (void)ge::AttrUtils::GetListStr(parend_desc, ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); + (void)ge::AttrUtils::GetListStr(parent_node->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); if (original_names.empty()) { original_names.emplace_back(parent_node->GetName()); } // for fusion node also used original_names[0] - (void)original_names[0].append("/").append(subgraph_name).append("/").append(node->GetName()); - - if (!ge::AttrUtils::SetListStr(node->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names)) { - GELOGW("Set %s to %s fail.", ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES.c_str(), node->GetOpDesc()->GetName().c_str()); + std::string prefix = original_names[0].append("/").append(subgraph_name).append("/"); + for (const ge::NodePtr &node : graph->GetDirectNode()) { + original_names[0] = prefix + node->GetName(); + if (!ge::AttrUtils::SetListStr(node->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names)) { + GELOGW("Set dump origin name to %s fail.", node->GetOpDesc()->GetName().c_str()); + } + GELOGD("Add dump origin name %s for node %s.", original_names[0].c_str(), node->GetName().c_str()); } - GELOGD("Add dump origin name %s for node %s.", original_names[0].c_str(), node->GetName().c_str()); } } // namespace ge @@ -273,6 +277,7 @@ Status GenSubgraphParseTasks(const ge::ComputeGraphPtr &parent_graph, std::deque } Status PostOpProcessForSubgraph(const ParseArg &arg) { + AddDumpOriginName(arg.parent_node, arg.subgraph_name, arg.graph); if (arg.parent_node == nullptr) { return SUCCESS; } @@ -297,7 +302,6 @@ Status PostOpProcessForSubgraph(const ParseArg &arg) { if ((node->GetOpDesc() == nullptr) || (node->GetType() == "Variable") || (node->GetType() == "VariableV2")) { continue; } - AddDumpOriginName(arg.subgraph_name, arg.parent_node, node); node->GetOpDesc()->SetName(node->GetOwnerComputeGraph()->GetName() + "/" + node->GetName()); } diff --git a/tests/st/testcase/test_tensorflow_parser.cc b/tests/st/testcase/test_tensorflow_parser.cc index e6038a6..5b41752 100644 --- a/tests/st/testcase/test_tensorflow_parser.cc +++ b/tests/st/testcase/test_tensorflow_parser.cc @@ -158,7 +158,7 @@ void STestTensorflowParser::RegisterCustomOp() { domi::OpRegistry::Instance()->registrationDatas.clear(); } -extern void AddDumpOriginName(const std::string& subgraph_name, const ge::NodePtr parent_node, ge::NodePtr node); +void AddDumpOriginName(const ge::NodePtr parent_node, const std::string& subgraph_name, ge::ComputeGraphPtr graph); namespace { NodeDef* AddNode(GraphDef& graph, string type, string name) { @@ -4291,35 +4291,43 @@ TEST_F(STestTensorflowParser, tensorflow_optimizer_fmk_fusion_op) { TEST_F(STestTensorflowParser, AddDumpOriginName_test) { GeTensorDesc scalar_tensor(GeShape(), ge::FORMAT_NCHW, ge::DT_FLOAT); - ge::ComputeGraphPtr graph = std::make_shared("default"); - ge::OpDescPtr data_op = std::make_shared(); - data_op->SetType(parser::WHILE); - data_op->SetName("WHILE0"); - data_op->AddInputDesc(ge::GeTensorDesc()); - data_op->AddOutputDesc(ge::GeTensorDesc()); - ge::NodePtr while0 = graph->AddNode(data_op); - - data_op = std::make_shared(); - data_op->SetType(parser::LOOPCOND); - data_op->SetName("COND0"); - data_op->AddInputDesc(ge::GeTensorDesc()); - data_op->AddOutputDesc(ge::GeTensorDesc()); - ge::NodePtr cond0 = graph->AddNode(data_op); - AddDumpOriginName(std::string("while"), while0, cond0); - - data_op = std::make_shared(); - data_op->SetType(parser::DATA); - data_op->SetName("Data1"); - data_op->AddInputDesc(ge::GeTensorDesc()); - data_op->AddOutputDesc(ge::GeTensorDesc()); - ge::NodePtr data1 = graph->AddNode(data_op); - AddDumpOriginName(std::string("cond"), cond0, data1); - - auto desc = data1->GetOpDesc(); + ge::ComputeGraphPtr parent_graph = std::make_shared("parent_graph"); + ge::OpDescPtr parent = std::make_shared(); + parent->SetType("Foo"); + parent->SetName("foo"); + ge::NodePtr foo = parent_graph->AddNode(parent); + + + ge::ComputeGraphPtr sub_graph = std::make_shared("sub_graph"); + auto child = std::make_shared(); + child->SetType("Bar"); + child->SetName("bar"); + ge::NodePtr bar = sub_graph->AddNode(child); + + AddDumpOriginName(foo, "f", sub_graph); + std::vector original_names; - (void)ge::AttrUtils::GetListStr(desc, ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); - EXPECT_EQ(original_names.empty(), false); - EXPECT_EQ(original_names[0], "WHILE0/while/COND0/cond/Data1"); + (void)ge::AttrUtils::GetListStr(bar->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); + EXPECT_EQ(original_names.size(), 1U); + EXPECT_EQ(original_names[0], "foo/f/bar"); + + (void)ge::AttrUtils::SetListStr(foo->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); + AddDumpOriginName(foo, "f", sub_graph); + + original_names.clear(); + (void)ge::AttrUtils::GetListStr(bar->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); + EXPECT_EQ(original_names.size(), 1U); + EXPECT_EQ(original_names[0], "foo/f/bar/f/bar"); + + original_names.push_back("abc"); + (void)ge::AttrUtils::SetListStr(foo->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); + AddDumpOriginName(foo, "f", sub_graph); + + original_names.clear(); + (void)ge::AttrUtils::GetListStr(bar->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); + EXPECT_EQ(original_names.size(), 2U); + EXPECT_EQ(original_names[0], "foo/f/bar/f/bar/f/bar"); + EXPECT_EQ(original_names[1], "abc"); } } // namespace ge diff --git a/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc b/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc index b62338f..00678d8 100644 --- a/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc +++ b/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc @@ -169,7 +169,7 @@ static Status ParseParamByOpFunc(const ge::Operator &op_src, ge::Operator& op_de return SUCCESS; } -extern void AddDumpOriginName(const std::string& subgraph_name, const ge::NodePtr parent_node, ge::NodePtr node); +void AddDumpOriginName(const ge::NodePtr parent_node, const std::string& subgraph_name, ge::ComputeGraphPtr graph); void UtestTensorflowParser::RegisterCustomOp() { REGISTER_CUSTOM_OP("Add") @@ -4779,35 +4779,43 @@ TEST_F(UtestTensorflowParser, tensorflow_ComputeArgRange) TEST_F(UtestTensorflowParser, AddDumpOriginName_test) { GeTensorDesc scalar_tensor(GeShape(), ge::FORMAT_NCHW, ge::DT_FLOAT); - ge::ComputeGraphPtr graph = std::make_shared("default"); - ge::OpDescPtr data_op = std::make_shared(); - data_op->SetType(parser::WHILE); - data_op->SetName("WHILE0"); - data_op->AddInputDesc(ge::GeTensorDesc()); - data_op->AddOutputDesc(ge::GeTensorDesc()); - ge::NodePtr while0 = graph->AddNode(data_op); + ge::ComputeGraphPtr parent_graph = std::make_shared("parent_graph"); + ge::OpDescPtr parent = std::make_shared(); + parent->SetType("Foo"); + parent->SetName("foo"); + ge::NodePtr foo = parent_graph->AddNode(parent); - data_op = std::make_shared(); - data_op->SetType(parser::LOOPCOND); - data_op->SetName("COND0"); - data_op->AddInputDesc(ge::GeTensorDesc()); - data_op->AddOutputDesc(ge::GeTensorDesc()); - ge::NodePtr cond0 = graph->AddNode(data_op); - AddDumpOriginName(std::string("while"), while0, cond0); - data_op = std::make_shared(); - data_op->SetType(parser::DATA); - data_op->SetName("Data1"); - data_op->AddInputDesc(ge::GeTensorDesc()); - data_op->AddOutputDesc(ge::GeTensorDesc()); - ge::NodePtr data1 = graph->AddNode(data_op); - AddDumpOriginName(std::string("cond"), cond0, data1); + ge::ComputeGraphPtr sub_graph = std::make_shared("sub_graph"); + auto child = std::make_shared(); + child->SetType("Bar"); + child->SetName("bar"); + ge::NodePtr bar = sub_graph->AddNode(child); + + AddDumpOriginName(foo, "f", sub_graph); - auto desc = data1->GetOpDesc(); std::vector original_names; - (void)ge::AttrUtils::GetListStr(desc, ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); - EXPECT_EQ(original_names.empty(), false); - EXPECT_EQ(original_names[0], "WHILE0/while/COND0/cond/Data1"); + (void)ge::AttrUtils::GetListStr(bar->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); + EXPECT_EQ(original_names.size(), 1U); + EXPECT_EQ(original_names[0], "foo/f/bar"); + + (void)ge::AttrUtils::SetListStr(foo->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); + AddDumpOriginName(foo, "f", sub_graph); + + original_names.clear(); + (void)ge::AttrUtils::GetListStr(bar->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); + EXPECT_EQ(original_names.size(), 1U); + EXPECT_EQ(original_names[0], "foo/f/bar/f/bar"); + + original_names.push_back("abc"); + (void)ge::AttrUtils::SetListStr(foo->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); + AddDumpOriginName(foo, "f", sub_graph); + + original_names.clear(); + (void)ge::AttrUtils::GetListStr(bar->GetOpDesc(), ge::ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_names); + EXPECT_EQ(original_names.size(), 2U); + EXPECT_EQ(original_names[0], "foo/f/bar/f/bar/f/bar"); + EXPECT_EQ(original_names[1], "abc"); } } // namespace ge From bb90f11a02969a7b2446a143ae579e3643c0048f Mon Sep 17 00:00:00 2001 From: TangQunzhang Date: Thu, 25 Aug 2022 13:43:04 +0000 Subject: [PATCH 3/3] !631 Fix codecheck Merge pull request !631 from TangQunzhang/ge_dev --- parser/tensorflow/tensorflow_constant_parser.h | 2 +- parser/tensorflow/tensorflow_frameworkop_parser.cc | 2 +- .../tensorflow_fusion_custom_parser_adapter.cc | 2 +- parser/tensorflow/tensorflow_fusion_op_parser.cc | 16 ++--- parser/tensorflow/tensorflow_fusion_op_parser.h | 2 +- parser/tensorflow/tensorflow_merge_parser.cc | 2 +- parser/tensorflow/tensorflow_merge_parser.h | 2 +- parser/tensorflow/tensorflow_parser.cc | 20 ++++-- parser/tensorflow/tensorflow_parser_register.h | 2 +- parser/tensorflow/tensorflow_ref_switch_parser.cc | 4 +- parser/tensorflow/tensorflow_reshape_parser.cc | 13 ++-- parser/tensorflow/tensorflow_shape_n_parser.cc | 7 +- parser/tensorflow/tensorflow_squeeze_parser.cc | 21 +++--- parser/tensorflow/tensorflow_util.cc | 82 ++++++++++++---------- 14 files changed, 98 insertions(+), 79 deletions(-) diff --git a/parser/tensorflow/tensorflow_constant_parser.h b/parser/tensorflow/tensorflow_constant_parser.h index b961fbe..557db3d 100644 --- a/parser/tensorflow/tensorflow_constant_parser.h +++ b/parser/tensorflow/tensorflow_constant_parser.h @@ -21,9 +21,9 @@ #include "parser/common/data_op_parser.h" #include "parser/tensorflow/tensorflow_op_parser.h" +namespace ge { using domi::tensorflow::NodeDef; -namespace ge { class PARSER_FUNC_VISIBILITY TensorFlowConstantParser : public TensorFlowOpParser { public: Status ParseParams(const Message *op_src, ge::OpDescPtr &op_dest) override; diff --git a/parser/tensorflow/tensorflow_frameworkop_parser.cc b/parser/tensorflow/tensorflow_frameworkop_parser.cc index 36883c7..2d03c7b 100644 --- a/parser/tensorflow/tensorflow_frameworkop_parser.cc +++ b/parser/tensorflow/tensorflow_frameworkop_parser.cc @@ -31,7 +31,7 @@ namespace ge { Status ParseParams(const Message *op_src, FrameworkOpOperator *op) { GE_CHECK_NOTNULL(op_src); GE_CHECK_NOTNULL(op); - const domi::tensorflow::NodeDef *node = reinterpret_cast(op_src); + const domi::tensorflow::NodeDef *node = static_cast(op_src); GELOGD("TF op node name = %s, op type= %s, parse params", node->name().c_str(), node->op().c_str()); string type = node->op(); diff --git a/parser/tensorflow/tensorflow_fusion_custom_parser_adapter.cc b/parser/tensorflow/tensorflow_fusion_custom_parser_adapter.cc index 6c49409..33a2532 100644 --- a/parser/tensorflow/tensorflow_fusion_custom_parser_adapter.cc +++ b/parser/tensorflow/tensorflow_fusion_custom_parser_adapter.cc @@ -33,7 +33,7 @@ Status TensorFlowFusionCustomParserAdapter::ParseParams(const vector inside_nodes; for (auto inside_node : v_input_const) { GE_CHECK_NOTNULL(inside_node); - const google::protobuf::Message *node_src = reinterpret_cast(inside_node); + const google::protobuf::Message *node_src = dynamic_cast(inside_node); inside_nodes.push_back(node_src); } std::string ori_type = op_dest->GetType(); diff --git a/parser/tensorflow/tensorflow_fusion_op_parser.cc b/parser/tensorflow/tensorflow_fusion_op_parser.cc index 7225a4b..256b2c9 100644 --- a/parser/tensorflow/tensorflow_fusion_op_parser.cc +++ b/parser/tensorflow/tensorflow_fusion_op_parser.cc @@ -31,21 +31,21 @@ namespace ge { do { \ google::protobuf::RepeatedField val_vec; \ int32_t val_size = 0; \ - val_vec = (tensor).FIELD##_val(); \ + val_vec = (tensor).FIELD##_val(); \ val_size = val_vec.size(); \ - if ((index) < val_size) { \ - (param) = val_vec.Get(index); \ - } else if ((tensor).has_tensor_shape()) { \ - const std::string tensor_content = (tensor).tensor_content(); \ - char *buf = const_cast(tensor_content.data()); \ - FIELD *buf_v = reinterpret_cast(buf); \ + if ((index) < val_size) { \ + (param) = val_vec.Get(index); \ + } else if ((tensor).has_tensor_shape()) { \ + const std::string &tensor_content = (tensor).tensor_content(); \ + const char *buf = tensor_content.data(); \ + const FIELD *buf_v = reinterpret_cast(buf); \ if (static_cast(index) >= tensor_content.length() / sizeof(FIELD)) { \ REPORT_INNER_ERROR("E19999", "Const data size of node:%s is smaller than index:%d, not supported!", \ node_def->name().c_str(), index); \ GELOGE(domi::PARAM_INVALID, "Const data size is smaller than index :%d,not supported!", index); \ return domi::PARAM_INVALID; \ } \ - (param) = buf_v[index]; \ + (param) = buf_v[index]; \ } else { \ REPORT_INNER_ERROR("E19999", "Const data size of node:%s is smaller than index:%d, not supported!", \ node_def->name().c_str(), index); \ diff --git a/parser/tensorflow/tensorflow_fusion_op_parser.h b/parser/tensorflow/tensorflow_fusion_op_parser.h index 34b16a1..a2a1939 100644 --- a/parser/tensorflow/tensorflow_fusion_op_parser.h +++ b/parser/tensorflow/tensorflow_fusion_op_parser.h @@ -25,11 +25,11 @@ #include "proto/tensorflow/graph.pb.h" #include "proto/tensorflow/node_def.pb.h" +namespace ge { using google::protobuf::Message; using domi::tensorflow::NodeDef; using domi::tensorflow::TensorProto; -namespace ge { /** * @ingroup domi_omg * @brief Used to parse TensorFlow operator information diff --git a/parser/tensorflow/tensorflow_merge_parser.cc b/parser/tensorflow/tensorflow_merge_parser.cc index a3972c0..c20185f 100644 --- a/parser/tensorflow/tensorflow_merge_parser.cc +++ b/parser/tensorflow/tensorflow_merge_parser.cc @@ -39,7 +39,7 @@ Status TensorFlowMergeParser::ParseParams(const Message *op_src, ge::OpDescPtr & int32_t input_tensor_num = attr_num.i(); // add dynamic input - graphStatus ret = op_desc->AddDynamicInputDesc("x", input_tensor_num); + const graphStatus ret = op_desc->AddDynamicInputDesc("x", input_tensor_num); if (ret != GRAPH_SUCCESS) { REPORT_CALL_ERROR("E19999", "Add Dynamic InputDesc name:x to node:%s(%s) failed", op_desc->GetName().c_str(), op_desc->GetType().c_str()); diff --git a/parser/tensorflow/tensorflow_merge_parser.h b/parser/tensorflow/tensorflow_merge_parser.h index 7aa4549..1de5b92 100644 --- a/parser/tensorflow/tensorflow_merge_parser.h +++ b/parser/tensorflow/tensorflow_merge_parser.h @@ -25,4 +25,4 @@ class PARSER_FUNC_VISIBILITY TensorFlowMergeParser : public TensorFlowOpParser { Status ParseParams(const Message *op_src, ge::OpDescPtr &op_desc) override; }; } // namespace ge -#endif //_DOMI_OMG_PARSER_TENSORFLOW_TENSORFLOW_MERGE_PARSER_H_ +#endif // _DOMI_OMG_PARSER_TENSORFLOW_TENSORFLOW_MERGE_PARSER_H_ diff --git a/parser/tensorflow/tensorflow_parser.cc b/parser/tensorflow/tensorflow_parser.cc index 90373df..4d30749 100644 --- a/parser/tensorflow/tensorflow_parser.cc +++ b/parser/tensorflow/tensorflow_parser.cc @@ -913,8 +913,10 @@ Status TensorFlowModelParser::CheckOpType(const domi::tensorflow::NodeDef *node_ GE_IF_BOOL_EXEC( op_type == ge::parser::SPARSESOFTMAXCROSSENTROPYWITHLOGITS, GE_CHK_STATUS_RET(CheckOpShapeDim(node_def, check_dims[op_type], valid), "failed to check op shape"); - GE_IF_BOOL_EXEC(!valid, op_type = ge::parser::FRAMEWORKOP; GELOGI("Set op %s to frameworkop", node_name.c_str()); - framework_ops_[node_name] = node_def;);); + GE_IF_BOOL_EXEC(!valid, op_type = ge::parser::FRAMEWORKOP; + GELOGI("Set op %s to frameworkop", node_name.c_str()); + framework_ops_[node_name] = node_def;); + ); GE_IF_BOOL_EXEC( op_type == ge::parser::ADD || op_type == ge::parser::MULTIPLY || op_type == ge::parser::MEAN, @@ -974,7 +976,8 @@ Status TensorFlowModelParser::ParseNodeDef(TensorFlowModelParser *parser, ge::Co GELOGD("CCE %s parsering", node_op.c_str());); GE_IF_BOOL_EXEC((implyType == domi::ImplyType::HCCL) && (op_type != ge::parser::FRAMEWORKOP), GELOGD("HCCL %s parsering", node_op.c_str());); - GE_IF_BOOL_EXEC(op_type == ge::parser::FRAMEWORKOP, GELOGD("FRAMEWORKOP %s parsering", node_op.c_str());); + GE_IF_BOOL_EXEC(op_type == ge::parser::FRAMEWORKOP, + GELOGD("FRAMEWORKOP %s parsering", node_op.c_str());); GELOGD("TF op node name = %s, op type= %s, trans to op type %s", node_name.c_str(), node_op.c_str(), op_type.c_str()); // Construct operator by IR @@ -2326,7 +2329,8 @@ Status TensorFlowModelParser::ParseProto(const google::protobuf::Message *proto, // Loop analysis of op_nodes and map them to nodes in graph ret = AddFmkNode(graph, scope_graph, op_node_name_list, isDatasetInit); PARSER_TIMESTAMP_END(AddFmkNode, "TensorFlowModelParser::AddFmkNode"); - GE_CHK_STATUS_EXEC(ret, DeleteFuisonNodeDef(); return ret, "AddFmkNode failed"); + GE_CHK_STATUS_EXEC(ret, DeleteFuisonNodeDef(); + return ret, "AddFmkNode failed"); GELOGD("[TF Parser] Add framework node success"); ret = AddEdges(graph); @@ -3008,12 +3012,16 @@ Status TensorFlowModelParser::GetFormatTranspose(const NodeDef *transpose_node, GE_IF_BOOL_EXEC( type == domi::tensorflow::DT_INT32, const int32_t *data = reinterpret_cast(tensor.tensor_content().data()); - for (int i = 0; i < parser::DIM_DEFAULT_SIZE; i++) { perm_value.push_back(data[i]); }); + for (int i = 0; i < parser::DIM_DEFAULT_SIZE; i++) { + perm_value.push_back(data[i]); + }); GE_IF_BOOL_EXEC( type == domi::tensorflow::DT_INT64, const int64_t *data = reinterpret_cast(tensor.tensor_content().data()); - for (int i = 0; i < parser::DIM_DEFAULT_SIZE; i++) { perm_value.push_back(data[i]); }); + for (int i = 0; i < parser::DIM_DEFAULT_SIZE; i++) { + perm_value.push_back(data[i]); + }); // 0, 1, 2, 3 present dim num. vector perm_to_nchw = {0, 3, 1, 2}; diff --git a/parser/tensorflow/tensorflow_parser_register.h b/parser/tensorflow/tensorflow_parser_register.h index cf2abd1..10c78f2 100644 --- a/parser/tensorflow/tensorflow_parser_register.h +++ b/parser/tensorflow/tensorflow_parser_register.h @@ -61,7 +61,7 @@ class PARSER_FUNC_VISIBILITY TensorflowParserBuilder : public TensorflowWeightPa public: using ParseParamsFn = std::function; - explicit TensorflowParserBuilder(const std::string &davinci_optype) : davinci_optype_(davinci_optype) {} + explicit TensorflowParserBuilder(const std::string &davinci_optype) noexcept : davinci_optype_(davinci_optype) {} ~TensorflowParserBuilder() override {} diff --git a/parser/tensorflow/tensorflow_ref_switch_parser.cc b/parser/tensorflow/tensorflow_ref_switch_parser.cc index d311b7d..f2f8840 100644 --- a/parser/tensorflow/tensorflow_ref_switch_parser.cc +++ b/parser/tensorflow/tensorflow_ref_switch_parser.cc @@ -40,8 +40,8 @@ Status TensorFlowRefSwitchParser::ParseT(const domi::tensorflow::NodeDef *node, GE_RETURN_WITH_LOG_IF_ERROR(TensorFlowUtil::CheckAttrHasType(attr, "type"), "check Attr T failed"); - domi::tensorflow::DataType tfType = attr.type(); - ge::DataType type = domi::TensorAssign::ConvertTensorflowDataType(tfType); + const domi::tensorflow::DataType tfType = attr.type(); + const ge::DataType type = domi::TensorAssign::ConvertTensorflowDataType(tfType); CHECK_FALSE_EXEC(type != ge::DataType::DT_UNDEFINED, REPORT_CALL_ERROR("E19999", "Data type %s of node %s is not supported", DataType_Name(tfType).c_str(), diff --git a/parser/tensorflow/tensorflow_reshape_parser.cc b/parser/tensorflow/tensorflow_reshape_parser.cc index 4c57cc4..52efc0b 100644 --- a/parser/tensorflow/tensorflow_reshape_parser.cc +++ b/parser/tensorflow/tensorflow_reshape_parser.cc @@ -34,26 +34,29 @@ Status TensorFlowReshapeParser::ParseDesc(const domi::tensorflow::AttrValue &att auto a_list = attr_value.list(); GE_CHK_BOOL_RET_STATUS(TensorFlowUtil::ParseFromAttrValueList(ge_desc, a_list, 0, tf_datatype), PARAM_INVALID, "parse ge_desc failed."); - uint32_t size_type = 1; + uint32_t size_type = 1U; auto data_type = ge_desc.GetDataType(); bool type_ret = ge::TypeUtils::GetDataTypeLength(data_type, size_type); GE_IF_BOOL_EXEC(!type_ret, REPORT_CALL_ERROR("E19999", "Data type %s is not supported", ge::TypeUtils::DataTypeToSerialString(data_type).c_str()); - GELOGE(FAILED, "Can't GetDataTypeLength of data_type: %s", + GELOGE(FAILED, "Can't GetDataTypeLength of data_type: %s.", ge::TypeUtils::DataTypeToSerialString(data_type).c_str()); return PARAM_INVALID); // calculate size int64_t real_size = 1; - for (uint32_t j = 0; j < ge_desc.GetShape().GetDimNum(); ++j) { + for (uint32_t j = 0U; j < ge_desc.GetShape().GetDimNum(); ++j) { int64_t tmp_dim = ge_desc.GetShape().GetDim(j); - GE_IF_BOOL_EXEC(tmp_dim < 0, real_size = tmp_dim * (-1) * real_size; continue;); + if (tmp_dim < 0) { + real_size = tmp_dim * (-1) * real_size; + continue; + } real_size *= tmp_dim; } PARSER_INT64_MULCHECK(real_size, size_type); ge::TensorUtils::SetSize(ge_desc, real_size * size_type); ge::TensorUtils::SetRealDimCnt(ge_desc, ge_desc.GetShape().GetDimNum()); - GELOGI("after translate tf_desc, datatype: %s, format: %s, real size: %ld, size_type: %u", + GELOGI("After translate tf_desc, datatype: %s, format: %s, real size: %ld, size_type: %u", ge::TypeUtils::DataTypeToSerialString(ge_desc.GetDataType()).c_str(), ge::TypeUtils::FormatToSerialString(ge_desc.GetFormat()).c_str(), real_size * size_type, size_type); return SUCCESS; diff --git a/parser/tensorflow/tensorflow_shape_n_parser.cc b/parser/tensorflow/tensorflow_shape_n_parser.cc index 3b3f5e3..7530bc8 100644 --- a/parser/tensorflow/tensorflow_shape_n_parser.cc +++ b/parser/tensorflow/tensorflow_shape_n_parser.cc @@ -83,7 +83,8 @@ Status TensorFlowShapeNParser::ParseN(const domi::tensorflow::NodeDef *node, Sha // The upper caller guarantees the input params is not empty. domi::tensorflow::AttrValue attr; const int64_t attr_n = 2; - CHECK_FALSE_EXEC(TensorFlowUtil::FindAttrValue(node, SHAPEN_ATTR_N, attr), op->N(attr_n); return SUCCESS); + CHECK_FALSE_EXEC(TensorFlowUtil::FindAttrValue(node, SHAPEN_ATTR_N, attr), op->N(attr_n); + return SUCCESS); GE_RETURN_WITH_LOG_IF_ERROR(TensorFlowUtil::CheckAttrHasType(attr, "int"), "check Attr N failed"); @@ -133,7 +134,7 @@ Status TensorFlowShapeNParser::ParseParams(const Message *op_src, ge::OpDescPtr if (ret != SUCCESS) { return ret; } - graphStatus status = op_dest->AddDynamicOutputDesc("y", dynamic_tensor_num); + const graphStatus status = op_dest->AddDynamicOutputDesc("y", dynamic_tensor_num); if (status != GRAPH_SUCCESS) { REPORT_CALL_ERROR("E19999", "Add Dynamic OuputDesc name:y to node:%s(%s) failed", op_dest->GetName().c_str(), op_dest->GetType().c_str()); @@ -141,7 +142,7 @@ Status TensorFlowShapeNParser::ParseParams(const Message *op_src, ge::OpDescPtr return FAILED; } } - graphStatus status = op_dest->AddDynamicInputDesc("x", dynamic_tensor_num); + const graphStatus status = op_dest->AddDynamicInputDesc("x", dynamic_tensor_num); if (status != GRAPH_SUCCESS) { REPORT_CALL_ERROR("E19999", "Add Dynamic InputDesc name:x to node:%s(%s) failed", op_dest->GetName().c_str(), op_dest->GetType().c_str()); diff --git a/parser/tensorflow/tensorflow_squeeze_parser.cc b/parser/tensorflow/tensorflow_squeeze_parser.cc index 6d16213..9da16b5 100644 --- a/parser/tensorflow/tensorflow_squeeze_parser.cc +++ b/parser/tensorflow/tensorflow_squeeze_parser.cc @@ -38,27 +38,30 @@ Status TensorFlowSqueezeParser::ParseDesc(const domi::tensorflow::AttrValue &att auto a_list = attr_value.list(); GE_CHK_BOOL_RET_STATUS(TensorFlowUtil::ParseFromAttrValueList(ge_desc, a_list, 0, tf_datatype), domi::PARAM_INVALID, "parse ge_desc failed."); - uint32_t size_type; - auto data_type = ge_desc.GetDataType(); - bool type_ret = ge::TypeUtils::GetDataTypeLength(data_type, size_type); + uint32_t size_type = 0U; + const auto data_type = ge_desc.GetDataType(); + const bool type_ret = ge::TypeUtils::GetDataTypeLength(data_type, size_type); GE_IF_BOOL_EXEC(!type_ret, REPORT_CALL_ERROR("E19999", "Data type %s is not supported", ge::TypeUtils::DataTypeToSerialString(data_type).c_str()); - GELOGE(domi::PARAM_INVALID, "Can't GetDataTypeLength of data_type: %s", + GELOGE(domi::PARAM_INVALID, "Can't GetDataTypeLength of data_type: %s.", ge::TypeUtils::DataTypeToSerialString(data_type).c_str()); return domi::PARAM_INVALID); // calculate size int64_t real_size = 1; - for (uint32_t j = 0; j < ge_desc.GetShape().GetDimNum(); ++j) { + for (uint32_t j = 0U; j < ge_desc.GetShape().GetDimNum(); ++j) { int64_t tmp_dim = ge_desc.GetShape().GetDim(j); - GE_IF_BOOL_EXEC(tmp_dim < 0, real_size = tmp_dim * (-1) * real_size; continue;); + if (tmp_dim < 0) { + real_size = tmp_dim * (-1) * real_size; + continue; + } PARSER_INT64_MULCHECK(real_size, tmp_dim); real_size *= tmp_dim; } PARSER_INT64_MULCHECK(real_size, size_type); ge::TensorUtils::SetSize(ge_desc, real_size * size_type); ge::TensorUtils::SetRealDimCnt(ge_desc, ge_desc.GetShape().GetDimNum()); - GELOGD("after translate tf_desc, datatype: %s, format: %s, real size: %ld, size_type: %u", + GELOGD("After translate tf_desc, datatype: %s, format: %s, real size: %ld, size_type: %u", ge::TypeUtils::DataTypeToSerialString(ge_desc.GetDataType()).c_str(), ge::TypeUtils::FormatToSerialString(ge_desc.GetFormat()).c_str(), real_size * size_type, size_type); return SUCCESS; @@ -80,8 +83,8 @@ Status TensorFlowSqueezeParser::ParseParams(const Message *op_src, ge::OpDescPtr domi::tensorflow::AttrValue axis; domi::tensorflow::AttrValue dims; - bool has_axis = TensorFlowUtil::FindAttrValue(node, SQUEEZE_ATTR_AXIS, axis); - bool has_dims = TensorFlowUtil::FindAttrValue(node, SQUEEZE_ATTR_DIMS, dims); + const bool has_axis = TensorFlowUtil::FindAttrValue(node, SQUEEZE_ATTR_AXIS, axis); + const bool has_dims = TensorFlowUtil::FindAttrValue(node, SQUEEZE_ATTR_DIMS, dims); if (!has_axis && !has_dims) { return SUCCESS; } diff --git a/parser/tensorflow/tensorflow_util.cc b/parser/tensorflow/tensorflow_util.cc index 4c05f89..1def5cc 100644 --- a/parser/tensorflow/tensorflow_util.cc +++ b/parser/tensorflow/tensorflow_util.cc @@ -30,6 +30,25 @@ using domi::tensorflow::DT_INVALID; +#define VALIDATE_FIELD(attr_value, type, num_set, name, type_string, oneof_case) \ + do { \ + if ((attr_value).has_list()) { \ + if ((attr_value).list().name##_size() > 0) { \ + if (type != "list(" type_string ")") { \ + GELOGE(FAILED, "GeAttrValue had value with type 'list(" type_string ")'when '%s' expected", type.c_str()); \ + return FAILED; \ + } \ + ++(num_set); \ + } \ + } else if ((attr_value).value_case() == domi::tensorflow::AttrValue::oneof_case) { \ + if (type != (type_string)) { \ + GELOGE(FAILED, "GeAttrValue had value with type '" type_string "' when '%s' expected", type.c_str()); \ + return FAILED; \ + } \ + ++(num_set); \ + } \ + } while (false) + namespace ge { /***************************TensorFlow attribute type, constant definition*******************************************/ const std::string TENSORFLOW_ATTR_TYPE_STRING = "string"; @@ -126,7 +145,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool TensorFlowUtil::FindAttrVa GE_CHECK_NOTNULL(node_def); const google::protobuf::Map &attr = node_def->attr(); const google::protobuf::Map::const_iterator it = attr.find(attr_name); - if (it != attr.end()) { + if (it != attr.cend()) { attr_value = it->second; return true; } @@ -136,34 +155,15 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool TensorFlowUtil::FindAttrVa FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY domi::Status TensorFlowUtil::CheckAttrHasType( const domi::tensorflow::AttrValue &attr_value, const std::string &type) { - uint32_t num_set = 0; -#define VALIDATE_FIELD(name, type_string, oneof_case) \ - do { \ - if (attr_value.has_list()) { \ - if (attr_value.list().name##_size() > 0) { \ - if (type != "list(" type_string ")") { \ - GELOGE(FAILED, "GeAttrValue had value with type 'list(" type_string ")'when '%s' expected", type.c_str()); \ - return FAILED; \ - } \ - ++num_set; \ - } \ - } else if (attr_value.value_case() == domi::tensorflow::AttrValue::oneof_case) { \ - if (type != (type_string)) { \ - GELOGE(FAILED, "GeAttrValue had value with type '" type_string "' when '%s' expected", type.c_str()); \ - return FAILED; \ - } \ - ++num_set; \ - } \ - } while (false) - - VALIDATE_FIELD(s, "string", kS); - VALIDATE_FIELD(i, "int", kI); - VALIDATE_FIELD(f, "float", kF); - VALIDATE_FIELD(b, "bool", kB); - VALIDATE_FIELD(type, "type", kType); - VALIDATE_FIELD(shape, "shape", kShape); - VALIDATE_FIELD(tensor, "tensor", kTensor); - VALIDATE_FIELD(func, "func", kFunc); + uint32_t num_set = 0U; + VALIDATE_FIELD(attr_value, type, num_set, s, "string", kS); + VALIDATE_FIELD(attr_value, type, num_set, i, "int", kI); + VALIDATE_FIELD(attr_value, type, num_set, f, "float", kF); + VALIDATE_FIELD(attr_value, type, num_set, b, "bool", kB); + VALIDATE_FIELD(attr_value, type, num_set, type, "type", kType); + VALIDATE_FIELD(attr_value, type, num_set, shape, "shape", kShape); + VALIDATE_FIELD(attr_value, type, num_set, tensor, "tensor", kTensor); + VALIDATE_FIELD(attr_value, type, num_set, func, "func", kFunc); #undef VALIDATE_FIELD @@ -173,7 +173,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY domi::Status TensorFlowUtil::Ch } // Okay to have an empty list, but not to be missing a non-list value. - if ((num_set == 0) && (!ge::StringUtils::StartWith(type, "list("))) { + if ((num_set == 0U) && (!ge::StringUtils::StartWith(type, "list("))) { GELOGE(FAILED, "GeAttrValue missing value with expected type '%s'", type.c_str()); return FAILED; } @@ -210,7 +210,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY domi::Status TensorFlowUtil::Pa const domi::tensorflow::NodeDef *node_src, const std::string &attr_src, domi::tensorflow::DataType &data_type) { GE_CHECK_NOTNULL(node_src); - std::string node_name = node_src->name(); + const std::string &node_name = node_src->name(); // Find the value of attr_src from node_src domi::tensorflow::AttrValue attr_value; @@ -236,7 +236,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool TensorFlowUtil::ParseFromA ge_desc.SetOriginFormat(ge::FORMAT_ND); tf_datatype = a_list.func(i).attr().at(SERIALIZE_DATATYPE).i(); - ge::DataType type = domi::TensorAssign::ConvertTensorflowDataType(tf_datatype); + const ge::DataType type = domi::TensorAssign::ConvertTensorflowDataType(tf_datatype); GE_CHK_BOOL_RET_STATUS(type != ge::DataType::DT_UNDEFINED, PARAM_INVALID, "In FrameworkOp translate datatype:%d failed, domi cann't support.", tf_datatype); ge_desc.SetDataType(type); @@ -266,21 +266,25 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY domi::Status TensorFlowUtil::Tr int32_t tf_datatype = 0; GE_CHK_BOOL_RET_STATUS(ParseFromAttrValueList(ge_desc, a_list, i, tf_datatype), PARAM_INVALID, "parse ge_desc failed."); - uint32_t size_type = 1; + uint32_t size_type = 1U; auto data_type = ge_desc.GetDataType(); GE_CHK_BOOL_RET_STATUS(ge::TypeUtils::GetDataTypeLength(data_type, size_type), PARAM_INVALID, "dataType no define size , parse ge_desc failed."); // get size - for (uint32_t j = 0; j < ge_desc.GetShape().GetDimNum(); ++j) { + for (uint32_t j = 0U; j < ge_desc.GetShape().GetDimNum(); ++j) { int64_t tmp_dim = ge_desc.GetShape().GetDim(j); - // The shape infered by fusedbatchnormgrad and mean calling tensorflow is not accurate. // Here, special treatment is given to the two operators. // Adjust shape to fit resnet50 network only. - GE_IF_BOOL_EXEC((type == ge::parser::FUSEDBATCHNORMGRAD) && (tmp_dim == 0), ge_desc.SetShape(ge::GeShape()); - break;); - GE_IF_BOOL_EXEC((type == ge::parser::MEAN) && (tmp_dim == 0), std::vector data_dim = {tmp_dim}; - ge_desc.SetShape(ge::GeShape(data_dim)); break;); + if ((type == ge::parser::FUSEDBATCHNORMGRAD) && (tmp_dim == 0)) { + ge_desc.SetShape(ge::GeShape()); + break; + } + if ((type == ge::parser::MEAN) && (tmp_dim == 0)) { + std::vector data_dim = {tmp_dim}; + ge_desc.SetShape(ge::GeShape(data_dim)); + break; + } } ge::TensorUtils::SetRealDimCnt(ge_desc, ge_desc.GetShape().GetDimNum()); GELOGD("IO:%d: after translate tf_desc, datatype: %s, format: %s, size_type: %u", io,