From 685eb9dcc3f6fffade2b56fae0155017666a3fca Mon Sep 17 00:00:00 2001 From: jwx930962 Date: Sat, 11 Dec 2021 09:43:02 +0800 Subject: [PATCH 1/2] parser st testcase --- tests/st/testcase/origin_models/caffe.proto | 3 + tests/st/testcase/test_tensorflow_parser.cc | 275 ++++++++++++++++++++ 2 files changed, 278 insertions(+) create mode 100644 tests/st/testcase/origin_models/caffe.proto diff --git a/tests/st/testcase/origin_models/caffe.proto b/tests/st/testcase/origin_models/caffe.proto new file mode 100644 index 0000000..def265a --- /dev/null +++ b/tests/st/testcase/origin_models/caffe.proto @@ -0,0 +1,3 @@ +{ + "a": "b" +} \ No newline at end of file diff --git a/tests/st/testcase/test_tensorflow_parser.cc b/tests/st/testcase/test_tensorflow_parser.cc index bae85ba..3d6322f 100644 --- a/tests/st/testcase/test_tensorflow_parser.cc +++ b/tests/st/testcase/test_tensorflow_parser.cc @@ -58,6 +58,13 @@ #include "common/op_def/fill_op.h" #include "common/convert/pb2json.h" #include "common/convert/message2operator.h" +#include "parser/common/proto_file_parser.h" +#include "parser/common/pre_checker.h" +#include "parser/common/tbe_plugin_loader.h" +#include "parser/common/data_op_parser.h" +#include "parser/common/model_saver.h" +#include "framework/omg/parser/parser_api.h" +#include "parser/common/parser_fp16_t.h" #undef protected #undef private @@ -3377,4 +3384,272 @@ TEST_F(STestTensorflowParser, tensorflow_Pb2Json_OneField2Json_test) delete field; } +TEST_F(STestTensorflowParser, input_proto_real_path_success) { + const char *caffe_proto_path = "./caffe/caffe.proto"; + const char *custom_proto_path = "./caffe/custom.proto"; + ProtoFileParser proto_file_parser; + string fusion_proto_file; + auto ret = proto_file_parser.CombineProtoFile(caffe_proto_path, custom_proto_path, fusion_proto_file); + EXPECT_EQ(ret, FAILED); + + ret = proto_file_parser.RecordProtoMessage(caffe_proto_path); + EXPECT_EQ(ret, FAILED); + + ret = proto_file_parser.WriteProtoFile(caffe_proto_path, custom_proto_path); + EXPECT_EQ(ret, FAILED); + + std::cout << __FILE__ << std::endl; + std::string caseDir = __FILE__; + std::size_t idx = caseDir.find_last_of("/"); + caseDir = caseDir.substr(0, idx); + std::string proto_file = caseDir + "/origin_models/caffe.proto"; + caffe_proto_path = proto_file.c_str(); + ret = proto_file_parser.CombineProtoFile(caffe_proto_path, caffe_proto_path, fusion_proto_file); + EXPECT_EQ(ret, SUCCESS); + + ret = proto_file_parser.WriteProtoFile(caffe_proto_path, custom_proto_path); + EXPECT_EQ(ret, FAILED); + + std::string dest_line = "test"; + ret = proto_file_parser.FindConflictLine(custom_proto_path, 0, dest_line); + EXPECT_EQ(ret, FAILED); + + std::map> identifier_op_map; + std::map> op_identifier_map; + ret = proto_file_parser.ParseProtoFile(custom_proto_path, identifier_op_map, op_identifier_map); + EXPECT_EQ(ret, FAILED); + + proto_file_parser.GetFusionProtoFile(); + + std::ofstream write_tmp; + ret = proto_file_parser.AddCustomAndConflictMessage(custom_proto_path, write_tmp); + EXPECT_EQ(ret, FAILED); +} + +TEST_F(STestTensorflowParser, all_success) +{ + PreChecker::OpId id1 = (void*)(intptr_t)1; + PreChecker::OpId id2 = (void*)(intptr_t)2; + PreChecker::OpId id3 = (void*)(intptr_t)3; + PreChecker::OpId id4 = (void*)(intptr_t)4; + PreChecker &checker = PreChecker::Instance(); + + EXPECT_EQ(checker.AddOp(id1, "name1", "type1"), SUCCESS); + EXPECT_EQ(checker.AddOp(id2, "name2", "type2"), SUCCESS); + EXPECT_EQ(checker.AddOp(id3, "name1", "type3"), SUCCESS); + EXPECT_EQ(checker.AddOp(id4, "name4", ge::parser::DETECTIONOUTPUT), SUCCESS); + + EXPECT_EQ(checker.CheckName(id1), SUCCESS); + EXPECT_EQ(checker.CheckName(id2), SUCCESS); + EXPECT_EQ(checker.CheckName(id3), SUCCESS); + EXPECT_EQ(checker.CheckName(id4), SUCCESS); + + EXPECT_EQ(checker.CheckType(id1), SUCCESS); + EXPECT_EQ(checker.CheckType(id2), SUCCESS); + EXPECT_EQ(checker.CheckType(id3), SUCCESS); + EXPECT_EQ(checker.CheckType(id4), SUCCESS); + + EXPECT_EQ(checker.AddCause(id1, PreChecker::ErrorCode::OK, "msg"), SUCCESS); + EXPECT_EQ(checker.AddCause(id1, PreChecker::ErrorCode::PARAM_INVALID, "msg"), domi::SUCCESS); + + PreChecker::Cause cause; + cause.code = PreChecker::ErrorCode::TYPE_AMBIGUOUS; + cause.message = "msg"; + EXPECT_EQ(checker.AddCause(id1, cause), SUCCESS); + EXPECT_EQ(checker.HasError(), true); + EXPECT_EQ(checker.Save("check_result.json"), SUCCESS); + + std::string msg = "msg"; + Status ret = checker.Clear(id1, msg); + EXPECT_EQ(ret, SUCCESS); + + checker.Clear(); + checker.RefreshErrorMessageByName("name1",PreChecker::ErrorCode::PARAM_INVALID,"node repeated in"); +} + +TEST_F(STestTensorflowParser, tensorflow_tbe_tfplugin_loader_test) +{ + TBEPluginLoader pluginLoad; + vector fileList = {}; + string caffeParserPath = ""; + string full_name = "dabc"; + string caffe_parser_so_suff = "abc"; + pluginLoad.ProcessSoFullName(fileList, caffeParserPath, full_name, caffe_parser_so_suff); + ASSERT_EQ(caffeParserPath, full_name); + + pluginLoad.ClearHandles_(); + + std::cout << __FILE__ << std::endl; + std::string caseDir = __FILE__; + std::size_t idx = caseDir.find_last_of("/"); + caseDir = caseDir.substr(0, idx); + std::string proto_file = caseDir + "/origin_models/caffe.proto"; + std::string path = proto_file; + std::string caffe_parser_path = path; + pluginLoad.FindParserSo(path, fileList, caffe_parser_path); + + Status ret = pluginLoad.Finalize(); + EXPECT_EQ(ret, SUCCESS); +} + +TEST_F(STestTensorflowParser, tensorflow_data_op_parser_test) +{ + std::vector shape = {1, 1, 224, 224}; + ge::GeTensorDesc tensor_desc; + DataOpParser opParser; + Status ret = opParser.Init5DInputTensor(shape, tensor_desc); + EXPECT_EQ(ret, SUCCESS); + + ret = opParser.Init5DOutputTensor(shape, tensor_desc); + EXPECT_EQ(ret, SUCCESS); + + ge::OpDescPtr op = std::make_shared(); + ret = opParser.ParseShape(shape, op); +} + +TEST_F(STestTensorflowParser, read_proto_from_mem_test) +{ + tensorflow::NodeDef *node_def = initNodeDef(); + const char *data = nullptr; + int size = 3; + bool ret = parser::ReadProtoFromMem(data, size, node_def); + EXPECT_EQ(false, ret); + + data = "not file"; + ret = parser::ReadProtoFromMem(data, size, node_def); + EXPECT_EQ(false, ret); +} + +TEST_F(STestTensorflowParser, tensorflow_GetOriginalType_test) +{ + ge::ComputeGraphPtr graph = std::make_shared(GRAPH_DEFAULT_NAME); + ge::OpDescPtr op = std::make_shared("fusionCustom", parser::FRAMEWORKOP); + ge::NodePtr node = std::make_shared(op, graph); + string type = parser::FRAMEWORKOP; + Status ret = parser::GetOriginalType(node, type); + EXPECT_EQ(ret, INTERNAL_ERROR); +} + +TEST_F(STestTensorflowParser, tensorflow_ReadBytesFromBinaryFile_test) +{ + const char *file_name = nullptr; + char *buffer = nullptr; + int length = 1; + bool ret = parser::ReadBytesFromBinaryFile(file_name, &buffer, length); + EXPECT_EQ(ret, false); + + file_name = "./caffe.proto"; + ret = parser::ReadBytesFromBinaryFile(file_name, &buffer, length); + EXPECT_EQ(ret, false); + + std::cout << __FILE__ << std::endl; + std::string caseDir = __FILE__; + std::size_t idx = caseDir.find_last_of("/"); + caseDir = caseDir.substr(0, idx); + std::string proto_file = caseDir + "/origin_models/caffe.proto"; + file_name = proto_file.c_str(); + ret = parser::ReadBytesFromBinaryFile(file_name, &buffer, length); + EXPECT_EQ(ret, true); + + const char *path = nullptr; + std::string realPath = parser::RealPath(path); + EXPECT_EQ(realPath, ""); +} + +TEST_F(STestTensorflowParser, tensorflow_AclGrphParseUtil_ParseAclInputFp16Nodes_test) +{ + AclGrphParseUtil parserUtil; + ge::ComputeGraphPtr graph = std::make_shared(GRAPH_DEFAULT_NAME); + std::string input_fp16_nodes = "Add"; + std::string is_input_adjust_hw_layout = "is_input_adjust_hw_layout"; + Status ret = parserUtil.ParseAclInputFp16Nodes(graph, input_fp16_nodes, is_input_adjust_hw_layout); + EXPECT_EQ(ret, PARAM_INVALID); + + is_input_adjust_hw_layout = "true"; + ret = parserUtil.ParseAclInputFp16Nodes(graph, input_fp16_nodes, is_input_adjust_hw_layout); + EXPECT_EQ(ret, PARAM_INVALID); + + vector adjust_fp16_format_vec = {"true", "false"}; + uint32_t index = 1; + ge::OpDescPtr op_desc = std::make_shared(); + parserUtil.AddAttrsForInputNodes(adjust_fp16_format_vec, input_fp16_nodes, index, op_desc); + + std::string is_output_fp16 = "is_output_fp16"; + ret = parserUtil.ParseAclOutputFp16NodesFormat(is_output_fp16); + EXPECT_EQ(ret, PARAM_INVALID); + + is_output_fp16 = "false"; + ret = parserUtil.ParseAclOutputFp16NodesFormat(is_output_fp16); + EXPECT_EQ(ret, SUCCESS); + + is_output_fp16 = "true"; + ret = parserUtil.ParseAclOutputFp16NodesFormat(is_output_fp16); + EXPECT_EQ(ret, SUCCESS); +} + +TEST_F(STestTensorflowParser, tensorflow_ModelSaver_test) +{ + const char *file_path = nullptr; + const Json model = {{"a", "b"}}; + Status ret = ge::parser::ModelSaver::SaveJsonToFile(file_path, model); + EXPECT_EQ(ret, FAILED); + + file_path = "./origin_models/"; + ret = ge::parser::ModelSaver::SaveJsonToFile(file_path, model); + EXPECT_EQ(ret, FAILED); + + std::cout << __FILE__ << std::endl; + std::string caseDir = __FILE__; + std::size_t idx = caseDir.find_last_of("/"); + caseDir = caseDir.substr(0, idx); + std::string proto_file = caseDir + "/origin_models/caffe.proto"; + file_path = proto_file.c_str(); + ret = ge::parser::ModelSaver::SaveJsonToFile(file_path, model); + + char path[4096 + 1] = { 0 }; + memset(path, 'a', 4096); + EXPECT_EQ(-1, ge::parser::ModelSaver::CreateDirectory(path)); + EXPECT_EQ(-1, ge::parser::ModelSaver::CheckPath(path)); +} + +TEST_F(STestTensorflowParser, create_weights_parser_failed) +{ + WeightsParserFactory* factory = WeightsParserFactory::Instance(); + shared_ptr weight_parser = factory->CreateWeightsParser(FRAMEWORK_RESERVED); + ASSERT_TRUE(NULL == weight_parser); + + ModelParserFactory *modelFactory = ModelParserFactory::Instance(); + shared_ptr model_parser = modelFactory->CreateModelParser(FRAMEWORK_RESERVED); + ASSERT_TRUE(NULL == model_parser); +} + +TEST_F(STestTensorflowParser, tensorflow_parser_api_test) +{ + std::map options = {{"ge.runFlag", "1"}}; + Status ret = ParserInitialize(options); + EXPECT_EQ(ret, SUCCESS); + + ret = ParserInitialize(options); + EXPECT_EQ(ret, SUCCESS); + + ret = ParserFinalize(); + EXPECT_EQ(ret, SUCCESS); + + ret = ParserFinalize(); + EXPECT_EQ(ret, SUCCESS); +} + +TEST_F(STestTensorflowParser, tensorflow_FP16_parser_test) +{ + parser::fp16_t fp16; + fp16.ToDouble(); + fp16.ToInt8(); + fp16.ToUInt8(); + fp16.ToInt16(); + fp16.ToUInt16(); + fp16.ToInt32(); + fp16.ToUInt32(); + fp16.IsInf(); +} + } // namespace ge From 16923a1ce4d9cf20bad1da1d6808fbbb593ba3c5 Mon Sep 17 00:00:00 2001 From: jwx930962 Date: Sat, 11 Dec 2021 17:13:39 +0800 Subject: [PATCH 2/2] st parser --- tests/st/testcase/test_tensorflow_parser.cc | 121 +++++++++++++++++++- 1 file changed, 119 insertions(+), 2 deletions(-) diff --git a/tests/st/testcase/test_tensorflow_parser.cc b/tests/st/testcase/test_tensorflow_parser.cc index 3d6322f..e190bed 100644 --- a/tests/st/testcase/test_tensorflow_parser.cc +++ b/tests/st/testcase/test_tensorflow_parser.cc @@ -65,6 +65,8 @@ #include "parser/common/model_saver.h" #include "framework/omg/parser/parser_api.h" #include "parser/common/parser_fp16_t.h" +#include "parser/common/op_parser_factory.h" +#include "parser/common/prototype_pass_manager.h" #undef protected #undef private @@ -3101,6 +3103,46 @@ TEST_F(STestTensorflowParser, tensorflow_OptimizeConstNodes4CustomOp_test) EXPECT_EQ(ret, SUCCESS); } +TEST_F(STestTensorflowParser, OptimizeConstNodes4CustomOp_success) +{ + GraphDef graph; + auto bn = AddNode(graph, "FusedBatchNormV3", "FusedBatchNormV3_0"); + auto bn_grad = AddNode(graph, "FusedBatchNormGradV3", "FusedBatchNormGradV3_0"); + + AddInput(bn, bn_grad, 0); + AddInput(bn, bn_grad, 1); + AddInput(bn, bn_grad, 2); + AddInput(bn, bn_grad, 3); + AddInput(bn, bn_grad, 5); + AddInput(bn, bn_grad, 5); + + GraphDef* graphDef = &graph; + int before_bn_grad_input_size = bn_grad->input_size(); + ASSERT_EQ(before_bn_grad_input_size, 6); + + ModelParserFactory* factory = ModelParserFactory::Instance(); + shared_ptr model_parser= factory->CreateModelParser(domi::TENSORFLOW); + ge::TensorFlowModelParser tensorflow_parser; + + Status ret = tensorflow_parser.OptimizeConstNodes4CustomOp(graphDef); + int after_bn_grad_input_size = bn_grad->input_size(); + ASSERT_EQ(after_bn_grad_input_size, 6); + ASSERT_EQ(ret, domi::SUCCESS); + + REGISTER_CUSTOM_OP("BatchNormGrad") + .FrameworkType(domi::TENSORFLOW) + .OriginOpType({"FusedBatchNormGradV3", "FusedBatchNormGradV2", "FusedBatchNormGrad"}) + .ParseParamsFn(AutoMappingFn) + .DelInputWithOriginalType(5, "FusedBatchNormGradV3") + .ImplyType(ImplyType::TVM); + register_tbe_op(); + + ret = tensorflow_parser.OptimizeConstNodes4CustomOp(graphDef); + after_bn_grad_input_size = bn_grad->input_size(); + ASSERT_EQ(after_bn_grad_input_size, 6); + ASSERT_EQ(ret, domi::SUCCESS); +} + TEST_F(STestTensorflowParser, tensorflow_ParseOpParams_test) { TensorFlowModelParser model_parser; @@ -3483,11 +3525,16 @@ TEST_F(STestTensorflowParser, tensorflow_tbe_tfplugin_loader_test) std::string caseDir = __FILE__; std::size_t idx = caseDir.find_last_of("/"); caseDir = caseDir.substr(0, idx); - std::string proto_file = caseDir + "/origin_models/caffe.proto"; + std::string proto_file = caseDir + "/origin_models/"; std::string path = proto_file; std::string caffe_parser_path = path; pluginLoad.FindParserSo(path, fileList, caffe_parser_path); + setenv("ASCEND_OPP_PATH", "aaa", 1); + std::string customop_path = ""; + pluginLoad.GetCustomOpPath(customop_path); + ASSERT_EQ(customop_path, "aaa/framework/custom/:aaa/framework/built-in/tensorflow"); + Status ret = pluginLoad.Finalize(); EXPECT_EQ(ret, SUCCESS); } @@ -3551,9 +3598,14 @@ TEST_F(STestTensorflowParser, tensorflow_ReadBytesFromBinaryFile_test) ret = parser::ReadBytesFromBinaryFile(file_name, &buffer, length); EXPECT_EQ(ret, true); - const char *path = nullptr; + char path[4096 + 1] = { 0 }; + memset(path, 'a', 4096); std::string realPath = parser::RealPath(path); EXPECT_EQ(realPath, ""); + + const char *real_path = nullptr; + realPath = parser::RealPath(real_path); + EXPECT_EQ(realPath, ""); } TEST_F(STestTensorflowParser, tensorflow_AclGrphParseUtil_ParseAclInputFp16Nodes_test) @@ -3621,6 +3673,24 @@ TEST_F(STestTensorflowParser, create_weights_parser_failed) ModelParserFactory *modelFactory = ModelParserFactory::Instance(); shared_ptr model_parser = modelFactory->CreateModelParser(FRAMEWORK_RESERVED); ASSERT_TRUE(NULL == model_parser); + + std::shared_ptr parserFactory = OpParserFactory::Instance(domi::FrameworkType::CAFFE); + std::shared_ptr fusion_op_parser = parserFactory->CreateFusionOpParser(ge::parser::DATA); + ASSERT_TRUE(NULL == fusion_op_parser); + + std::shared_ptr op_parser = parserFactory->CreateOpParser("10"); + ASSERT_TRUE(NULL == op_parser); +} + +TEST_F(STestTensorflowParser, custom_parser_adapter_register) +{ + using PARSER_CREATOR_FN = std::function(void)>; + PARSER_CREATOR_FN func = CustomParserAdapterRegistry::Instance()->GetCreateFunc(domi::TENSORFLOW); + CustomParserAdapterRegistry::Instance()->Register(domi::TENSORFLOW, func); + CustomParserAdapterRegistry::Instance()->Register(domi::TENSORFLOW, func); + + func = CustomParserAdapterRegistry::Instance()->GetCreateFunc(domi::FRAMEWORK_RESERVED); + ASSERT_EQ(nullptr, func); } TEST_F(STestTensorflowParser, tensorflow_parser_api_test) @@ -3650,6 +3720,53 @@ TEST_F(STestTensorflowParser, tensorflow_FP16_parser_test) fp16.ToInt32(); fp16.ToUInt32(); fp16.IsInf(); + fp16.operator+(fp16); + fp16.operator-(fp16); + fp16.operator*(fp16); + fp16.operator/(fp16); + fp16.operator+=(fp16); + fp16.operator-=(fp16); + fp16.operator*=(fp16); + fp16.operator/=(fp16); + fp16.operator==(fp16); + fp16.operator!=(fp16); + fp16.operator>(fp16); + fp16.operator>=(fp16); + fp16.operator<(fp16); + fp16.operator<=(fp16); + fp16.operator=(fp16); + + float f_val = 0.1; + fp16.operator=(f_val); + + double d_val = 0.2; + fp16.operator=(d_val); + + int8_t i_val = 1; + fp16.operator=(i_val); + + uint8_t ui_val = 2; + fp16.operator=(ui_val); + + int16_t i_vals = 1; + fp16.operator=(i_vals); + + uint16_t ui16_val = 1; + fp16.operator=(ui16_val); + ui16_val = 0; + fp16.operator=(ui16_val); + ui16_val = 100000; + fp16.operator=(ui16_val); + + int32_t i32_val = 0; + fp16.operator=(i32_val); + i32_val = 1; + fp16.operator=(i32_val); + + uint32_t ui32_val = 0; + fp16.operator=(ui32_val); + ui32_val = 1; + fp16.operator=(ui32_val); } } // namespace ge