From 843f2127c6413c49afd38f4d88663acbf09d0abb Mon Sep 17 00:00:00 2001 From: liudingyan Date: Tue, 13 Apr 2021 15:21:41 +0800 Subject: [PATCH] add report error message --- parser/caffe/caffe_custom_parser_adapter.cc | 26 +- parser/caffe/caffe_data_parser.cc | 48 +-- parser/caffe/caffe_op_parser.cc | 68 ++- parser/caffe/caffe_parser.cc | 445 +++++++++++--------- parser/caffe/caffe_reshape_parser.cc | 19 +- parser/common/acl_graph_parser_util.cc | 205 +++++---- parser/common/data_op_parser.cc | 48 ++- parser/common/model_saver.cc | 23 +- parser/common/op_def/ir_pb_converter.cc | 26 +- parser/common/op_def/op_schema.cc | 28 +- parser/common/op_parser_factory.cc | 11 +- parser/common/parser_factory.cc | 8 +- parser/common/parser_utils.cc | 66 ++- parser/common/pass_manager.cc | 8 +- parser/common/pre_checker.cc | 33 +- parser/common/proto_file_parser.cc | 49 ++- parser/common/register_tbe.cc | 17 +- parser/onnx/onnx_constant_parser.cc | 24 +- parser/onnx/onnx_custom_parser_adapter.cc | 2 +- parser/onnx/onnx_data_parser.cc | 7 +- parser/onnx/onnx_parser.cc | 103 +++-- 21 files changed, 756 insertions(+), 508 deletions(-) diff --git a/parser/caffe/caffe_custom_parser_adapter.cc b/parser/caffe/caffe_custom_parser_adapter.cc index 4cfd084..0cd8730 100644 --- a/parser/caffe/caffe_custom_parser_adapter.cc +++ b/parser/caffe/caffe_custom_parser_adapter.cc @@ -49,7 +49,9 @@ Status CaffeCustomParserAdapter::ParseParams(const Message *op_src, ge::OpDescPt op_dest->SetName(layer->name()); ge::Operator op = ge::OpDescUtils::CreateOperatorFromOpDesc(op_dest); - GE_CHK_BOOL_RET_STATUS(customOpParser(op_src, op) == SUCCESS, FAILED, "Custom parser params failed"); + GE_CHK_BOOL_RET_STATUS(customOpParser(op_src, op) == SUCCESS, FAILED, + "[Invoke][CustomOpParser] failed, layer name:%s, layer type:%s", + layer->name().c_str(), layer->type().c_str()); return SUCCESS; } @@ -64,7 +66,9 @@ Status CaffeCustomParserAdapter::ParseParams(const Operator &op_src, ge::OpDescP op_dest->SetName(op_src.GetName()); ge::Operator op = ge::OpDescUtils::CreateOperatorFromOpDesc(op_dest); - GE_CHK_BOOL_RET_STATUS(custom_op_parser(op_src, op) == SUCCESS, FAILED, "Custom parser params failed"); + GE_CHK_BOOL_RET_STATUS(custom_op_parser(op_src, op) == SUCCESS, FAILED, + "[Invoke][CustomOpParser] failed, layer name:%s, type:%s", + op_src.GetName().c_str(), op_src.GetOpType().c_str()); return SUCCESS; } @@ -75,7 +79,7 @@ Status CaffeCustomParserAdapter::ParseWeights(const Message *op_src, ge::NodePtr GE_CHECK_NOTNULL(op); const LayerParameter *layer = reinterpret_cast(op_src); - GE_CHK_BOOL_RET_STATUS(nullptr != layer, FAILED, "Dynamic cast op_src to LayerParameter failed"); + GE_CHK_BOOL_RET_STATUS(nullptr != layer, FAILED, "[Convert][Type]Dynamic cast op_src to LayerParameter failed"); GELOGI("layer: %s blobs_size: %d bottom_size: %d", layer->name().c_str(), layer->blobs_size(), layer->bottom_size()); if (layer->blobs_size() == 0) { return SUCCESS; @@ -87,8 +91,8 @@ Status CaffeCustomParserAdapter::ParseWeights(const Message *op_src, ge::NodePtr for (int i = 0; i < layer->blobs_size(); ++i) { ge::GeTensorPtr weight = ge::parser::MakeShared(); GE_CHECK_NOTNULL(weight); - GE_CHK_STATUS_RET(ConvertWeight(layer->blobs(i), layer->name(), weight), "Convert blobs(%d) for layer %s failed", i, - layer->name().c_str()); + GE_CHK_STATUS_RET(ConvertWeight(layer->blobs(i), layer->name(), weight), + "[Convert][Blobs] (%d) for layer %s failed", i, layer->name().c_str()); GE_IF_BOOL_EXEC(layer->type() == kConvolution && i == kBlobIndexOne, const ConvolutionParameter &conv_params_src = layer->convolution_param(); bias_en = conv_params_src.bias_term();); @@ -122,13 +126,17 @@ Status CaffeCustomParserAdapter::ParseWeights(const Message *op_src, ge::NodePtr auto valid_input_name = op->GetValidInputNameByIndex(static_cast(index)); if (update_in_turn || valid_input_name.empty()) { if (node->AddLinkFrom(static_cast(index), const_node) != GRAPH_SUCCESS) { - GELOGE(GRAPH_FAILED, "AddEdge failed of from Node %s output to Node %s input %d", const_node->GetName().c_str(), - node->GetName().c_str(), index); + REPORT_CALL_ERROR("E19999", "AddEdge failed of from Node %s output to Node %s input %d", + const_node->GetName().c_str(), node->GetName().c_str(), index); + GELOGE(GRAPH_FAILED, "[Invoke][AddLinkFrom] AddEdge failed of from Node %s output to Node %s input %d", + const_node->GetName().c_str(), node->GetName().c_str(), index); } } else { if (node->AddLinkFrom(valid_input_name, const_node) != GRAPH_SUCCESS) { - GELOGE(GRAPH_FAILED, "AddEdge failed of from Node %s output to Node %s input %s", const_node->GetName().c_str(), - node->GetName().c_str(), valid_input_name.c_str()); + REPORT_CALL_ERROR("E19999", "AddEdge failed of from Node %s output to Node %s input %s", + const_node->GetName().c_str(), node->GetName().c_str(), valid_input_name.c_str()); + GELOGE(GRAPH_FAILED, "[Invoke][AddLinkFrom] AddEdge failed of from Node %s output to Node %s input %s", + const_node->GetName().c_str(), node->GetName().c_str(), valid_input_name.c_str()); } } diff --git a/parser/caffe/caffe_data_parser.cc b/parser/caffe/caffe_data_parser.cc index f7acb63..ecdb1c0 100644 --- a/parser/caffe/caffe_data_parser.cc +++ b/parser/caffe/caffe_data_parser.cc @@ -37,7 +37,7 @@ Status CaffeDataParser::GetOutputDesc(const string &name, int dim_size, const st GELOGW("SetInt failed for op %s.", op->GetName().c_str());); // no need to return // Initialize input and output description of OP according to input_dims information - GE_RETURN_WITH_LOG_IF_ERROR(ParseShape(input_dims, op), "data layer %s ParseShape failed", name.c_str()); + GE_RETURN_WITH_LOG_IF_ERROR(ParseShape(input_dims, op), "[Parse][Shape] failed for data layer %s", name.c_str()); return SUCCESS; } @@ -50,14 +50,14 @@ Status CaffeDataParser::ParseParams(const Message *op_src, ge::OpDescPtr &op) { GELOGD("Caffe layer name = %s, layer type= %s, parse params", layer->name().c_str(), layer->type().c_str()); if (layer->type() == ge::parser::INPUT_TYPE) { - GE_CHK_STATUS_RET(ParseParamsForInput(layer, op), "Caffe layer name = %s, layer type= %s, parse params failed", - layer->name().c_str(), layer->type().c_str()); + GE_CHK_STATUS_RET(ParseParamsForInput(layer, op), "[Parse][Params] failed, Caffe layer name = %s, " + "layer type= %s", layer->name().c_str(), layer->type().c_str()); } else if(layer->type() == ge::parser::DUMMY_DATA) { - GE_CHK_STATUS_RET(ParseParamsForDummyData(layer, op), "Caffe layer name = %s, layer type= %s, parse params failed", - layer->name().c_str(), layer->type().c_str()); + GE_CHK_STATUS_RET(ParseParamsForDummyData(layer, op), "[Parse][Params] failed, Caffe layer name = %s, " + "layer type= %s", layer->name().c_str(), layer->type().c_str()); } else { ErrorManager::GetInstance().ATCReportErrMessage("E11030"); - GELOGE(PARAM_INVALID, "Caffe prototxt has no optype [Input]"); + GELOGE(PARAM_INVALID, "[Check][Param] Caffe prototxt has no optype [Input]"); return FAILED; } return SUCCESS; @@ -69,9 +69,8 @@ Status CaffeDataParser::ParseParamsForInput(const domi::caffe::LayerParameter *l if (input_param.shape_size() == 0) { ErrorManager::GetInstance().ATCReportErrMessage( "E11027", {"layername", "layertype"}, {layer->name(), layer->type()}); - GELOGE(PARAM_INVALID, - "input_param shape size is zero, caffe layer name [%s], layer type [%s].", - layer->name().c_str(), layer->type().c_str()); + GELOGE(PARAM_INVALID, "[Check][Param]input_param shape size is zero, check invalid, " + "caffe layer name [%s], layer type [%s].", layer->name().c_str(), layer->type().c_str()); return FAILED; } for (int i = 0; i < input_param.shape_size(); i++) { @@ -84,8 +83,8 @@ Status CaffeDataParser::ParseParamsForInput(const domi::caffe::LayerParameter *l } string name = layer->name(); GE_IF_BOOL_EXEC(shape_map.count(name) != 0, model_dims = shape_map.at(name)); - GE_CHK_STATUS_RET(GetOutputDesc(name, model_dims.size(), model_dims, op), "Get output desc failed in layer %s", - name.c_str()); + GE_CHK_STATUS_RET(GetOutputDesc(name, model_dims.size(), model_dims, op), + "[Get][OutputDesc] failed in layer %s", name.c_str()); } } else { // Get from external input @@ -96,14 +95,14 @@ Status CaffeDataParser::ParseParamsForInput(const domi::caffe::LayerParameter *l if (search == input_dims.end()) { ErrorManager::GetInstance().ATCReportErrMessage( "E11028", {"layername", "layertype"}, {layer->name(), layer->type()}); - GELOGE(PARAM_INVALID, - "Caffe prototxt has no input_param or user should set --input_shape in atc parameter, " - "caffe layer name [%s], layer type [%s].", layer->name().c_str(), layer->type().c_str()); + GELOGE(PARAM_INVALID, "[Check][Param] Caffe prototxt has no input_param or user " + "should set --input_shape in atc parameter, caffe layer name [%s], layer type [%s].", + layer->name().c_str(), layer->type().c_str()); return FAILED; } std::vector dims = search->second; - GE_CHK_STATUS_RET(GetOutputDesc(name, dims.size(), dims, op), "Get output desc failed in layer %s.", - name.c_str()); + GE_CHK_STATUS_RET(GetOutputDesc(name, dims.size(), dims, op), + "[Get][OutputDesc] failed in layer %s.", name.c_str()); } return SUCCESS; } @@ -114,8 +113,7 @@ Status CaffeDataParser::ParseParamsForDummyData(const domi::caffe::LayerParamete if (dummy_data_param.shape_size() == 0) { ErrorManager::GetInstance().ATCReportErrMessage( "E11027", {"layername", "layertype"}, {layer->name(), layer->type()}); - GELOGE(PARAM_INVALID, - "input_param shape size is zero, caffe layer name [%s], layer type [%s].", + GELOGE(PARAM_INVALID, "[Check][Param] input_param shape size is zero, caffe layer name [%s], layer type [%s].", layer->name().c_str(), layer->type().c_str()); return FAILED; } @@ -131,8 +129,8 @@ Status CaffeDataParser::ParseParamsForDummyData(const domi::caffe::LayerParamete string name = layer->name(); GE_IF_BOOL_EXEC(shape_map.count(name) != 0, model_dims = shape_map.at(name)); - GE_CHK_STATUS_RET(GetOutputDesc(name, model_dims.size(), model_dims, op), "Get output desc failed in layer %s", - name.c_str()); + GE_CHK_STATUS_RET(GetOutputDesc(name, model_dims.size(), model_dims, op), + "[Get][OutputDesc] failed in layer %s", name.c_str()); } } else { // Get from external input @@ -143,14 +141,14 @@ Status CaffeDataParser::ParseParamsForDummyData(const domi::caffe::LayerParamete if (search == input_dims.end()) { ErrorManager::GetInstance().ATCReportErrMessage( "E11028", {"layername", "layertype"}, {layer->name(), layer->type()}); - GELOGE(PARAM_INVALID, - "Caffe prototxt has no input_param or user should set --input_shape in atc parameter, " - "caffe layer name [%s], layer type [%s].", layer->name().c_str(), layer->type().c_str()); + GELOGE(PARAM_INVALID, "[Check][Param] Caffe prototxt has no input_param or user " + "should set --input_shape in atc parameter, caffe layer name [%s], layer type [%s].", + layer->name().c_str(), layer->type().c_str()); return FAILED; } std::vector dims = search->second; - GE_CHK_STATUS_RET(GetOutputDesc(name, dims.size(), dims, op), "Get output desc failed in layer %s.", - name.c_str()); + GE_CHK_STATUS_RET(GetOutputDesc(name, dims.size(), dims, op), + "[Get][OutputDesc] failed in layer %s.", name.c_str()); } return SUCCESS; } diff --git a/parser/caffe/caffe_op_parser.cc b/parser/caffe/caffe_op_parser.cc index 63d0b6e..77d2229 100644 --- a/parser/caffe/caffe_op_parser.cc +++ b/parser/caffe/caffe_op_parser.cc @@ -58,16 +58,17 @@ Status CaffeOpParser::ConvertWeight(const BlobProto &proto, const string &lay_na for (size_t i = 0; i < shape.GetDimNum(); ++i) { int dim = shape.GetDim(i); if (dim <= 0) { - GELOGE(FAILED, "Convert weight fail, Blob size invalid"); + REPORT_INNER_ERROR("E19999", "Convert weight fail, dim:%d of layer:%s <=0, check invalid", dim, lay_name.c_str()); + GELOGE(FAILED, "[Check][Size]Convert weight fail, dim:%d of layer:%s <=0, check invalid", dim, lay_name.c_str()); return FAILED; } if (dim >= INT64_MAX / count) { - ErrorManager::GetInstance().ATCReportErrMessage( - "E11033", {"opname", "blobsize", "reason"}, - {lay_name, std::to_string(dim) + "*" + std::to_string(count), - "it exceeds INT64_MAX[" + std::to_string(INT64_MAX) + "]"}); - GELOGE(FAILED, "Convert weight fail, Blob size exceeds INT64_MAX, dim:%d, count:%d", dim, count); + ErrorManager::GetInstance().ATCReportErrMessage("E11033", {"opname", "blobsize", "reason"}, + {lay_name, std::to_string(dim) + "*" + std::to_string(count), + "it exceeds INT64_MAX[" + std::to_string(INT64_MAX) + "]"}); + GELOGE(FAILED, "[Check][Size]Convert weight fail, Blob size exceeds INT64_MAX, dim:%d, count:%d, layer name:%s", + dim, count, lay_name.c_str()); return FAILED; } @@ -84,12 +85,11 @@ Status CaffeOpParser::ParseWeightType(const BlobProto &proto, const ge::GeShape if (proto.double_data_size() > 0) { // Convert by double type if (size != proto.double_data_size()) { - ErrorManager::GetInstance().ATCReportErrMessage( - "E11033", {"opname", "blobsize", "reason"}, - {lay_name, std::to_string(proto.double_data_size()), - "it does not match shape size[" + std::to_string(size) + "]"}); - GELOGE(FAILED, "Convert weight fail, Blob size does not match shape size, shape size:%d, blob size:%d", size, - proto.double_data_size()); + ErrorManager::GetInstance().ATCReportErrMessage("E11033", {"opname", "blobsize", "reason"}, + {lay_name, std::to_string(proto.double_data_size()), + "it does not match shape size[" + std::to_string(size) + "]"}); + GELOGE(FAILED, "[Check][Param]Convert weight fail, Blob size does not match shape size, " + "shape size:%d, blob size:%d, layer name:%s", size, proto.double_data_size(), lay_name.c_str()); return FAILED; } std::unique_ptr buf(new (std::nothrow) float[size]()); @@ -101,12 +101,11 @@ Status CaffeOpParser::ParseWeightType(const BlobProto &proto, const ge::GeShape GELOGW("SetData failed for GeTensor.");); // no need to return } else if (proto.int8_data().length() > 0) { if (size != static_cast(proto.int8_data().length())) { - ErrorManager::GetInstance().ATCReportErrMessage( - "E11033", {"opname", "blobsize", "reason"}, - {lay_name, std::to_string(proto.int8_data().length()), - "it does not match shape size[" + std::to_string(size) + "]"}); - GELOGE(FAILED, "Convert weight failed, Blob size does not match shape size, shape size:%d, blob size:%ld", size, - proto.int8_data().length()); + ErrorManager::GetInstance().ATCReportErrMessage("E11033", {"opname", "blobsize", "reason"}, + {lay_name, std::to_string(proto.int8_data().length()), + "it does not match shape size[" + std::to_string(size) + "]"}); + GELOGE(FAILED, "[Check][Param]Convert weight failed, Blob size does not match shape size, " + "shape size:%d, blob size:%ld, layer name:%s", size, proto.int8_data().length(), lay_name.c_str()); return FAILED; } const char *data_ptr = proto.int8_data().data(); @@ -117,12 +116,11 @@ Status CaffeOpParser::ParseWeightType(const BlobProto &proto, const ge::GeShape dtype = ge::DT_INT8; } else if (proto.int32_data_size() > 0) { if (size != proto.int32_data_size()) { - ErrorManager::GetInstance().ATCReportErrMessage( - "E11033", {"opname", "blobsize", "reason"}, - {lay_name, std::to_string(proto.int32_data_size()), - "it does not match shape size[" + std::to_string(size) + "]"}); - GELOGE(FAILED, "Convert weight failed, Blob size does not match shape size, shape size:%d, blob size:%d", size, - proto.int32_data_size()); + ErrorManager::GetInstance().ATCReportErrMessage("E11033", {"opname", "blobsize", "reason"}, + {lay_name, std::to_string(proto.int32_data_size()), + "it does not match shape size[" + std::to_string(size) + "]"}); + GELOGE(FAILED, "[Check][Param]Convert weight failed, Blob size does not match shape size, " + "shape size:%d, blob size:%d, layer name:%s", size, proto.int32_data_size(), lay_name.c_str()); return FAILED; } std::unique_ptr int32_weight_buf(new (std::nothrow) int32_t[size]()); @@ -136,12 +134,11 @@ Status CaffeOpParser::ParseWeightType(const BlobProto &proto, const ge::GeShape dtype = ge::DT_INT32; } else if (proto.uint64_data_size() > 0) { if (size != proto.uint64_data_size()) { - ErrorManager::GetInstance().ATCReportErrMessage( - "E11033", {"opname", "blobsize", "reason"}, - {lay_name, std::to_string(proto.uint64_data_size()), - "it does not match shape size[" + std::to_string(size) + "]"}); - GELOGE(FAILED, "Convert weight failed, Blob size does not match shape size, shape size:%d, blob size:%d", size, - proto.uint64_data_size()); + ErrorManager::GetInstance().ATCReportErrMessage("E11033", {"opname", "blobsize", "reason"}, + {lay_name, std::to_string(proto.uint64_data_size()), + "it does not match shape size[" + std::to_string(size) + "]"}); + GELOGE(FAILED, "[Check][Param]Convert weight failed, Blob size does not match shape size, " + "shape size:%d, blob size:%d, layer name:%s", size, proto.uint64_data_size(), lay_name.c_str()); return FAILED; } std::unique_ptr uint64_weight_buf(new (std::nothrow) uint64_t[size]()); @@ -156,12 +153,11 @@ Status CaffeOpParser::ParseWeightType(const BlobProto &proto, const ge::GeShape } else { // Convert by float type if (size != proto.data_size()) { - ErrorManager::GetInstance().ATCReportErrMessage( - "E11033", {"opname", "blobsize", "reason"}, - {lay_name, std::to_string(proto.data_size()), - "it does not match shape size[" + std::to_string(size) + "]"}); - GELOGE(FAILED, "Convert weight fail, Blob size does not match shape size, shape size:%d, blob.data_size:%d", size, - proto.data_size()); + ErrorManager::GetInstance().ATCReportErrMessage("E11033", {"opname", "blobsize", "reason"}, + {lay_name, std::to_string(proto.data_size()), + "it does not match shape size[" + std::to_string(size) + "]"}); + GELOGE(FAILED, "[Check][Param]Convert weight fail, Blob size does not match shape size, " + "shape size:%d, blob.data_size:%d, layer name:%s", size, proto.data_size(), lay_name.c_str()); return FAILED; } const float *data_ptr = proto.data().data(); diff --git a/parser/caffe/caffe_parser.cc b/parser/caffe/caffe_parser.cc index 46aed57..fec7c80 100644 --- a/parser/caffe/caffe_parser.cc +++ b/parser/caffe/caffe_parser.cc @@ -84,7 +84,8 @@ graphStatus aclgrphParseCaffe(const char *model_file, const char *weights_file, AclGrphParseUtil acl_graph_parse_util; domi::Status status = acl_graph_parse_util.AclParserInitialize(options); if (status != domi::SUCCESS) { - GELOGE(GRAPH_FAILED, "Parser Initialize failed."); + REPORT_CALL_ERROR("E19999", "AclParserInitialize failed, ret:%d.", status); + GELOGE(GRAPH_FAILED, "[Parser][Initialize] failed, ret:%d.", status); return GRAPH_FAILED; } @@ -99,7 +100,8 @@ graphStatus aclgrphParseCaffe(const char *model_file, const char *weights_file, // parse caffe model_file and weights_file to GE graph ge::graphStatus ret = model_parser->Parse(model_file, graph); if (ret != ge::SUCCESS) { - GELOGE(ret, "Parser graph %s failed.", graph.GetName().c_str()); + REPORT_CALL_ERROR("E19999", "parse param:model_file %s failed, graph:%s.", model_file, graph.GetName().c_str()); + GELOGE(ret, "[Parser][Param]ModelFile %s failed, graph:%s.", model_file, graph.GetName().c_str()); return ge::FAILED; } GELOGI("Parser graph %s success.", graph.GetName().c_str()); @@ -108,13 +110,17 @@ graphStatus aclgrphParseCaffe(const char *model_file, const char *weights_file, GE_CHECK_NOTNULL(weights_parser); ret = weights_parser->Parse(weights_file, graph); if (ret != ge::SUCCESS) { - GELOGE(ret, "Weights parse failed. graph: %s", graph.GetName().c_str()); + REPORT_CALL_ERROR("E19999", "parse param:weights_file %s failed, graph:%s", weights_file, graph.GetName().c_str()); + GELOGE(ret, "[Parse][Param]WeightsFile %s failed. graph: %s", weights_file, graph.GetName().c_str()); return ret; } GELOGI("Weights parse success. graph: %s", graph.GetName().c_str()); std::map parser_params; if (acl_graph_parse_util.SetOutputNodeInfo(graph, parser_params) != ge::SUCCESS) { - GELOGE(ret, "Set graph %s default output node failed.", graph.GetName().c_str()); + REPORT_CALL_ERROR("E19999", "SetOutputNodeInfo failed, model file:%s graph:%s", + model_file, graph.GetName().c_str()); + GELOGE(ret, "[Invoke][SetOutputNodeInfo]Set graph %s default output node failed, model file:%s.", + graph.GetName().c_str(), model_file); return ge::FAILED; } return ge::SUCCESS; @@ -132,13 +138,14 @@ graphStatus aclgrphParseCaffe(const char *model_file, const char *weights_file, AclGrphParseUtil acl_graph_parse_util; domi::Status status = acl_graph_parse_util.AclParserInitialize(options); if (status != domi::SUCCESS) { - GELOGE(GRAPH_FAILED, "Parser Initialize failed."); + REPORT_CALL_ERROR("E19999", "AclParserInitialize failed, ret:%d.", status); + GELOGE(GRAPH_FAILED, "[Parser][Initialize] failed ret:%d.", status); return GRAPH_FAILED; } string output_name; if (acl_graph_parse_util.ParseParamsBeforeGraph(parser_params, output_name) != ge::SUCCESS) { - GELOGE(ge::FAILED, "Parser params before graph failed."); + GELOGE(ge::FAILED, "[Parse][Params]Before Graph failed."); return ge::FAILED; } // Create an empty computegraph @@ -153,13 +160,15 @@ graphStatus aclgrphParseCaffe(const char *model_file, const char *weights_file, // parse caffe model_file and weights_file to GE graph ge::graphStatus ret = model_parser->Parse(model_file, graph); if (ret != ge::SUCCESS) { - GELOGE(ret, "Parser graph %s failed.", graph.GetName().c_str()); + REPORT_CALL_ERROR("E19999", "Parse param:model_file %s failed, graph:%s", model_file, graph.GetName().c_str()); + GELOGE(ret, "[Parser][Param]ModelFile %s failed, graph %s.", model_file, graph.GetName().c_str()); return ge::FAILED; } GELOGI("Parser graph %s success.", graph.GetName().c_str()); if (acl_graph_parse_util.ParseParamsAfterGraph(graph, parser_params) != ge::SUCCESS) { - GELOGE(ge::FAILED, "Parser params after graph failed."); + REPORT_CALL_ERROR("E19999", "ParseParamsAfterGraph failed, graph:%s.", graph.GetName().c_str()); + GELOGE(ge::FAILED, "[Parser][Params] after graph failed, graph:%s.", graph.GetName().c_str()); return ge::FAILED; } @@ -167,13 +176,16 @@ graphStatus aclgrphParseCaffe(const char *model_file, const char *weights_file, GE_CHECK_NOTNULL(weights_parser); ret = weights_parser->Parse(weights_file, graph); if (ret != ge::SUCCESS) { - GELOGE(ret, "Weights parse failed. graph: %s", graph.GetName().c_str()); + REPORT_CALL_ERROR("E19999", "parse param:weights_file %s failed, graph: %s", weights_file, graph.GetName().c_str()); + GELOGE(ret, "[Parse][Param]WeightsFile %s failed. graph: %s", weights_file, graph.GetName().c_str()); return ret; } GELOGI("Weights parse success. graph: %s", graph.GetName().c_str()); if (acl_graph_parse_util.SetOutputNodeInfo(graph, parser_params) != ge::SUCCESS) { - GELOGE(ge::FAILED, "Set graph %s default output node failed.", graph.GetName().c_str()); + REPORT_CALL_ERROR("E19999", "SetOutputNodeInfo failed, graph:%s", graph.GetName().c_str()); + GELOGE(ge::FAILED, "[Invoke][SetOutputNodeInfo]Set graph %s default output node failed.", + graph.GetName().c_str()); return ge::FAILED; } GELOGI("AclgrphParse graph %s success.", graph.GetName().c_str()); @@ -232,7 +244,7 @@ Status CheckPathValid(const char *model_path, const string &custom_proto, string string path_model = ge::parser::RealPath(model_path); if (path_model.empty()) { ErrorManager::GetInstance().ATCReportErrMessage("E19000", {"path", "errmsg"}, {model_path, strerror(errno)}); - GELOGE(FAILED, "Invalid path of model: %s", model_path); + GELOGE(FAILED, "[Check][Param]ModelPath %s is Invalid path of model", model_path); return FAILED; } @@ -265,21 +277,22 @@ Status CaffeModelParser::ParseInput(domi::caffe::NetParameter &proto_message, bo if (proto_message.input_dim_size() > 0) { if (proto_message.input_shape_size() > 0) { ErrorManager::GetInstance().ATCReportErrMessage("E11001"); - GELOGE(FAILED, "input_dim and input_shape can not both exist!"); + GELOGE(FAILED, "[Check][Size]input_dim and input_shape can not both exist!"); return FAILED; } int input_dim_size = proto_message.input_dim_size(); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((proto_message.input_size() == 0), ErrorManager::GetInstance().ATCReportErrMessage("E11002"); - return PARAM_INVALID, "Model has no input."); + return PARAM_INVALID, "[Check][Size]Model has no input."); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((input_dim_size / proto_message.input_size() != parser::DIM_DEFAULT_SIZE || input_dim_size % proto_message.input_size() != 0), ErrorManager::GetInstance().ATCReportErrMessage( "E11003", {"input_dim_size", "input_size"}, {std::to_string(input_dim_size), std::to_string(proto_message.input_size())}); - return FAILED, "Model input_dim size[%d] is not 4 times of input size[%d].", - input_dim_size, proto_message.input_size()) + return FAILED, + "[Check][Size]Model input_dim size[%d] is not 4 times of input size[%d].", + input_dim_size, proto_message.input_size()) for (int i = 0; i < proto_message.input_size(); i++) { domi::caffe::LayerParameter *layer = proto_message.add_layer(); @@ -300,13 +313,12 @@ Status CaffeModelParser::ParseInput(domi::caffe::NetParameter &proto_message, bo input_data_flag = true; } } else if (proto_message.input_shape_size() > 0) { - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG( - proto_message.input_shape_size() != proto_message.input_size(), - ErrorManager::GetInstance().ATCReportErrMessage( - "E11004", {"input_shape_size", "input_size"}, - {std::to_string(proto_message.input_shape_size()), std::to_string(proto_message.input_size())}); - return FAILED, "caffe net input_shape size(%d) is not equal input size(%d).", - proto_message.input_shape_size(), proto_message.input_size()); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(proto_message.input_shape_size() != proto_message.input_size(), + ErrorManager::GetInstance().ATCReportErrMessage("E11004", {"input_shape_size", "input_size"}, + {std::to_string(proto_message.input_shape_size()), + std::to_string(proto_message.input_size())}); + return FAILED, "[Check][Size]caffe net input_shape size(%d) is not equal input size(%d).", + proto_message.input_shape_size(), proto_message.input_size()); for (int i = 0; i < proto_message.input_size(); i++) { int dim_size = proto_message.input_shape(i).dim_size(); @@ -335,7 +347,7 @@ Status CaffeModelParser::ParseInput(domi::caffe::NetParameter &proto_message, bo string name = proto_message.input(i); if (input_dims.count(name) == 0) { // Input defined by model does not exist in input of external input ErrorManager::GetInstance().ATCReportErrMessage("E11005"); - GELOGE(FAILED, "Model has no input shape."); + GELOGE(FAILED, "[Find][Dim]Model has no input shape."); return FAILED; } std::vector dims = input_dims.at(name); @@ -382,7 +394,7 @@ Status CaffeModelParser::ParseNetModelByCustomProto(const char *model_path, cons if (ReadModelWithoutWarning(model_path, message) != SUCCESS) { delete message; - GELOGE(FAILED, "ReadModelWithoutWarning %s failed.", model_path); + GELOGE(FAILED, "[Invoke][ReadModelWithoutWarning] %s failed.", model_path); return FAILED; } @@ -392,13 +404,14 @@ Status CaffeModelParser::ParseNetModelByCustomProto(const char *model_path, cons delete message; ErrorManager::GetInstance().ATCReportErrMessage( "E19021", {"reason"}, {"Does not find domi.caffe.LayerParameter in google::protobuf::Descriptor"}); - GELOGE(FAILED, "Does not find domi.caffe.LayerParameter in google::protobuf::Descriptor"); + GELOGE(FAILED, "[Invoke][FindMessageTypeByName]Does not find domi.caffe.LayerParameter" + "in google::protobuf::Descriptor"); return FAILED; } if (ParseLayerParameter(layer_descriptor, message, operators) != SUCCESS) { delete message; - GELOGE(FAILED, "ParseLayerParameter failed."); + GELOGE(FAILED, "[Parse][LayerParameter] failed, model path:%s.", model_path); return FAILED; } @@ -417,14 +430,14 @@ Status CaffeModelParser::CustomProtoParse(const char *model_path, const string & string custom_proto_name; if (CheckPathValid(model_path, custom_proto, custom_proto_path, custom_proto_name) != SUCCESS) { - GELOGE(FAILED, "CheckPathValid of model and proto failed."); + GELOGE(FAILED, "[Check][PathValid] of model and proto failed, path:%s.", model_path); return FAILED; } GELOGI("Start to parse model: %s by custom proto: %s.", model_path, custom_proto.c_str()); Status ret = ParseNetModelByCustomProto(model_path, custom_proto_path, custom_proto_name, operators); if (ret != SUCCESS) { - GELOGE(FAILED, "parse net model by custom proto failed."); + GELOGE(FAILED, "[Parse][NetModel]By CustomProto failed, path:%s.", model_path); } return ret; @@ -436,7 +449,7 @@ Status CaffeModelParser::GetIdentifier(const std::string &line, int32_t &identif if (pos == std::string::npos) { ErrorManager::GetInstance().ATCReportErrMessage("E11032", {"name", "reason"}, {line.c_str(), "it must contain '='"}); - GELOGE(FAILED, "line: %s must contain char =.", line.c_str()); + GELOGE(FAILED, "[Check][Param]line: %s must contain char =.", line.c_str()); return FAILED; } for (size_t i = pos + 1; i < size; i++) { @@ -446,7 +459,8 @@ Status CaffeModelParser::GetIdentifier(const std::string &line, int32_t &identif if (identifier > kMaxIdentifier || identifier < 0) { ErrorManager::GetInstance().ATCReportErrMessage( "E11032", {"name", "reason"}, {to_string(identifier), "it can not exceed max value or less than 0"}); - GELOGE(FAILED, "Param identifier exceeded max value, identifier: %d.", identifier); + GELOGE(FAILED, "[Check][Param]Param identifier exceeded max value:%d, identifier: %d.", + kMaxIdentifier, identifier); return FAILED; } if (line[i] >= '0' && line[i] <= '9') { @@ -457,7 +471,7 @@ Status CaffeModelParser::GetIdentifier(const std::string &line, int32_t &identif if (identifier == 0) { ErrorManager::GetInstance().ATCReportErrMessage( "E11032", {"name", "reason"}, {to_string(identifier), "it must larger than 0"}); - GELOGE(FAILED, "Param identifier must larger than zero, identifier: %d.", identifier); + GELOGE(FAILED, "[Check][Param]Param identifier must larger than zero, identifier: %d.", identifier); return FAILED; } return SUCCESS; @@ -478,15 +492,15 @@ Status CaffeModelParser::SaveIdentifierOpMapInfo(const string &line, std::mapis_repeated()) { ErrorManager::GetInstance().ATCReportErrMessage("E11032", {"name", "reason"}, {field->name().c_str(), "LayerParameter should be repeated"}); - GELOGE(FAILED, "LayerParameter should be repeated."); + GELOGE(FAILED, "[Check][Param] LayerParameter should be repeated."); return FAILED; } @@ -650,7 +664,7 @@ Status CaffeModelParser::ParseLayerParameter(const google::protobuf::Descriptor continue; } if (CreateCustomOperator(op_name, op_type, &layer_message, i, operators) != SUCCESS) { - GELOGE(FAILED, "CreateCustomOperator failed, name: %s, type: %s.", op_name.c_str(), op_type.c_str()); + GELOGE(FAILED, "[Create][CustomOperator] failed, name: %s, type: %s.", op_name.c_str(), op_type.c_str()); return FAILED; } } @@ -662,7 +676,8 @@ Status CaffeModelParser::CreateCustomOperator(string op_name, string op_type, co int index, vector &operators) { if (op_name.empty() || op_type.empty()) { ErrorManager::GetInstance().ATCReportErrMessage("E12026", {"name", "type"}, {op_name.c_str(), op_type.c_str()}); - GELOGE(FAILED, "Name or type of layer is empty, name: %s, type: %s.", op_name.c_str(), op_type.c_str()); + GELOGE(FAILED, "[Check][Param]Name or type of layer is empty, name: %s, type: %s.", + op_name.c_str(), op_type.c_str()); return FAILED; } @@ -670,12 +685,13 @@ Status CaffeModelParser::CreateCustomOperator(string op_name, string op_type, co ge::Operator ops(op_name, op_type); if (ops.GetName() != op_name) { ErrorManager::GetInstance().ATCReportErrMessage("E12027", {"name", "type"}, {op_name.c_str(), op_type.c_str()}); - GELOGE(FAILED, "Create operator failed, name: %s, type: %s, index: %d.", op_name.c_str(), op_type.c_str(), index); + GELOGE(FAILED, "[Create][Operator] failed, name: %s, type: %s, index: %d.", + op_name.c_str(), op_type.c_str(), index); return FAILED; } if (ParseOperatorAttrs(message, 1, ops) != SUCCESS) { - GELOGE(FAILED, "ParseOperatorAttrs of %s failed.", op_name.c_str()); + GELOGE(FAILED, "[Parse][OperatorAttrs] of %s failed.", op_name.c_str()); return FAILED; } @@ -687,7 +703,8 @@ Status CaffeModelParser::CreateCustomOperator(string op_name, string op_type, co Status CaffeModelParser::ParseOperatorAttrs(const google::protobuf::Message *message, int depth, ge::Operator &ops) { if (depth > kMaxParseDepth) { - GELOGE(FAILED, "Message depth can not exceed %d.", kMaxParseDepth); + REPORT_INNER_ERROR("E19999", "Message depth:%d can not exceed %d.", depth, kMaxParseDepth); + GELOGE(FAILED, "[Check][Param]Message depth can not exceed %d.", kMaxParseDepth); return FAILED; } @@ -700,12 +717,12 @@ Status CaffeModelParser::ParseOperatorAttrs(const google::protobuf::Message *mes GE_CHECK_NOTNULL(field); if (field->is_repeated()) { if (ParseRepeatedField(reflection, message, field, depth, ops) != SUCCESS) { - GELOGE(FAILED, "Parse repeated field %s failed.", field->name().c_str()); + GELOGE(FAILED, "[Parse][RepeatedField] %s failed.", field->name().c_str()); return FAILED; } } else { if (ParseField(reflection, message, field, depth, ops) != SUCCESS) { - GELOGE(FAILED, "Parse field %s failed.", field->name().c_str()); + GELOGE(FAILED, "[Parse][Field] %s failed.", field->name().c_str()); return FAILED; } } @@ -748,7 +765,7 @@ Status CaffeModelParser::ParseField(const google::protobuf::Reflection *reflecti case google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE: { const google::protobuf::Message &sub_message = reflection->GetMessage(*message, field); if (ParseOperatorAttrs(&sub_message, depth + 1, ops) != SUCCESS) { - GELOGE(FAILED, "ParseOperatorAttrs of %s failed.", field->name().c_str()); + GELOGE(FAILED, "[Parse][OperatorAttrs] of %s failed.", field->name().c_str()); return FAILED; } break; @@ -756,7 +773,7 @@ Status CaffeModelParser::ParseField(const google::protobuf::Reflection *reflecti default: { ErrorManager::GetInstance().ATCReportErrMessage("E11032", {"name", "reason"}, {field->name().c_str(), "Unsupported field type"}); - GELOGE(FAILED, "Unsupported field type, name: %s.", field->name().c_str()); + GELOGE(FAILED, "[Check][FieldType]Unsupported field type, name: %s.", field->name().c_str()); return FAILED; } } @@ -771,7 +788,8 @@ Status CaffeModelParser::ParseRepeatedField(const google::protobuf::Reflection * GELOGD("Start to parse field: %s.", field->name().c_str()); int field_size = reflection->FieldSize(*message, field); if (field_size <= 0) { - GELOGE(FAILED, "Size of repeated field %s must bigger than 0", field->name().c_str()); + REPORT_INNER_ERROR("E19999", "Size of repeated field %s must bigger than 0", field->name().c_str()); + GELOGE(FAILED, "[Check][Size]Size of repeated field %s must bigger than 0", field->name().c_str()); return FAILED; } @@ -802,11 +820,11 @@ Status CaffeModelParser::ParseRepeatedField(const google::protobuf::Reflection * repeated_message_str = message_json.dump(kInteval, ' ', false, Json::error_handler_t::ignore); } catch (std::exception &e) { ErrorManager::GetInstance().ATCReportErrMessage("E19007", {"exception"}, {e.what()}); - GELOGE(FAILED, "Failed to convert JSON to string, reason: %s.", e.what()); + GELOGE(FAILED, "[Parse][JSON]Failed to convert JSON to string, reason: %s.", e.what()); return FAILED; } catch (...) { ErrorManager::GetInstance().ATCReportErrMessage("E19008"); - GELOGE(FAILED, "Failed to convert JSON to string."); + GELOGE(FAILED, "[Parse][JSON]Failed to convert JSON to string."); return FAILED; } (void)ops.SetAttr(field->name(), repeated_message_str); @@ -815,7 +833,7 @@ Status CaffeModelParser::ParseRepeatedField(const google::protobuf::Reflection * default: { ErrorManager::GetInstance().ATCReportErrMessage("E11032", {"name", "reason"}, {field->name().c_str(), "Unsupported field type"}); - GELOGE(FAILED, "Unsupported field type, name: %s.", field->name().c_str()); + GELOGE(FAILED, "[Check][FieldType]Unsupported field type, name: %s.", field->name().c_str()); return FAILED; } } @@ -872,7 +890,7 @@ Status CaffeModelParser::ParseOutputNodeTopInfo(const domi::caffe::NetParameter if (!find_node_falg || layer_name.empty()) { ErrorManager::GetInstance().ATCReportErrMessage( "E11032", {"name", "reason"}, {top_name.c_str(), "Cannot find the top_name, which is invalid"}); - GELOGE(PARAM_INVALID, "Cannot find top_name[%s], which is invalid", top_name.c_str()); + GELOGE(PARAM_INVALID, "[Check][Param]Cannot find top_name[%s], which is invalid", top_name.c_str()); return PARAM_INVALID; } GELOGD("Node[%s] find top_name[%s], top_index[%d]", layer_name.c_str(), top_name.c_str(), top_index); @@ -885,7 +903,7 @@ Status CaffeModelParser::AddBlobsToMap(const domi::caffe::LayerParameter &layer, std::map &inplace_blob_name_remapping) { if (layer.top_size() <= 0) { ErrorManager::GetInstance().ATCReportErrMessage("E19011", {"opname"}, {layer.name()}); - GELOGE(FAILED, "The output size of layer %s needs to be greater than zero.", layer.name().c_str()); + GELOGE(FAILED, "[Check][Size]The output size of layer %s needs to be greater than zero.", layer.name().c_str()); return FAILED; } @@ -963,7 +981,7 @@ Status CaffeModelParser::GetCustomOp(const domi::caffe::LayerParameter &layer, v const google::protobuf::Message *layer_message = reinterpret_cast(&layer); Status status = CreateCustomOperator(op_name, op_type, layer_message, 0, operators); if (status != SUCCESS || operators.empty()) { - GELOGE(status, "CreateCustomOperator failed, name: %s, type: %s.", op_name.c_str(), op_type.c_str()); + GELOGE(status, "[Create][CustomOperator] failed, name: %s, type: %s.", op_name.c_str(), op_type.c_str()); return FAILED; } if (IsOpAttrEmpty(operators[0], kBuiltin)) { @@ -993,7 +1011,8 @@ Status CaffeModelParser::ParseOpParam(const domi::caffe::LayerParameter &layer, status = GetCustomOp(layer, custom_operator); if (status != SUCCESS || custom_operator.empty()) { ErrorManager::GetInstance().ATCReportErrMessage("E11010", {"opname", "optype"}, {layer.name(), op_type}); - GELOGE(status, "Parse Params for custom op [%s] failed, optype [%s]", layer.name().c_str(), op_type.c_str()); + GELOGE(status, "[Get][CustomOp]failed for op [%s], optype [%s]", + layer.name().c_str(), op_type.c_str()); return status; } status = caffe_custom_op_parser->ParseParams(custom_operator[0], op); @@ -1001,7 +1020,7 @@ Status CaffeModelParser::ParseOpParam(const domi::caffe::LayerParameter &layer, if (status != SUCCESS) { ErrorManager::GetInstance().ATCReportErrMessage("E11010", {"opname", "optype"}, {layer.name(), op_type}); - GELOGE(status, "Parse Params for op [%s] fail, optype [%s]", layer.name().c_str(), op_type.c_str()); + GELOGE(status, "[Parse][Params] for op [%s] fail, optype [%s]", layer.name().c_str(), op_type.c_str()); return status; } @@ -1019,7 +1038,7 @@ Status CaffeModelParser::AddNode(const domi::caffe::LayerParameter &layer, ge::C // Judge whether there is Python_Param. If not, it is illegal if (!layer.has_python_param()) { ErrorManager::GetInstance().ATCReportErrMessage("E11006", {"opname"}, {layer.name()}); - GELOGE(FAILED, "Op[%s] optype[Python] has no python_param.", layer.name().c_str()); + GELOGE(FAILED, "[Check][Param]Op[%s] optype[Python] has no python_param.", layer.name().c_str()); return FAILED; } @@ -1027,15 +1046,13 @@ Status CaffeModelParser::AddNode(const domi::caffe::LayerParameter &layer, ge::C // Judge whether it is a Proposal operator if (python_param.layer() == kProposalLayer) { ErrorManager::GetInstance().ATCReportErrMessage("E11031", {"opname"}, {layer.name()}); - GELOGE(PARAM_INVALID, "Python Layer %s need to be rewritten according to product directions", + GELOGE(PARAM_INVALID, "[Check][Param]Python Layer %s need to be rewritten according to product directions", layer.name().c_str()); return FAILED; } else { ErrorManager::GetInstance().ATCReportErrMessage("E11007", {"opname"}, {python_param.layer()}); - GELOGE(FAILED, - "If optype is [Python], opname must be [ProposalLayer], " - "but actual opname is [%s].", - python_param.layer().c_str()); + GELOGE(FAILED, "[Check][Param]If optype is [Python], opname must be [ProposalLayer], " + "but actual opname is [%s].", python_param.layer().c_str()); return FAILED; } } else { @@ -1051,16 +1068,12 @@ Status CaffeModelParser::AddNode(const domi::caffe::LayerParameter &layer, ge::C if (iter == caffe_op_map.end()) { if (op_type == kDetectionOutput) { ErrorManager::GetInstance().ATCReportErrMessage("E11008"); - GELOGE(FAILED, - "Op type 'DetectionOutput' is confused. " - "Suggest you modify the model file and use a explicit type, such as 'FSRDetectionOutput' or " - "'SSDDetectionOutput'."); + GELOGE(FAILED, "[Check][Type] Op type 'DetectionOutput' is confused. Suggest you modify the model file " + "and use a explicit type, such as 'FSRDetectionOutput' or 'SSDDetectionOutput'."); } else { ErrorManager::GetInstance().ATCReportErrMessage("E11009", {"opname", "optype"}, {layer.name(), op_type}); - GELOGE(FAILED, - "Unsupport op[%s] optype[%s], " - "you should customize the op at first.", - layer.name().c_str(), op_type.c_str()); + GELOGE(FAILED, "[Check][Type]Unsupport op[%s] optype[%s], you should customize the op at first.", + layer.name().c_str(), op_type.c_str()); } return FAILED; @@ -1108,7 +1121,8 @@ Status CaffeModelParser::AddNode(const domi::caffe::LayerParameter &layer, ge::C ge::NodePtr node = graph->AddNode(op); if (node == nullptr) { - GELOGE(FAILED, "call Graph add node failed, op name:%s, type:%s", op->GetName().c_str(), op->GetType().c_str()); + REPORT_INNER_ERROR("E19999", "AddNode failed, op name:%s, type:%s", op->GetName().c_str(), op->GetType().c_str()); + GELOGE(FAILED, "[Add][Node] failed, op name:%s, type:%s", op->GetName().c_str(), op->GetType().c_str()); return FAILED; } @@ -1121,7 +1135,8 @@ Status CaffeModelParser::AddNode(const domi::caffe::LayerParameter &layer, ge::C Status status; status = caffe_op_parser->AddConstInput(node); if (status != SUCCESS) { - GELOGE(FAILED, "add const input to node %s fail.", node->GetOpDesc()->GetName().c_str()); + REPORT_CALL_ERROR("E19999", "AddConstInput failed for node:%s", node->GetOpDesc()->GetName().c_str()); + GELOGE(FAILED, "[Add][ConstInput] to node %s fail.", node->GetOpDesc()->GetName().c_str()); return status; } @@ -1171,7 +1186,7 @@ Status CaffeModelParser::AddTensorDescToOpDescByIr(ge::OpDescPtr &op_desc, const GE_CHECK_NOTNULL(op_desc); Status ret = AddTensorDescToOpDesc(op_desc, layer); if (ret != SUCCESS) { - GELOGE(FAILED, "op[%s] type[%s] AddTensorDescToOpDesc failed.", layer.name().c_str(), op_type.c_str()); + GELOGE(FAILED, "[Add][TensorDesc]To OpDesc failed for op[%s] type[%s].", layer.name().c_str(), op_type.c_str()); } return ret; } @@ -1181,7 +1196,8 @@ Status CaffeModelParser::AddTensorDescToOpDescByIr(ge::OpDescPtr &op_desc, const ge::Operator op_factory = ge::OperatorFactory::CreateOperator(layer_name, op_type); if (op_factory.GetName() != layer.name()) { ErrorManager::GetInstance().ATCReportErrMessage("E11011", {"opname", "optype"}, {layer_name, op_type}); - GELOGE(FAILED, "IR for op[%s] optype[%s] is not registered.", layer_name.c_str(), op_type.c_str()); + GELOGE(FAILED, "[Invoke][CreateOperator]IR for op[%s] optype[%s] is not registered.", + layer_name.c_str(), op_type.c_str()); return FAILED; } else { op_desc = ge::OpDescUtils::GetOpDescFromOperator(op_factory); @@ -1237,10 +1253,10 @@ Status CaffeModelParser::AddEdges(ge::ComputeGraphPtr &graph) { auto t_iter = top_blobs_map_.find(b_iter->first); // Unable to find the output corresponding to the input, error reported if (t_iter == top_blobs_map_.end()) { - ErrorManager::GetInstance().ATCReportErrMessage( - "E11012", {"bottom_blob", "layer", "bottom_index"}, - {b_iter->first, b_iter->second[0].first, std::to_string(b_iter->second[0].second)}); - GELOGE(FAILED, "Unknown bottom blob '%s', in layer '%s', bottom index:%d.", b_iter->first.c_str(), + ErrorManager::GetInstance().ATCReportErrMessage("E11012", {"bottom_blob", "layer", "bottom_index"}, + {b_iter->first, b_iter->second[0].first, + std::to_string(b_iter->second[0].second)}); + GELOGE(FAILED, "[Find][Blob]Unknown bottom blob '%s', in layer '%s', bottom index:%d.", b_iter->first.c_str(), b_iter->second[0].first.c_str(), b_iter->second[0].second); return PARAM_INVALID; } @@ -1268,10 +1284,10 @@ Status CaffeModelParser::AddEdges(ge::ComputeGraphPtr &graph) { ge::InDataAnchorPtr in_archor_ptr = bottom_node_iter->second->GetInDataAnchor(bottom_blob_layer_pair.second); GE_CHECK_NOTNULL(in_archor_ptr); GE_IF_BOOL_EXEC(ge::GraphUtils::AddEdge(out_archor_ptr, in_archor_ptr) != ge::GRAPH_SUCCESS, - ErrorManager::GetInstance().ATCReportErrMessage( - "E11013", {"opname1", "opname2"}, - {top_node_iter->second->GetName(), bottom_node_iter->second->GetName()}); - GELOGE(INTERNAL_ERROR, "Add link failed from op[%s] to op[%s].", + ErrorManager::GetInstance().ATCReportErrMessage("E11013", {"opname1", "opname2"}, + {top_node_iter->second->GetName(), + bottom_node_iter->second->GetName()}); + GELOGE(INTERNAL_ERROR, "[Invoke][AddEdge]Add link failed from op[%s] to op[%s].", top_node_iter->second->GetName().c_str(), bottom_node_iter->second->GetName().c_str()); return INTERNAL_ERROR;); auto op_desc = bottom_node_iter->second->GetOpDesc(); @@ -1281,15 +1297,16 @@ Status CaffeModelParser::AddEdges(ge::ComputeGraphPtr &graph) { (void) op_desc->UpdateInputDesc((static_cast(in_archor_ptr->GetIdx())), out_op_desc->GetOutputDesc(static_cast(out_archor_ptr->GetIdx()))); } - GE_IF_BOOL_EXEC(top_node_iter == node_map.end(), ErrorManager::GetInstance().ATCReportErrMessage( - "E11014", {"opname"}, {top_blob_layer_pair.first}); - GELOGE(INTERNAL_ERROR, "Failed to find top layer name: %s.", top_blob_layer_pair.first.c_str()); + GE_IF_BOOL_EXEC(top_node_iter == node_map.end(), + ErrorManager::GetInstance().ATCReportErrMessage("E11014", {"opname"}, + {top_blob_layer_pair.first}); + GELOGE(INTERNAL_ERROR, "[Find][TopLayer] %s failed.", top_blob_layer_pair.first.c_str()); + return ge::FAILED;) + GE_IF_BOOL_EXEC(top_node_iter == node_map.end(), + ErrorManager::GetInstance().ATCReportErrMessage("E11015", {"opname"}, + {bottom_blob_layer_pair.first}); + GELOGE(INTERNAL_ERROR, "[Find][BottomLayer] %s failed.", bottom_blob_layer_pair.first.c_str()); return ge::FAILED;) - GE_IF_BOOL_EXEC( - top_node_iter == node_map.end(), - ErrorManager::GetInstance().ATCReportErrMessage("E11015", {"opname"}, {bottom_blob_layer_pair.first}); - GELOGE(INTERNAL_ERROR, "Failed to find bottom layer name: %s.", bottom_blob_layer_pair.first.c_str()); - return ge::FAILED;) } } } @@ -1329,14 +1346,11 @@ Status CaffeModelParser::AddUserOutNodesTop() { if (static_cast(out_pair.second) >= (layer_iter->second).size()) { ErrorManager::GetInstance().ATCReportErrMessage( "E11016", {"opname", "outputindex", "totlaloutputindex", "inputindex", "totlalinputindex"}, - {out_pair.first.c_str(), std::to_string(out_pair.second), - std::to_string((layer_iter->second).size()), std::to_string(index), - std::to_string(net_output_num)}); - GELOGE(INTERNAL_ERROR, - "Add op %s to NetOutput faild, current node output index:%d should < %zu. NetOutput" - "input_index:%d should < %u.", - out_pair.first.c_str(), out_pair.second, (layer_iter->second).size(), index, - net_output_num); + {out_pair.first.c_str(), std::to_string(out_pair.second), std::to_string((layer_iter->second).size()), + std::to_string(index), std::to_string(net_output_num)}); + GELOGE(INTERNAL_ERROR, "[Check][Size]Add op %s to NetOutput faild, current node output index:%d should < %zu. " + "NetOutput input_index:%d should < %u.", out_pair.first.c_str(), out_pair.second, + (layer_iter->second).size(), index, net_output_num); return INTERNAL_ERROR; } @@ -1349,7 +1363,8 @@ Status CaffeModelParser::AddUserOutNodesTop() { ++index; } else { ErrorManager::GetInstance().ATCReportErrMessage("E11017", {"opname"}, {out_pair.first}); - GELOGE(PARAM_INVALID, "Can not find out_node:%s, you should check --out_nodes.", out_pair.first.c_str()); + GELOGE(PARAM_INVALID, "[Find][Node]Can not find out_node:%s, you should check --out_nodes.", + out_pair.first.c_str()); return PARAM_INVALID; } } @@ -1374,7 +1389,8 @@ Status CaffeModelParser::AddOutputTop(const domi::caffe::NetParameter &proto_mes auto t_iter = top_blobs_map_.find(top); - GE_RETURN_WITH_LOG_IF_FALSE(t_iter != top_blobs_map_.end(), "Failed to find top: %s, layer name:%s", top.c_str(), + GE_RETURN_WITH_LOG_IF_FALSE(t_iter != top_blobs_map_.end(), + "[Check][Param]Failed to find top: %s, layer name:%s", top.c_str(), layer.name().c_str()); // Find the bottom blob corresponding to the top blob @@ -1447,19 +1463,20 @@ Status CaffeModelParser::PreCheck(const domi::caffe::NetParameter &net) { string mode = "^[A-Za-z0-9./_-]+$"; if (!ge::parser::ValidateStr(layer.name(), mode)) { ErrorManager::GetInstance().ATCReportErrMessage("E11018", {"opname"}, {layer.name()}); - GELOGE(ge::FAILED, - "Parse caffe pbtxt validate op[%s] failed, opname can only contain " - "'a-z' 'A-Z' '0-9' '-' '.' '_' '/'", - layer.name().c_str()); + GELOGE(ge::FAILED, "[Invoke][ValidateStr]Parse caffe pbtxt validate op[%s] failed, opname can only contain " + "'a-z' 'A-Z' '0-9' '-' '.' '_' '/'", layer.name().c_str()); return ge::FAILED; } GE_RETURN_WITH_LOG_IF_ERROR(PreChecker::Instance().AddOp(&layer, layer.name(), layer.type()), - "Add layer to PreChecker failed, layer name: %s.", layer.name().c_str()); + "[Invoke][AddOp]Add layer to PreChecker failed, layer name: %s.", + layer.name().c_str()); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(PreChecker::Instance().CheckName(&layer) != SUCCESS, return FAILED, - "Check op[%s] failed, name repeat in caffe prototxt.", layer.name().c_str()); + "[Invoke][CheckName]Check op[%s] failed, name repeat in caffe prototxt.", + layer.name().c_str()); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(PreChecker::Instance().CheckType(&layer) != SUCCESS, return FAILED, - "Check op[%s]'s optype failed, type is not supported.", layer.name().c_str()); + "[Invoke][CheckType]Check op[%s]'s optype failed, type is not supported.", + layer.name().c_str()); } return SUCCESS; @@ -1469,23 +1486,22 @@ Status CaffeModelParser::ParseFromMemory(const char *data, uint32_t size, ge::Co ErrorManager::GetInstance().SetStage(ErrorMessage::kModelCompile, ErrorMessage::kParser); bool has_error = false; - GE_CHK_BOOL_RET_STATUS(data != nullptr, FAILED, "model data is nullptr."); - GE_CHK_BOOL_RET_STATUS(graph != nullptr, FAILED, "graph is nullptr."); + GE_CHK_BOOL_RET_STATUS(data != nullptr, FAILED, "[Check][Param]model data is nullptr."); + GE_CHK_BOOL_RET_STATUS(graph != nullptr, FAILED, "[Check][Param]graph is nullptr."); domi::caffe::NetParameter proto_message; // Get Caffe network model information if (!ge::parser::ReadProtoFromMem(data, static_cast(size), &proto_message)) { - GELOGE(FAILED, "read proto from text ret fail"); + GELOGE(FAILED, "[Read][ProtoFromMem] ret fail"); return FAILED; } - GE_CHK_BOOL_RET_STATUS( - !(proto_message.layer_size() == 0 && proto_message.layers_size() > 0), FAILED, - "The model file is consisted of layers-structure which is deprecated in caffe and unsupport in OMG. " + GE_CHK_BOOL_RET_STATUS(!(proto_message.layer_size() == 0 && proto_message.layers_size() > 0), FAILED, + "[Check][Size]The model file is consisted of layers-structure which is deprecated in caffe and unsupport in OMG." "It is recommended to convert layers-structure to layer-structure by caffe tool."); GE_CHK_BOOL_RET_STATUS((proto_message.layer_size() != 0), FAILED, - "net layer num is zero, prototxt file may be invalid."); + "[Check][Size]net layer num is zero, prototxt file may be invalid."); // Set network name GE_IF_BOOL_EXEC((proto_message.has_name()), graph->SetName(proto_message.name())); @@ -1495,7 +1511,7 @@ Status CaffeModelParser::ParseFromMemory(const char *data, uint32_t size, ge::Co has_error = PreChecker::Instance().HasError(); if (ReorderInput(proto_message) != SUCCESS) { - GELOGE(INTERNAL_ERROR, "Reorder input failed."); + GELOGE(INTERNAL_ERROR, "[Reorder][Input] failed."); return INTERNAL_ERROR; } @@ -1503,7 +1519,7 @@ Status CaffeModelParser::ParseFromMemory(const char *data, uint32_t size, ge::Co // Process input of type input CHECK_FALSE_EXEC(ParseInput(proto_message, input_data_flag) == SUCCESS, has_error = true; - GELOGE(FAILED, "ParseInput ret fail.")); + GELOGE(FAILED, "[Parse][Input] ret fail.")); int32_t layer_count = proto_message.layer_size(); std::map inplace_blob_name_remapping; @@ -1517,11 +1533,17 @@ Status CaffeModelParser::ParseFromMemory(const char *data, uint32_t size, ge::Co for (int32_t i = 0; i < layer_count; i++) { domi::caffe::LayerParameter &layer = const_cast(proto_message.layer(i)); - GE_CHK_BOOL_EXEC_INFO(CheckValidLayer(layer), continue, "layer phase is train, skip this layer, name:%s, type:%s.", + GE_CHK_BOOL_EXEC_INFO(CheckValidLayer(layer), continue, + "[Check][Layer]layer phase is train, skip this layer, name:%s, type:%s.", layer.name().c_str(), layer.type().c_str()); CHECK_FALSE_EXEC(!((layer.type() == ge::parser::DATA_TYPE) && (input_data_flag == true)), has_error = true; - GELOGE(FAILED, "net %s has input and data layer simultaneously.", proto_message.name().c_str())); + REPORT_INNER_ERROR("E19999", "net %s has input and data layer simultaneously, check invalid." + "layer name:%s, layer type:%s", proto_message.name().c_str(), + layer.name().c_str(), layer.type().c_str()); + GELOGE(FAILED, "[Check][Layer]net %s has input and data layer simultaneously, check invalid." + "layer name:%s, layer type:%s", proto_message.name().c_str(), + layer.name().c_str(), layer.type().c_str())); // All layer names cannot be duplicate // 20181208 Modified to support the existence of duplicate operators in Caffe model @@ -1540,7 +1562,7 @@ Status CaffeModelParser::ParseFromMemory(const char *data, uint32_t size, ge::Co // Do not exit immediately when there is an error, wait until all errors are collected before exiting Status ret = AddNode(layer, graph); if (ret != SUCCESS) { - GELOGE(FAILED, "Caffe parser add node fail."); + GELOGE(FAILED, "[Add][Node]failed for layer:%s.", layer.name().c_str()); has_error = true; continue; } @@ -1556,25 +1578,28 @@ Status CaffeModelParser::ParseFromMemory(const char *data, uint32_t size, ge::Co GE_IF_BOOL_EXEC((v_param_names.size() > 0), layer_params_map.emplace(layer.name(), v_param_names)); GE_RETURN_WITH_LOG_IF_ERROR(AddBlobsToMap(layer, inplace_blob_name_remapping), - "Caffe parser add blobs to map ret fail."); + "[Add][Blobs]To Map ret fail, layer:%s.", layer.name().c_str()); } // Find a layer with the same param name and save it to graph GE_RETURN_WITH_LOG_IF_ERROR(FindShareParamLayers(layer_params_map), - "Caffe parser find share param layers map ret fail."); + "[Find][ShareParamLayers] by Caffe parser ret fail."); // Exit if an error occurs GE_IF_BOOL_EXEC(has_error, return FAILED); - GE_CHK_BOOL_RET_STATUS(top_blobs_map_.size() > 0, FAILED, "current net has no output!"); + GE_CHK_BOOL_RET_STATUS(top_blobs_map_.size() > 0, FAILED, "[Check][Size]current net has no output!"); - GE_RETURN_WITH_LOG_IF_ERROR(AddEdges(graph), "Caffe parser add edges fail."); + GE_RETURN_WITH_LOG_IF_ERROR(AddEdges(graph), "[Add][Edges] failed by Caffe parser, graph:%s.", + graph->GetName().c_str()); if (!(ge::GetParserContext().user_out_nodes.empty())) { - GE_RETURN_WITH_LOG_IF_ERROR(AddUserOutNodesTop(), "Caffe parser add top_name for user out nodes failed."); + GE_RETURN_WITH_LOG_IF_ERROR(AddUserOutNodesTop(), "[Add][UserOutNodesTop] by Caffe parser failed."); } else { - GE_RETURN_WITH_LOG_IF_ERROR(AddOutputTop(proto_message), "Caffe parser add top_name for output fail."); + GE_RETURN_WITH_LOG_IF_ERROR(AddOutputTop(proto_message), "[Add][OutputTop] by Caffe parser failed."); } - GE_RETURN_WITH_LOG_IF_ERROR(graph->TopologicalSorting(), "Caffe parser call graph topo sort fail."); + GE_RETURN_WITH_LOG_IF_ERROR(graph->TopologicalSorting(), + "[Call][TopologicalSorting] by Caffe parser failed, graph:%s.", + graph->GetName().c_str()); auto nodes = graph->GetDirectNode(); GELOGI("graph node size = %zu.", nodes.size()); @@ -1596,7 +1621,7 @@ Status CaffeModelParser::Parse(const char *model_path, ge::Graph &graph) { Status ret = Parse(model_path, compute_graph); if (ret != SUCCESS) { - GELOGE(ret, "Parser model for graph %s failed.", graph.GetName().c_str()); + GELOGE(ret, "[Parser][Model] %s for graph %s failed.", model_path, graph.GetName().c_str()); return ret; } @@ -1621,7 +1646,7 @@ Status CaffeModelParser::SaveDataLayerTops(const domi::caffe::LayerParameter &la string name = layer.name(); if (node_map.find(name) == node_map.end()) { ErrorManager::GetInstance().ATCReportErrMessage("E11034", {"opname"}, {name}); - GELOGE(FAILED, "Node can not be found by layer name: %s", name.c_str()); + GELOGE(FAILED, "[Find][Node]Node can not be found by layer name: %s", name.c_str()); return FAILED; } @@ -1632,7 +1657,7 @@ Status CaffeModelParser::SaveDataLayerTops(const domi::caffe::LayerParameter &la if (layer.top_size() != 1) { ErrorManager::GetInstance().ATCReportErrMessage("E11035", {"opname", "size"}, {name, std::to_string(layer.top_size())}); - GELOGE(FAILED, "Data layer[%s] top size must be 1, real size: %d", name.c_str(), layer.top_size()); + GELOGE(FAILED, "[Check][Type]Data layer[%s] top size must be 1, real size: %d", name.c_str(), layer.top_size()); return FAILED; } @@ -1640,7 +1665,7 @@ Status CaffeModelParser::SaveDataLayerTops(const domi::caffe::LayerParameter &la auto data_top_names = ge::GetParserContext().data_top_names; if (find(data_top_names.begin(), data_top_names.end(), top_name) != data_top_names.end()) { ErrorManager::GetInstance().ATCReportErrMessage("E11036", {"topname"}, {top_name}); - GELOGE(FAILED, "Different data node can not have same top name: %s.", top_name.c_str()); + GELOGE(FAILED, "[Check][Node]Different data node can not have same top name: %s.", top_name.c_str()); return FAILED; } ge::GetParserContext().data_top_names.push_back(top_name); @@ -1661,7 +1686,7 @@ Status CaffeModelParser::Parse(const char *model_path, ge::ComputeGraphPtr &grap // Get Caffe network model information if (ReadModelWithoutWarning(model_path, &proto_message) != SUCCESS) { - GELOGE(FAILED, "read caffe model from text ret fail, model path: %s.", model_path); + GELOGE(FAILED, "[Read][Model] from text ret fail, model path: %s.", model_path); return FAILED; } @@ -1670,7 +1695,7 @@ Status CaffeModelParser::Parse(const char *model_path, ge::ComputeGraphPtr &grap string caffe_proto_path = ge::GetParserContext().caffe_proto_path + "caffe.proto"; Status result = CustomProtoParse(model_path, custom_proto_path, caffe_proto_path, custom_operator_); if (result != SUCCESS) { - GELOGE(FAILED, "Parse model by custom proto failed, model: %s.", model_path); + GELOGE(FAILED, "[Parse][Model] by custom proto failed, model path: %s.", model_path); return FAILED; } @@ -1678,12 +1703,12 @@ Status CaffeModelParser::Parse(const char *model_path, ge::ComputeGraphPtr &grap proto_message.layer_size() == 0 && proto_message.layers_size() > 0, ErrorManager::GetInstance().ATCReportErrMessage("E11021", {"realpath"}, {model_path}); return FAILED, - "The model file[%s] is consisted of layers-structure which is deprecated in Caffe " + "[Check][Size]The model file[%s] is consisted of layers-structure which is deprecated in Caffe " "and unsupported in ATC. The \"layers\" should be changed to \"layer\".", model_path); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((proto_message.layer_size() == 0), ErrorManager::GetInstance().ATCReportErrMessage("E11022"); - return FAILED, "net layer num is zero, prototxt file may be invalid."); + return FAILED, "[Check][Size]net layer num is zero, prototxt file may be invalid."); // Set network name GE_IF_BOOL_EXEC((proto_message.has_name() && !proto_message.name().empty()), graph->SetName(proto_message.name())); @@ -1692,12 +1717,13 @@ Status CaffeModelParser::Parse(const char *model_path, ge::ComputeGraphPtr &grap GE_RETURN_IF_ERROR(PreCheck(proto_message)); if (PreChecker::Instance().HasError()) { - GELOGE(INTERNAL_ERROR, "Precheck failed. Please read check report."); + REPORT_INNER_ERROR("E19999", "Precheck failed. Please read check report."); + GELOGE(INTERNAL_ERROR, "[Has][Error]Precheck failed. Please read check report."); return FAILED; } if (ReorderInput(proto_message) != SUCCESS) { - GELOGE(INTERNAL_ERROR, "Reorder input failed."); + GELOGE(INTERNAL_ERROR, "[Reorder][Input] failed."); return INTERNAL_ERROR; } @@ -1705,14 +1731,14 @@ Status CaffeModelParser::Parse(const char *model_path, ge::ComputeGraphPtr &grap // Process input of type input CHECK_FALSE_EXEC(ParseInput(proto_message, input_data_flag) == SUCCESS, has_error = true; - GELOGE(FAILED, "ParseInput ret fail.")); + GELOGE(FAILED, "[Parse][Input] ret fail.")); int32_t layer_count = proto_message.layer_size(); if (!ge::GetParserContext().user_out_nodes_top_vec.empty()) { GELOGW("The out_put info has top_name items."); GE_RETURN_WITH_LOG_IF_ERROR(ParseOutputNodeTopInfo(proto_message), - "Caffe parser parse output node-top info failed."); + "[Parse][OutputNodeTopInfo] failed."); ge::GetParserContext().user_out_nodes_top_vec.clear(); } @@ -1727,11 +1753,14 @@ Status CaffeModelParser::Parse(const char *model_path, ge::ComputeGraphPtr &grap for (int32_t i = 0; i < layer_count; i++) { domi::caffe::LayerParameter &layer = const_cast(proto_message.layer(i)); SaveOrigionLayerTops(layer); - GE_CHK_BOOL_EXEC_INFO(CheckValidLayer(layer), continue, "layer phase is train, skip this layer, name:%s, type:%s.", + GE_CHK_BOOL_EXEC_INFO(CheckValidLayer(layer), continue, + "[Check][Layer]layer phase is train, skip this layer, name:%s, type:%s.", layer.name().c_str(), layer.type().c_str()); CHECK_FALSE_EXEC(!((layer.type() == ge::parser::DATA_TYPE) && (input_data_flag == true)), has_error = true; - GELOGE(FAILED, "net %s has input and data layer simultaneously.", proto_message.name().c_str())); + GELOGE(FAILED, "[Check][Layer]net %s has input and data layer simultaneously, check invalid." + "layer name:%s, layer type:%s", proto_message.name().c_str(), + layer.name().c_str(), layer.type().c_str())); // All layer names cannot be duplicate // Modified to support the existence of duplicate operators in Caffe model @@ -1750,7 +1779,7 @@ Status CaffeModelParser::Parse(const char *model_path, ge::ComputeGraphPtr &grap // Do not exit immediately when there is an error, wait until all errors are collected before exiting Status ret = AddNode(layer, graph); if (ret != SUCCESS) { - GELOGE(FAILED, "Caffe parser add node fail."); + GELOGE(FAILED, "[Add][Node] fail, layer:%s.", layer.name().c_str()); has_error = true; continue; } @@ -1766,29 +1795,30 @@ Status CaffeModelParser::Parse(const char *model_path, ge::ComputeGraphPtr &grap GE_IF_BOOL_EXEC((v_param_names.size() > 0), layer_params_map.emplace(layer.name(), v_param_names)); GE_RETURN_WITH_LOG_IF_ERROR(AddBlobsToMap(layer, inplace_blob_name_remapping), - "Caffe parser add blobs to map ret fail."); + "[Add][blobs] to map ret fail, layer:%s.", layer.name().c_str()); if (SaveDataLayerTops(layer) != SUCCESS) { - GELOGE(FAILED, "Caffe parse: save data layer tops failed."); + GELOGE(FAILED, "[Save][DataLayerTops] failed, layer:%s.", layer.name().c_str()); return FAILED; } } // Find a layer with the same param name and save it to graph GE_RETURN_WITH_LOG_IF_ERROR(FindShareParamLayers(layer_params_map), - "Caffe parser find share param layers map ret fail."); + "[Find][ShareParamLayers] ret fail."); // Exit if an error occurs GE_IF_BOOL_EXEC(has_error, return FAILED); - GE_CHK_BOOL_RET_STATUS(top_blobs_map_.size() > 0, FAILED, "current net has no output!"); + GE_CHK_BOOL_RET_STATUS(top_blobs_map_.size() > 0, FAILED, "[Check][Size]current net has no output!"); - GE_RETURN_WITH_LOG_IF_ERROR(AddEdges(graph), "Caffe parser add edges fail."); + GE_RETURN_WITH_LOG_IF_ERROR(AddEdges(graph), "[Add][Edges] fail, graph:%s.", graph->GetName().c_str()); if (!(ge::GetParserContext().user_out_nodes.empty())) { - GE_RETURN_WITH_LOG_IF_ERROR(AddUserOutNodesTop(), "Caffe parser add top_name for user out nodes failed."); + GE_RETURN_WITH_LOG_IF_ERROR(AddUserOutNodesTop(), "[Add][UserOutNodesTop] failed."); } else { - GE_RETURN_WITH_LOG_IF_ERROR(AddOutputTop(proto_message), "Caffe parser add top_name for output fail."); + GE_RETURN_WITH_LOG_IF_ERROR(AddOutputTop(proto_message), "[Add][OutputTop] failed."); } - GE_RETURN_WITH_LOG_IF_ERROR(graph->TopologicalSorting(), "Caffe parser call graph topo sort fail."); + GE_RETURN_WITH_LOG_IF_ERROR(graph->TopologicalSorting(), "[Call][TopologicalSorting] failed, graph:%s.", + graph->GetName().c_str()); auto nodes = graph->GetDirectNode(); GELOGI("graph node size = %zu.", nodes.size()); @@ -1825,13 +1855,13 @@ Status CaffeModelParser::FindShareParamLayers(const std::map(), j, true); return ModelSaver::SaveJsonToFile(json_file, j); } @@ -1849,14 +1879,19 @@ Status CaffeModelParser::ReorderInput(domi::caffe::NetParameter &net) { if (it.moveType == domi::OMG_INPUT_REORDER) { auto inputs = layer->bottom(); if (static_cast(inputs.size()) != it.input_order.size()) { - GELOGE(INTERNAL_ERROR, "Size of input is mismatched, new order size is %zu, input size is %d.", + REPORT_INNER_ERROR("E19999", "Size of input is mismatched, check invalid," + "new order size is %zu, input size is %d.", it.input_order.size(), inputs.size()); + GELOGE(INTERNAL_ERROR, "[Check][Size]Size of input is mismatched, new order size is %zu, input size is %d.", it.input_order.size(), inputs.size()); return INTERNAL_ERROR; } for (size_t j = 0; j < it.input_order.size(); ++j) { int new_index = it.input_order[j]; if (new_index < 0 || new_index >= inputs.size()) { - GELOGE(INTERNAL_ERROR, "New order of %s has invalid index %d.", layer->name().c_str(), new_index); + REPORT_INNER_ERROR("E19999", "New order of %s has invalid index %d, which is out of range, " + "inputs size:%d.", layer->name().c_str(), new_index, inputs.size()); + GELOGE(INTERNAL_ERROR, "[Check][Param]New order of %s has invalid index %d, which is out of range, " + "inputs size:%d.", layer->name().c_str(), new_index, inputs.size()); return INTERNAL_ERROR; } layer->set_bottom(j, inputs[new_index]); @@ -1871,12 +1906,14 @@ Status CaffeModelParser::ReorderInput(domi::caffe::NetParameter &net) { Status CaffeWeightsParser::ParseFromMemory(const char *data, uint32_t size, ge::ComputeGraphPtr &graph) { ErrorManager::GetInstance().SetStage(ErrorMessage::kModelCompile, ErrorMessage::kParser); if (data == nullptr) { - GELOGE(PARAM_INVALID, "Caffe weights data is nullptr"); + REPORT_INNER_ERROR("E19999", "param data is nullptr."); + GELOGE(PARAM_INVALID, "[Check][Param]Caffe weights data is nullptr"); return PARAM_INVALID; } if (graph == nullptr) { - GELOGE(PARAM_INVALID, "Caffe weights graph is nullptr"); + REPORT_INNER_ERROR("E19999", "param graph is nullptr."); + GELOGE(PARAM_INVALID, "[Check][Param]Caffe weights graph is nullptr"); return PARAM_INVALID; } @@ -1884,13 +1921,14 @@ Status CaffeWeightsParser::ParseFromMemory(const char *data, uint32_t size, ge:: NetParameter proto; bool success = ge::parser::ReadProtoFromArray(reinterpret_cast(data), static_cast(size), &proto); if (!success) { - GELOGE(domi::PARSE_WEIGHTS_FAILED, "ReadProto from Memory fail"); + REPORT_CALL_ERROR("E19999", "ReadProtoFromArray failed."); + GELOGE(domi::PARSE_WEIGHTS_FAILED, "[Read][Proto] from Memory fail"); return domi::PARSE_WEIGHTS_FAILED; } // Convert netparameter to opdef and save to graph Status status = ConvertNetParameter(proto, graph); - GE_IF_BOOL_EXEC(status != SUCCESS, GELOGE(FAILED, "Parse weights ConvertNetParameter failed, status=%d", status); + GE_IF_BOOL_EXEC(status != SUCCESS, GELOGE(FAILED, "[Convert][NetParameter] failed, status=%d", status); return domi::PARSE_WEIGHTS_FAILED;); return SUCCESS; @@ -1904,7 +1942,7 @@ Status CaffeWeightsParser::Parse(const char *file, ge::Graph &graph) { Status ret = Parse(file, compute_graph); if (ret != SUCCESS) { - GELOGE(ret, "Parser weight for graph %s failed.", graph.GetName().c_str()); + GELOGE(ret, "[Parser][Weight] %s for graph %s failed.", file, graph.GetName().c_str()); return ret; } @@ -1914,12 +1952,14 @@ Status CaffeWeightsParser::Parse(const char *file, ge::Graph &graph) { Status CaffeWeightsParser::Parse(const char *file, ge::ComputeGraphPtr &graph) { if (file == nullptr) { - GELOGE(FAILED, "Caffe weights parse fail, Parameter file invalid"); + REPORT_INNER_ERROR("E19999", "param file is nullptr, check invalid."); + GELOGE(FAILED, "[Check][Param]Caffe weights parse fail, Parameter file invalid"); return PARAM_INVALID; } if (graph == nullptr) { - GELOGE(FAILED, "Caffe weights parse fail, Parameter graph invalid"); + REPORT_INNER_ERROR("E19999", "param graph is nullptr, check invalid."); + GELOGE(FAILED, "[Check][Param]Caffe weights parse fail, Parameter graph invalid"); return PARAM_INVALID; } @@ -1938,7 +1978,9 @@ Status CaffeWeightsParser::Parse(const char *file, ge::ComputeGraphPtr &graph) { } else { if (proto_file_parser.CombineProtoFile(caffe_proto_path.c_str(), custom_proto_path.c_str(),\ fusion_proto_file) != SUCCESS) { - GELOGE(FAILED, "Create tmp fusion proto file from caffe and custom proto failed."); + REPORT_INNER_ERROR("E19999", "CombineProtoFile failed, caffe_proto_path:%s, custom_proto_path:%s.", + caffe_proto_path.c_str(), custom_proto_path.c_str()); + GELOGE(FAILED, "[Invoke][CombineProtoFile]Create tmp fusion proto file from caffe and custom proto failed."); return FAILED; } } @@ -1946,14 +1988,16 @@ Status CaffeWeightsParser::Parse(const char *file, ge::ComputeGraphPtr &graph) { string fusion_proto_path = ge::parser::RealPath(fusion_proto_file.c_str()); GELOGI("Get fusion proto file[%s]-[%s].", fusion_proto_file.c_str(), fusion_proto_path.c_str()); if (fusion_proto_path.empty()) { - GELOGE(FAILED, "Fusion proto file path [%s]-[%s] is not real existed.", fusion_proto_file.c_str(), - fusion_proto_path.c_str()); + REPORT_INNER_ERROR("E19999", "Fusion proto file path [%s] is not real existed.", + fusion_proto_file.c_str()); + GELOGE(FAILED, "[Invoke][RealPath]Fusion proto file path [%s]-[%s] is not real existed.", + fusion_proto_file.c_str(), fusion_proto_path.c_str()); return FAILED; } string fusion_proto_name; if (CheckPathValid(file, fusion_proto_file, fusion_proto_path, fusion_proto_name) != SUCCESS) { - GELOGE(FAILED, "CheckPathValid of weight file[%s] and tmp proto[%s] failed.", file, + GELOGE(FAILED, "[Check][PathValid] of weight file[%s] and tmp proto[%s] failed.", file, fusion_proto_file.c_str()); return FAILED; } @@ -1961,13 +2005,13 @@ Status CaffeWeightsParser::Parse(const char *file, ge::ComputeGraphPtr &graph) { GELOGI("Start to parse weight: %s by fusion proto: %s.", file, fusion_proto_file.c_str()); Status status = ParseWeightByFusionProto(file, fusion_proto_path, fusion_proto_name, graph); if (status != SUCCESS) { - GELOGE(FAILED, "Parse weight by fusion proto failed."); + GELOGE(FAILED, "[Invoke][ParseWeightByFusionProto] failed. ret:%u", status); return status; } status = CheckNodes(graph); if (status != SUCCESS) { - GELOGE(ge::GRAPH_FAILED, "Check Nodes failed, status=%u", status); + GELOGE(ge::GRAPH_FAILED, "[Check][Nodes] failed, status=%u", status); return domi::PARSE_WEIGHTS_FAILED; } @@ -1986,8 +2030,8 @@ Status CaffeWeightsParser::ParseWeightByFusionProto(const char *weight_path, con if (descriptor == nullptr) { ErrorManager::GetInstance().ATCReportErrMessage( "E19021", {"reason"}, {"Does not find domi.caffe.NetParameter in google::protobuf::Descriptor."}); - GELOGE(FAILED, "Does not find domi.caffe.NetParameter in google::protobuf::Descriptor, \ - which may be caused by problematic fusion proto."); + GELOGE(FAILED, "[Invoke][FindMessageTypeByName]Does not find domi.caffe.NetParameter in " + "google::protobuf::Descriptor, which may be caused by problematic fusion proto."); return FAILED; } google::protobuf::DynamicMessageFactory factory; @@ -2001,7 +2045,7 @@ Status CaffeWeightsParser::ParseWeightByFusionProto(const char *weight_path, con message = nullptr; ErrorManager::GetInstance().ATCReportErrMessage( "E19021", {"reason"}, {"ReadProtoFromBinaryFile based on fusion proto failed."}); - GELOGE(FAILED, "ReadProtoFromBinaryFile %s failed.", weight_path); + GELOGE(FAILED, "[Invoke][ReadProtoFromBinaryFile] %s failed.", weight_path); return FAILED; } @@ -2012,7 +2056,8 @@ Status CaffeWeightsParser::ParseWeightByFusionProto(const char *weight_path, con message = nullptr; ErrorManager::GetInstance().ATCReportErrMessage( "E19021", {"reason"}, {"Does not find domi.caffe.LayerParameter in google::protobuf::Descriptor"}); - GELOGE(FAILED, "Does not find domi.caffe.LayerParameter in google::protobuf::Descriptor"); + GELOGE(FAILED, + "[Invoke][FindMessageTypeByName]Does not find domi.caffe.LayerParameter in google::protobuf::Descriptor"); return FAILED; } @@ -2027,7 +2072,7 @@ Status CaffeWeightsParser::ParseWeightByFusionProto(const char *weight_path, con message = nullptr; ErrorManager::GetInstance().ATCReportErrMessage( "E19021", {"reason"}, {"ParseLayerParameter failed."}); - GELOGE(FAILED, "ParseLayerParameter failed."); + GELOGE(FAILED, "[Parse][LayerParameter] failed."); return FAILED; } @@ -2061,7 +2106,7 @@ Status CaffeWeightsParser::ParseLayerParameter(const google::protobuf::Descripto if (!field->is_repeated()) { ErrorManager::GetInstance().ATCReportErrMessage("E11032", {"name", "reason"}, {field->name().c_str(), "LayerParameter should be repeated"}); - GELOGE(FAILED, "LayerParameter should be repeated."); + GELOGE(FAILED, "[Check][Param] LayerParameter should be repeated, field:%s.", field->name().c_str()); return FAILED; } @@ -2072,7 +2117,7 @@ Status CaffeWeightsParser::ParseLayerParameter(const google::protobuf::Descripto LayerParameter *layer = tmp_net.add_layer(); if (ConvertLayerProto(&layer_message, layer) != SUCCESS) { - GELOGE(FAILED, "Convert message to layer proto failed."); + GELOGE(FAILED, "[Invoke][ConvertLayerProto] Convert message to layer proto failed."); return FAILED; } @@ -2102,7 +2147,7 @@ Status CaffeWeightsParser::ConvertLayerProto(const google::protobuf::Message *me for (auto &field : field_desc) { GE_CHECK_NOTNULL(field); if (ParseLayerField(layer_reflection, message, field, layer) != SUCCESS) { - GELOGE(FAILED, "Parse field %s failed.", field->name().c_str()); + GELOGE(FAILED, "[Invoke][ParseLayerField] Parse field %s failed.", field->name().c_str()); return FAILED; } } @@ -2144,7 +2189,7 @@ Status CaffeWeightsParser::ParseLayerField(const google::protobuf::Reflection *r BlobProto *item_message = layer_proto->add_blobs(); const google::protobuf::Message &sub_message = reflection->GetRepeatedMessage(*message, field, i); if (ConvertBlobsProto(&sub_message, item_message) != SUCCESS) { - GELOGE(FAILED, "ParseLayerField of field: %s failed.", field->name().c_str()); + GELOGE(FAILED, "[Invoke][ConvertBlobsProto] ParseLayerField of field: %s failed.", field->name().c_str()); return FAILED; } } @@ -2292,7 +2337,7 @@ Status CaffeWeightsParser::CheckLayersSize(const google::protobuf::Message *mess if (!field->is_repeated()) { ErrorManager::GetInstance().ATCReportErrMessage("E11032", {"name", "reason"}, {field->name().c_str(), "LayerParameter should be repeated"}); - GELOGE(FAILED, "LayerParameter should be repeated."); + GELOGE(FAILED, "[Check][Param] LayerParameter should be repeated. field:%s", field->name().c_str()); return FAILED; } @@ -2307,10 +2352,11 @@ Status CaffeWeightsParser::CheckLayersSize(const google::protobuf::Message *mess GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(num_layer == 0 && num_layers > 0, ErrorManager::GetInstance().ATCReportErrMessage("E11023"); return FAILED, - "The weight file is consisted of layers-structure which is deprecated in Caffe " - "and unsupported in ATC. The \"layers\" should be changed to \"layer\"."); + "[Check][Param]The weight file is consisted of layers-structure which is deprecated " + "in Caffe and unsupported in ATC. The \"layers\" should be changed to \"layer\"."); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((num_layer == 0), ErrorManager::GetInstance().ATCReportErrMessage("E11024"); - return FAILED, "Weight layer num is zero, weight file may be invalid."); + return FAILED, + "[Check][Param] Weight layer num is zero, weight file may be invalid."); return SUCCESS; } @@ -2368,13 +2414,15 @@ Status CaffeWeightsParser::ConvertLayerParameter(const google::protobuf::Message GE_CHK_BOOL_TRUE_EXEC_WITH_LOG( (op_parser.get() == nullptr), ErrorManager::GetInstance().ATCReportErrMessage("E11025", {"opname", "optype"}, {layer_name, op_type}); - return FAILED, "Op[%s] create OpParser failed, optype is %s", layer_name.c_str(), op_type.c_str()); + return FAILED, + "[Create][OpParser] failed for Op[%s], optype is %s", layer_name.c_str(), op_type.c_str()); // Parsing weight information through op parser Status status = op_parser->ParseWeights(layer_message, node); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG( (status != SUCCESS), ErrorManager::GetInstance().ATCReportErrMessage("E11026", {"opname"}, {layer_name}); - return status, "Parse op weights for op[%s] failed", layer_name.c_str()); + return status, + "[Parse][Weights] for op[%s] failed", layer_name.c_str()); } return SUCCESS; } @@ -2394,13 +2442,14 @@ Status CaffeWeightsParser::CheckNodes(ge::ComputeGraphPtr &graph) { if (in_anchor_ptr->GetPeerAnchors().empty() && input_desc != nullptr) { if (layer_name_record_map_.find(node->GetName()) == layer_name_record_map_.end()) { ErrorManager::GetInstance().ATCReportErrMessage("E11029", {"opname"}, {node->GetName()}); - GELOGE(ge::GRAPH_FAILED, "Op[%s] in model file does not exist in weight file.", node->GetName().c_str()); + GELOGE(ge::GRAPH_FAILED, "[Find][Node] Op[%s] in model file does not exist in weight file.", + node->GetName().c_str()); PreChecker::Instance().RefreshErrorMessageByName(node->GetName(), PreChecker::PARAM_INVALID, "Node does not exist in weight file."); } else { ErrorManager::GetInstance().ATCReportErrMessage("E11019", {"opname", "index"}, {node->GetName(), std::to_string(in_anchor_ptr->GetIdx())}); - GELOGE(ge::GRAPH_FAILED, "Op[%s]'s input %d is not linked.", node->GetName().c_str(), + GELOGE(ge::GRAPH_FAILED, "[Check][Param] Op[%s]'s input %d is not linked.", node->GetName().c_str(), in_anchor_ptr->GetIdx()); string check_msg = "input " + to_string(in_anchor_ptr->GetIdx()) + "is not linked in weight file"; PreChecker::Instance().RefreshErrorMessageByName(node->GetName(), PreChecker::PARAM_INVALID, check_msg); @@ -2422,9 +2471,9 @@ Status CaffeWeightsParser::ConvertNetParameter(const NetParameter ¶m, ge::Co GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(num_layer == 0 && num_layers > 0, ErrorManager::GetInstance().ATCReportErrMessage("E11023"); - return FAILED, - "The weight file is consisted of layers-structure which is deprecated in Caffe " - "and unsupported in ATC. The \"layers\" should be changed to \"layer\"."); + return FAILED, "[Check][Param] The weight file is consisted of layers-structure " + "which is deprecated in Caffe and unsupported in ATC. " + "The \"layers\" should be changed to \"layer\"."); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((num_layer == 0), ErrorManager::GetInstance().ATCReportErrMessage("E11024"); return FAILED, "weight layer num is zero, weight file may be invalid."); @@ -2488,13 +2537,13 @@ Status CaffeWeightsParser::ConvertNetParameter(const NetParameter ¶m, ge::Co GE_CHK_BOOL_TRUE_EXEC_WITH_LOG( (op_parser.get() == nullptr), ErrorManager::GetInstance().ATCReportErrMessage("E11025", {"opname", "optype"}, {layer_name, op_type}); - return FAILED, "Op[%s] create OpParser failed, optype is %s", layer_name.c_str(), op_type.c_str()); + return FAILED, "[Create][OpParser] failed for Op[%s], optype is %s", layer_name.c_str(), op_type.c_str()); // Parsing weight information through op parser Status status = op_parser->ParseWeights(&layer, node); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG( (status != SUCCESS), ErrorManager::GetInstance().ATCReportErrMessage("E11026", {"opname"}, {layer_name}); - return status, "Parse op weights for op[%s] failed", layer_name.c_str()); + return status, "[Parse][Weights] for op[%s] failed", layer_name.c_str()); } } diff --git a/parser/caffe/caffe_reshape_parser.cc b/parser/caffe/caffe_reshape_parser.cc index 9366827..ffb413b 100644 --- a/parser/caffe/caffe_reshape_parser.cc +++ b/parser/caffe/caffe_reshape_parser.cc @@ -40,7 +40,8 @@ Status CaffeReshapeParser::ParseParams(const Message *op_src, ge::OpDescPtr &op) GE_CHECK_NOTNULL(op); const LayerParameter *layer = DOMI_DYNAMIC_CAST(op_src); if (layer == nullptr) { - GELOGE(FAILED, "Reshape Dynamic cast op_src to LayerParameter failed"); + REPORT_INNER_ERROR("E19999", "Reshape Dynamic cast op_src to LayerParameter failed"); + GELOGE(FAILED, "[Convert][DataType]Reshape Dynamic cast op_src to LayerParameter failed"); return FAILED; } @@ -53,7 +54,10 @@ Status CaffeReshapeParser::ParseParams(const Message *op_src, ge::OpDescPtr &op) GELOGW("SetInt failed for op %s.", op->GetName().c_str());); // no need to return if (!reshape_parameter.has_shape()) { - GELOGE(FAILED, "Reshape has no shape info, ret fail"); + REPORT_INNER_ERROR("E19999", "Reshape has no shape info, ret fail, layer name = %s, layer type= %s", + layer->name().c_str(), layer->type().c_str()); + GELOGE(FAILED, "[Check][Param]Reshape has no shape info, ret fail, layer name = %s, layer type= %s", + layer->name().c_str(), layer->type().c_str()); return FAILED; } const BlobShape &blob_shape = reshape_parameter.shape(); @@ -87,7 +91,8 @@ Status CaffeReshapeParser::AddConstInput(ge::NodePtr &node) { GE_CHECK_NOTNULL(node); auto owner_graph = node->GetOwnerComputeGraph(); if (owner_graph == nullptr) { - GELOGE(FAILED, "node's graph is empty, name: %s", node->GetName().c_str()); + REPORT_INNER_ERROR("E19999", "node's graph is empty, name: %s", node->GetName().c_str()); + GELOGE(FAILED, "[Get][OwnerComputeGraph]node's graph is empty, name: %s", node->GetName().c_str()); return FAILED; } ge::OpDescPtr op = node->GetOpDesc(); @@ -104,7 +109,8 @@ Status CaffeReshapeParser::AddConstInput(ge::NodePtr &node) { const_desc.Update(shape, ge::FORMAT_NCHW, ge::DT_INT64); ge::graphStatus state = op->UpdateInputDesc(RESHAPE_ATTR_SHAPE, const_desc); if (state != ge::GRAPH_SUCCESS) { - GELOGE(FAILED, "Updata input_shape desc failed."); + REPORT_CALL_ERROR("E19999", "op:%s UpdateInputDesc failed.", op->GetName().c_str()); + GELOGE(FAILED, "[Update][InputDesc] failed for op:%s.", op->GetName().c_str()); return FAILED; } @@ -133,7 +139,10 @@ Status CaffeReshapeParser::AddConstInput(ge::NodePtr &node) { GE_CHECK_NOTNULL(in_archor_ptr); state = ge::GraphUtils::AddEdge(out_archor_ptr, in_archor_ptr); if (state != ge::GRAPH_SUCCESS) { - GELOGE(FAILED, "AddEdge failed of from Node %s to Node %s", const_node->GetName().c_str(), node->GetName().c_str()); + REPORT_CALL_ERROR("E19999", "AddEdge failed of from Node %s to Node %s", + const_node->GetName().c_str(), node->GetName().c_str()); + GELOGE(FAILED, "[Add][Edge] failed of from Node %s to Node %s", + const_node->GetName().c_str(), node->GetName().c_str()); return domi::FAILED; } return SUCCESS; diff --git a/parser/common/acl_graph_parser_util.cc b/parser/common/acl_graph_parser_util.cc index 2fc6b64..9040942 100644 --- a/parser/common/acl_graph_parser_util.cc +++ b/parser/common/acl_graph_parser_util.cc @@ -83,7 +83,8 @@ static void GetOpsProtoPath(string &opsproto_path) { string path = path_env; string file_path = ge::parser::RealPath(path.c_str()); if (file_path.empty()) { - GELOGE(ge::FAILED, "File path %s is invalid.", path.c_str()); + REPORT_INNER_ERROR("E19999", "File path %s is invalid.", path.c_str()); + GELOGE(ge::FAILED, "[Get][Path] File path %s is invalid.", path.c_str()); return; } opsproto_path = (path + "/op_proto/custom/" + ":") + (path + "/op_proto/built-in/"); @@ -124,7 +125,8 @@ static void GetAclParams(const std::map &par static bool CheckDigitStr(std::string &str) { for (char c : str) { if (!isdigit(c)) { - GELOGE(domi::FAILED, "Value[%s] is not positive integer", str.c_str()); + REPORT_CALL_ERROR("E19999", "param str:%s is not positive integer", str.c_str()); + GELOGE(domi::FAILED, "[Check][Param] Value[%s] is not positive integer", str.c_str()); return false; } } @@ -138,7 +140,8 @@ static bool CheckInputTrueOrFalse(const std::string &s, const std::string &atc_p return true; } else { ErrorManager::GetInstance().ATCReportErrMessage("E10005", {"parameter", "value"}, {atc_param, s}); - GELOGE(PARAM_INVALID, "Input parameter[%s]'s value[%s] must be true or false.", atc_param.c_str(), s.c_str()); + GELOGE(PARAM_INVALID, "[Check][Param] Input parameter[%s]'s value[%s] must be true or false.", + atc_param.c_str(), s.c_str()); return false; } } @@ -146,10 +149,8 @@ static bool CheckInputTrueOrFalse(const std::string &s, const std::string &atc_p static Status CheckOutNode(ge::OpDescPtr op_desc, int32_t index) { int32_t out_size = op_desc->GetOutputsSize(); if (index < 0 || index >= out_size) { - GELOGE(domi::FAILED, - "out_node [%s] output index:%d must be smaller " - "than node output size:%d and can not be negative!", - op_desc->GetName().c_str(), index, out_size); + GELOGE(domi::FAILED, "[Check][Param]out_node [%s] output index:%d must be smaller " + "than node output size:%d and can not be negative!", op_desc->GetName().c_str(), index, out_size); std::string fail_reason = "output index:" + to_string(index) + " must be smaller than output size:" + to_string(out_size) + " and can not be negative!"; ErrorManager::GetInstance().ATCReportErrMessage("E10003", {"parameter", "value", "reason"}, @@ -168,7 +169,10 @@ domi::Status AclGrphParseUtil::LoadOpsProtoLib() { option_tmp.emplace(std::pair(string("ge.opsProtoLibPath"), opsproto_path)); bool is_proto_init = manager->Initialize(option_tmp); if (!is_proto_init) { - GELOGE(FAILED, "Load ops_proto lib failed, ops proto path is invalid."); + REPORT_INNER_ERROR("E19999", "OpsProtoManager init failed because ops proto path:%s is invalid.", + opsproto_path.c_str()); + GELOGE(FAILED, "[Invoke][Initialize] Load ops_proto lib failed, ops proto path:%s is invalid.", + opsproto_path.c_str()); return FAILED; } return SUCCESS; @@ -214,13 +218,15 @@ domi::Status AclGrphParseUtil::AclParserInitialize(const std::mapsecond; @@ -269,25 +275,25 @@ domi::Status AclGrphParseUtil::ParseAclOutputNodes(const string &out_nodes) { } ErrorManager::GetInstance().ATCReportErrMessage( "E10001", {"parameter", "value", "reason"}, - {"out_nodes", node, "the correct format is \"node_name1:0;node_name1:1;node_name2:0\""}); - GELOGE(PARAM_INVALID, - "The input format of out_nodes is invalid, the correct format is " - "\"node_name1:0;node_name1:1;node_name2:0\", while the actual input is %s.", + {"out_nodes", node, "the correct format is \"node_name1:0; node_name1:1; node_name2:0\""}); + GELOGE(PARAM_INVALID, "[Check][Param] The input format of out_nodes is invalid, the correct format is " + "\"node_name1:0; node_name1:1; node_name2:0\", while the actual input is %s.", node.c_str()); return PARAM_INVALID; } if (!ge::GetParserContext().user_out_nodes_top_vec.empty()) { ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, {"out_nodes", out_nodes, "is not all index or top_name"}); - GELOGE(PARAM_INVALID, "This out_nodes str must be all index or top_name, while the actual input is %s", - out_nodes.c_str()); + GELOGE(PARAM_INVALID, "[Check][Param] This out_nodes str must be all index or top_name, " + "while the actual input is %s", out_nodes.c_str()); return PARAM_INVALID; } // stoi: The method may throw an exception: invalid_argument/out_of_range if (!CheckDigitStr(key_value_v[1])) { ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, {"out_nodes", out_nodes, "is not positive integer"}); - GELOGE(PARAM_INVALID, "This str must be digit string, while the actual input is %s", out_nodes.c_str()); + GELOGE(PARAM_INVALID, "[Check][Param] This str:%s must be digit string, while the actual input is %s", + key_value_v[1].c_str(), out_nodes.c_str()); return PARAM_INVALID; } @@ -305,11 +311,11 @@ domi::Status AclGrphParseUtil::ParseAclOutputNodes(const string &out_nodes) { } } } catch (std::invalid_argument &) { - GELOGE(PARAM_INVALID, "Invalid of out_nodes: %s ", out_nodes.c_str()); + GELOGE(PARAM_INVALID, "[Check][Param] Invalid of out_nodes: %s ", out_nodes.c_str()); ErrorManager::GetInstance().ATCReportErrMessage("E10014", {"parameter", "value"}, {"out_nodes", out_nodes}); return PARAM_INVALID; } catch (std::out_of_range &) { - GELOGE(PARAM_INVALID, "Invalid of out_nodes: %s ", out_nodes.c_str()); + GELOGE(PARAM_INVALID, "[Check][Param] Invalid of out_nodes: %s ", out_nodes.c_str()); ErrorManager::GetInstance().ATCReportErrMessage("E10013", {"parameter", "value"}, {"out_nodes", out_nodes}); return PARAM_INVALID; } @@ -327,8 +333,8 @@ domi::Status AclGrphParseUtil::ParseAclOutputFp16NodesFormat(const string &is_ou for (auto &is_fp16 : node_format_vec) { StringUtils::Trim(is_fp16); if (!CheckInputTrueOrFalse(is_fp16, "is_output_adjust_hw_layout")) { - GELOGE(PARAM_INVALID, "Invalid Param, is_output_adjust_hw_layout only support true/false: but is [%s]", - is_output_fp16.c_str()); + GELOGE(PARAM_INVALID, "[Check][Param]Invalid Param, is_output_adjust_hw_layout " + "only support true/false: but is [%s]", is_output_fp16.c_str()); return PARAM_INVALID; } if (is_fp16 == "false") { @@ -370,8 +376,8 @@ domi::Status AclGrphParseUtil::ParseAclInputFp16Nodes(const ComputeGraphPtr &gra for (auto &s : adjust_fp16_format_vec) { StringUtils::Trim(s); if (!CheckInputTrueOrFalse(s, "is_input_adjust_hw_layout")) { - GELOGE(PARAM_INVALID, "Invalid Param, is_input_adjust_hw_layout only support true/false: but is [%s]", - is_input_adjust_hw_layout.c_str()); + GELOGE(PARAM_INVALID, "[Check][Param] Invalid Param, is_input_adjust_hw_layout " + "only support true/false: but is [%s]", is_input_adjust_hw_layout.c_str()); return PARAM_INVALID; } } @@ -386,7 +392,7 @@ domi::Status AclGrphParseUtil::ParseAclInputFp16Nodes(const ComputeGraphPtr &gra if (node == nullptr) { ErrorManager::GetInstance().ATCReportErrMessage("E10016", {"parameter", "opname"}, {"input_fp16_nodes", input_fp16_nodes_vec[i]}); - GELOGE(PARAM_INVALID, "Input parameter[input_fp16_nodes]'s opname[%s] is not exist in model", + GELOGE(PARAM_INVALID, "[Check][Param] Input parameter[input_fp16_nodes]'s opname[%s] is not exist in model", input_fp16_nodes_vec[i].c_str()); return PARAM_INVALID; } @@ -395,7 +401,7 @@ domi::Status AclGrphParseUtil::ParseAclInputFp16Nodes(const ComputeGraphPtr &gra if (op_desc->GetType() != ge::parser::DATA) { ErrorManager::GetInstance().ATCReportErrMessage("E10017", {"parameter", "opname"}, {"input_fp16_nodes", input_fp16_nodes_vec[i]}); - GELOGE(PARAM_INVALID, "Input parameter[input_fp16_nodes]'s opname[%s] is not a input opname", + GELOGE(PARAM_INVALID, "[Check][Param] Input parameter[input_fp16_nodes]'s opname[%s] is not a input opname", input_fp16_nodes_vec[i].c_str()); return PARAM_INVALID; } @@ -434,7 +440,8 @@ domi::Status AclGrphParseUtil::GetOutputLeaf(NodePtr node, std::vector> &output_nodes_info) { ge::OpDescPtr tmpDescPtr = node->GetOpDesc(); if (tmpDescPtr == nullptr) { - GELOGE(domi::FAILED, "Get outnode op desc fail."); + REPORT_INNER_ERROR("E19999", "param node has no opdesc."); + GELOGE(domi::FAILED, "[Get][OpDesc] param node has no opdesc."); return domi::FAILED; } size_t size = tmpDescPtr->GetOutputsSize(); @@ -448,7 +455,8 @@ domi::Status AclGrphParseUtil::GetOutputLeaf(NodePtr node, for (auto in_anchor : in_anchors) { auto out_anchor = in_anchor->GetPeerOutAnchor(); if (out_anchor == nullptr) { - GELOGE(domi::FAILED, "Get leaf node op desc fail."); + REPORT_INNER_ERROR("E19999", "Get leaf node op desc fail."); + GELOGE(domi::FAILED, "[Invoke][GetPeerOutAnchor] Get leaf node op desc fail."); return domi::FAILED; } auto out_node = out_anchor->GetOwnerNode(); @@ -467,7 +475,8 @@ domi::Status AclGrphParseUtil::GetDefaultOutInfo(ge::ComputeGraphPtr &compute_gr if (out_node == nullptr) { ErrorManager::GetInstance().ATCReportErrMessage("E10016", {"parameter", "opname"}, {"out_nodes", default_out_nodes[i].first}); - GELOGE(domi::FAILED, "Can not find src node (%s) in graph.", default_out_nodes[i].first.c_str()); + GELOGE(domi::FAILED, "[Check][Param] Can not find out_nodes(%d) (%s) in graph.", + i, default_out_nodes[i].first.c_str()); return domi::FAILED; } output_nodes_info.push_back(std::make_pair(out_node, default_out_nodes[i].second)); @@ -479,7 +488,7 @@ domi::Status AclGrphParseUtil::GetDefaultOutInfo(ge::ComputeGraphPtr &compute_gr for (ge::NodePtr node : compute_graph->GetDirectNode()) { if (!node->GetInAllNodes().empty() && node->GetOutAllNodes().empty()) { Status ret = GetOutputLeaf(node, output_nodes_info); - GE_CHK_BOOL_RET_STATUS(ret == SUCCESS, ret, "Find leaf fail."); + GE_CHK_BOOL_RET_STATUS(ret == SUCCESS, ret, "[Invoke][GetOutputLeaf] Find leaf fail."); } } return domi::SUCCESS; @@ -501,13 +510,14 @@ domi::Status AclGrphParseUtil::SetOutputNodeInfo(ge::Graph &graph, if (out_node == nullptr) { ErrorManager::GetInstance().ATCReportErrMessage("E10016", {"parameter", "opname"}, {"out_nodes", user_out_nodes[i].first}); - GELOGE(domi::FAILED, "Can not find src node (%s) in graph.", user_out_nodes[i].first.c_str()); + GELOGE(domi::FAILED, "[Check][Param] Can not find out_nodes(%d) (%s) in graph.", + i, user_out_nodes[i].first.c_str()); return domi::FAILED; } auto op_desc = out_node->GetOpDesc(); GE_CHECK_NOTNULL(op_desc); if (CheckOutNode(op_desc, user_out_nodes[i].second) != SUCCESS) { - GELOGE(domi::FAILED, "Check out node (%s) fail.", user_out_nodes[i].first.c_str()); + GELOGE(domi::FAILED, "[CheckOut][Node] (%s) fail.", user_out_nodes[i].first.c_str()); return domi::FAILED; } @@ -528,7 +538,8 @@ domi::Status AclGrphParseUtil::SetOutputNodeInfo(ge::Graph &graph, // default output node (leaf) if (user_out_nodes.empty()) { if (GetDefaultOutInfo(compute_graph, output_nodes_info) != SUCCESS) { - GELOGE(domi::FAILED, "Get default output info failed."); + REPORT_CALL_ERROR("E19999", "GetDefaultOutInfo failed for graph:%s", graph.GetName().c_str()); + GELOGE(domi::FAILED, "[Invoke][GetDefaultOutInfo] failed, graph:%s.", graph.GetName().c_str()); return domi::FAILED; } } @@ -545,7 +556,7 @@ domi::Status AclGrphParseUtil::CheckOptions(const std::map &parser_params, string &graph_name) { GELOGI("Parse graph user options start."); - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(CheckOptions(parser_params) != SUCCESS, return PARAM_INVALID, - "Parse paragrams invalid."); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(CheckOptions(parser_params) != SUCCESS, + return PARAM_INVALID, "[Check][Options] Parse paragrams invalid, graph:%s.", + graph_name.c_str()); // support paragrams: out_nodes, is_output_adjust_hw_layout, output, enable_scope_fusion_passes SetDefaultFormat(); string out_nodes; GetAclParams(parser_params, ge::ir_option::OUT_NODES, out_nodes); - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclOutputNodes(out_nodes) != SUCCESS, return PARAM_INVALID, - "Parse out_nodes failed"); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclOutputNodes(out_nodes) != SUCCESS, + return PARAM_INVALID, + "[Invoke][ParseAclOutputNodes] Parse out_nodes failed, graph:%s.", graph_name.c_str()); string is_output_adjust_hw_layout; GetAclParams(parser_params, ge::ir_option::IS_OUTPUT_ADJUST_HW_LAYOUT, is_output_adjust_hw_layout); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclOutputFp16NodesFormat(is_output_adjust_hw_layout) != SUCCESS, - return PARAM_INVALID, "Parse is_output_adjust_hw_layout failed"); + return PARAM_INVALID, + "[Invoke][ParseAclOutputFp16NodesFormat] Parse is_output_adjust_hw_layout failed, " + "graph:%s.", graph_name.c_str()); string tmp_name; GetAclParams(parser_params, ge::ir_option::OUTPUT, tmp_name); @@ -584,8 +599,10 @@ domi::Status AclGrphParseUtil::ParseParamsBeforeGraph(const std::mapGetName().c_str()); return SUCCESS; } @@ -616,7 +634,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY std::string RealPath(const char } if (strlen(path) >= PATH_MAX) { ErrorManager::GetInstance().ATCReportErrMessage("E19002", {"filepath", "size"}, {path, std::to_string(PATH_MAX)}); - GELOGE(ge::FAILED, "Path[%s] len is too long, it must be less than %d", path, PATH_MAX); + GELOGE(ge::FAILED, "[Check][Param] Path[%s] len is too long, it must be less than %d", path, PATH_MAX); return ""; } // Nullptr is returned when the path does not exist or there is no permission @@ -632,26 +650,31 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY std::string RealPath(const char // Get file length FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY long GetFileLength(const std::string &input_file) { - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(input_file.empty(), return -1, "input_file path is null."); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(input_file.empty(), + REPORT_INNER_ERROR("E19999", "input_file path is null, check invalid."); + return -1, "[Check][Param] input_file path is null."); std::string real_path = RealPath(input_file.c_str()); - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(), return -1, "input_file path '%s' not valid", input_file.c_str()); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(), + REPORT_CALL_ERROR("E19999", "input_file path '%s' not valid, realpath failed", + input_file.c_str()); + return -1, "[Get][Path] input_file path '%s' not valid", input_file.c_str()); unsigned long long file_length = 0; GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(mmGetFileSize(input_file.c_str(), &file_length) != EN_OK, ErrorManager::GetInstance().ATCReportErrMessage("E19001", {"file", "errmsg"}, {input_file, strerror(errno)}); - return -1, "Open file[%s] failed. %s", input_file.c_str(), strerror(errno)); + return -1, "[Open][File] [%s] failed. %s", input_file.c_str(), strerror(errno)); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((file_length == 0), ErrorManager::GetInstance().ATCReportErrMessage("E19015", {"filepath"}, {input_file}); - return -1, "File[%s] size is 0, not valid.", input_file.c_str()); + return -1, "[Check][Param] File[%s] size is 0, not valid.", input_file.c_str()); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(file_length > kMaxFileSizeLimit, ErrorManager::GetInstance().ATCReportErrMessage( "E19016", {"filepath", "filesize", "maxlen"}, {input_file, std::to_string(file_length), std::to_string(kMaxFileSizeLimit)}); - return -1, "File[%s] size %lld is out of limit: %d.", + return -1, "[Check][Param] File[%s] size %lld is out of limit: %d.", input_file.c_str(), file_length, kMaxFileSizeLimit); return static_cast(file_length); } @@ -659,14 +682,15 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY long GetFileLength(const std::s FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY uint64_t GetCurrentTimestamp() { struct timeval tv{}; int ret = gettimeofday(&tv, nullptr); - GE_LOGE_IF(ret != 0, "Func gettimeofday may failed: ret=%d", ret); + GE_LOGE_IF(ret != 0, "[Func][GetTimeOfDay] may failed: ret=%d", ret); auto total_use_time = tv.tv_usec + tv.tv_sec * 1000000; // 1000000: seconds to microseconds return static_cast(total_use_time); } static bool ReadProtoFromCodedInputStream(CodedInputStream &coded_stream, Message *proto) { GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(proto == nullptr, - return false, "incorrect parameter. nullptr == proto"); + REPORT_INNER_ERROR("E19999", "param proto is nullptr, check invalid"); + return false, "[Check][Param] incorrect parameter. nullptr == proto"); coded_stream.SetTotalBytesLimit(kProtoReadBytesLimit, kWarningThreshold); return proto->ParseFromCodedStream(&coded_stream); @@ -682,26 +706,36 @@ static bool ReadProtoFromCodedInputStream(CodedInputStream &coded_stream, Messag */ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadBytesFromBinaryFile(const char *file_name, char **buffer, int &length) { - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((file_name == nullptr), return false, "incorrect parameter. file is nullptr"); - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((buffer == nullptr), return false, "incorrect parameter. buffer is nullptr"); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((file_name == nullptr), + REPORT_INNER_ERROR("E19999", "param file_name is nullptr, check invalid"); + return false, "[Check][Param] incorrect parameter. file is nullptr"); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((buffer == nullptr), + REPORT_INNER_ERROR("E19999", "param buffer is nullptr, check invalid"); + return false, "[Check][Param] incorrect parameter. buffer is nullptr"); std::string real_path = RealPath(file_name); - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(), return false, "file path '%s' not valid", file_name); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(), + REPORT_INNER_ERROR("E19999", "file path '%s' not valid, realpath failed", file_name); + return false, "[Check][Param]file path '%s' not valid, realpath failed", file_name); std::ifstream file(real_path.c_str(), std::ios::binary | std::ios::ate); if (!file.is_open()) { - GELOGE(ge::FAILED, "Read file %s failed.", file_name); + REPORT_INNER_ERROR("E19999", "read file %s failed", file_name); + GELOGE(ge::FAILED, "[Read][File] %s failed.", file_name); return false; } length = static_cast(file.tellg()); - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((length <= 0), file.close(); return false, "file length <= 0"); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((length <= 0), file.close(); REPORT_INNER_ERROR("E19999", "file length <= 0"); + return false, "[Check][Param] file length <= 0"); file.seekg(0, std::ios::beg); *buffer = new(std::nothrow) char[length](); - GE_CHK_BOOL_TRUE_EXEC_RET_STATUS(*buffer == nullptr, false, file.close(), "new an object failed."); + GE_CHK_BOOL_TRUE_EXEC_RET_STATUS(*buffer == nullptr, false, file.close(); + REPORT_CALL_ERROR("E19999", "new an object failed."), + "[Create][Buffer] new an object failed."); file.read(*buffer, length); file.close(); @@ -710,19 +744,20 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadBytesFromBinaryFile(co FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromBinaryFile(const char *file, Message *proto) { GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((file == nullptr || proto == nullptr), - return false, - "Input parameter file or proto is nullptr!"); + REPORT_INNER_ERROR("E19999", "param file or proto is nullptr, check invalid"); + return false, "[Check][Param] Input parameter file or proto is nullptr!"); std::string real_path = RealPath(file); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(), - return false, "pb file path '%s' not valid", file); + REPORT_INNER_ERROR("E19999", "file path '%s' not valid, realpath failed", file); + return false, "[Check][Param]pb file path '%s' not valid, realpath failed", file); - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(GetFileLength(real_path) == -1, return false, "file size not valid."); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(GetFileLength(real_path) == -1, return false, "[Get][FileLength]file size not valid."); std::ifstream fs(real_path, std::ifstream::in | std::ifstream::binary); if (!fs.is_open()) { ErrorManager::GetInstance().ATCReportErrMessage("E19001", {"file", "errmsg"}, {file, "ifstream is_open failed"}); - GELOGE(ge::FAILED, "Open real path[%s] failed.", file); + GELOGE(ge::FAILED, "[Open][RealPath][%s] failed.", file); return false; } @@ -735,7 +770,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromBinaryFile(co if (!ret) { ErrorManager::GetInstance().ATCReportErrMessage("E19005", {"file"}, {file}); - GELOGE(ge::FAILED, "Parse file[%s] failed.", file); + GELOGE(ge::FAILED, "[Read][Proto] Parse file[%s] failed.", file); return ret; } @@ -743,8 +778,10 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromBinaryFile(co } FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromArray(const void *data, int size, Message *proto) { - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((proto == nullptr || data == nullptr || size == 0), return false, - "incorrect parameter. proto is nullptr || data is nullptr || size is 0"); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((proto == nullptr || data == nullptr || size == 0), + REPORT_INNER_ERROR("E19999", "param proto or data is nullptr " + "or size is 0, check invalid"); return false, + "[Check][Param]incorrect parameter. proto is nullptr || data is nullptr || size is 0"); google::protobuf::io::CodedInputStream coded_stream(reinterpret_cast(const_cast(data)), size); return ReadProtoFromCodedInputStream(coded_stream, proto); @@ -752,33 +789,34 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromArray(const v FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromText(const char *file, google::protobuf::Message *message) { - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((file == nullptr || message == nullptr), return false, - "incorrect parameter. nullptr == file || nullptr == message"); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((file == nullptr || message == nullptr), + REPORT_INNER_ERROR("E19999", "param file or message is nullptr, check invalid"); + return false, + "[Check][Param]incorrect parameter. nullptr == file || nullptr == message"); std::string real_path = RealPath(file); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(), ErrorManager::GetInstance().ATCReportErrMessage("E19000", {"path", "errmsg"}, {file, strerror(errno)}); - return false, "Path[%s]'s realpath is empty, errmsg[%s]", file, + return false, "[Check][Param]Path[%s]'s realpath is empty, errmsg[%s]", file, strerror(errno)); - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(GetFileLength(real_path) == -1, return false, "file size not valid."); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(GetFileLength(real_path) == -1, return false, "[Check][Param] file size not valid."); std::ifstream fs(real_path.c_str(), std::ifstream::in); if (!fs.is_open()) { ErrorManager::GetInstance().ATCReportErrMessage("E19017", {"realpth", "protofile"}, {real_path, file}); - GELOGE(ge::FAILED, - "Fail to open proto file real path is '%s' when orginal file path is '%s'.", real_path.c_str(), file); + GELOGE(ge::FAILED, "[Open][ProtoFile] failed, real path is '%s' when orginal file path is '%s'.", + real_path.c_str(), file); return false; } google::protobuf::io::IstreamInputStream input(&fs); bool ret = google::protobuf::TextFormat::Parse(&input, message); - GE_IF_BOOL_EXEC(!ret, - ErrorManager::GetInstance().ATCReportErrMessage("E19018", {"protofile"}, {file}); - GELOGE(ret, "Parse file[%s] through [google::protobuf::TextFormat::Parse] failed, " - "please check whether the file is a valid protobuf format file.", file)); + GE_IF_BOOL_EXEC(!ret, ErrorManager::GetInstance().ATCReportErrMessage("E19018", {"protofile"}, {file}); + GELOGE(ret, "[Parse][File] [%s] through [google::protobuf::TextFormat::Parse] failed, " + "please check whether the file is a valid protobuf format file.", file)); fs.close(); return ret; @@ -786,15 +824,17 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromText(const ch FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromMem(const char *data, int size, google::protobuf::Message *message) { - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((data == nullptr || message == nullptr), return false, - "incorrect parameter. data is nullptr || message is nullptr"); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((data == nullptr || message == nullptr), + REPORT_INNER_ERROR("E19999", "param data or message is nullptr,check invalid"); + return false, + "[Check][Param] incorrect parameter. data is nullptr || message is nullptr"); std::string str(data, static_cast(size)); std::istringstream fs(str); google::protobuf::io::IstreamInputStream input(&fs); bool ret = google::protobuf::TextFormat::Parse(&input, message); - GE_IF_BOOL_EXEC( - !ret, GELOGE(ret, "Call [google::protobuf::TextFormat::Parse] func ret fail, please check your text file.")); + GE_IF_BOOL_EXEC(!ret, REPORT_CALL_ERROR("E19999", "parse failed, please check your text file."); + GELOGE(ret, "[Call][Parse] ret fail, please check your text file.")); return ret; } @@ -812,7 +852,10 @@ Status GetOriginalType(const ge::NodePtr &node, string &type) { GE_CHECK_NOTNULL(node->GetOpDesc()); bool ret = ge::AttrUtils::GetStr(node->GetOpDesc(), ATTR_NAME_FRAMEWORK_ORIGINAL_TYPE, type); if (!ret) { - GELOGE(INTERNAL_ERROR, "Get FrameWorkOp original type [%s]", type.c_str()); + REPORT_CALL_ERROR("E19999", "Get FrameWorkOp original type [%s] from node:%s failed.", + type.c_str(), node->GetName().c_str()); + GELOGE(INTERNAL_ERROR, "[Invoke][GetStr] Get FrameWorkOp original type [%s] from node:%s failed", + type.c_str(), node->GetName().c_str()); return INTERNAL_ERROR; } GELOGD("Get FrameWorkOp original type [%s]", type.c_str()); @@ -834,7 +877,7 @@ FMK_FUNC_HOST_VISIBILITY bool ValidateStr(const std::string &str, const std::str ret = regexec(®, str.c_str(), 0, nullptr, 0); if (ret) { regerror(ret, ®, ebuff, kMaxBuffSize); - GELOGE(ge::PARAM_INVALID, "regexec failed, reason: %s", ebuff); + GELOGE(ge::PARAM_INVALID, "[Invoke][RegExec] failed, reason: %s", ebuff); regfree(®); return false; } @@ -847,7 +890,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY std::string CurrentTimeInStr() std::time_t now = std::time(nullptr); std::tm *ptm = std::localtime(&now); if (ptm == nullptr) { - GELOGE(ge::FAILED, "Localtime failed."); + GELOGE(ge::FAILED, "[Invoke][LocalTime] failed."); return ""; } diff --git a/parser/common/data_op_parser.cc b/parser/common/data_op_parser.cc index 47df78f..7b05988 100644 --- a/parser/common/data_op_parser.cc +++ b/parser/common/data_op_parser.cc @@ -31,7 +31,7 @@ const uint32_t kScalarLength = 1; namespace ge { FMK_FUNC_HOST_VISIBILITY Status DataOpParser::ParseShape(const vector &shape, ge::OpDescPtr op) { - GE_RETURN_WITH_LOG_IF_FALSE(op != nullptr, "ParseShape failed for data_op, op is null"); + GE_RETURN_WITH_LOG_IF_FALSE(op != nullptr, "[Check][Param] ParseShape failed for data_op, op is null"); const string &data_op_name = op->GetName(); GetParserContext().input_dims.emplace(data_op_name, shape); @@ -53,9 +53,11 @@ FMK_FUNC_HOST_VISIBILITY Status DataOpParser::ParseShape(const vector & auto map_iter = input_nodes_format_map.find(data_op_name); if (map_iter != input_nodes_format_map.end() && map_iter->second == domi::DOMI_TENSOR_NC1HWC0) { // Input 5D NC1HWC0 - GE_RETURN_WITH_LOG_IF_ERROR(Init5DInputTensor(def_format_shape, i_tensor_desc), "InitInputTensor failed"); + GE_RETURN_WITH_LOG_IF_ERROR(Init5DInputTensor(def_format_shape, i_tensor_desc), + "[Invoke][Init5DInputTensor] failed"); // Output - GE_RETURN_WITH_LOG_IF_ERROR(Init5DOutputTensor(def_format_shape, o_tensor_desc), "InitOutputTensor failed"); + GE_RETURN_WITH_LOG_IF_ERROR(Init5DOutputTensor(def_format_shape, o_tensor_desc), + "[Invoke][Init5DOutputTensor] failed"); } else { // No need to consider AIPP here, // The adjustdatanodedesc function of model_builder will process the @@ -66,27 +68,31 @@ FMK_FUNC_HOST_VISIBILITY Status DataOpParser::ParseShape(const vector & // To be modified after AICPU operators support pvmodel. if (data_type == ge::DT_FLOAT) { // Input - GE_RETURN_WITH_LOG_IF_ERROR(InitInputTensor(def_format_shape, i_tensor_desc), "InitInputTensor failed"); + GE_RETURN_WITH_LOG_IF_ERROR(InitInputTensor(def_format_shape, i_tensor_desc), + "[Invoke][InitInputTensor] failed"); // Output - GE_RETURN_WITH_LOG_IF_ERROR(InitOutputTensor(def_format_shape, o_tensor_desc), "InitOutputTensor failed"); + GE_RETURN_WITH_LOG_IF_ERROR(InitOutputTensor(def_format_shape, o_tensor_desc), + "[Invoke][InitOutputTensor] failed"); } else { // Input GE_RETURN_WITH_LOG_IF_ERROR(InitNDTensor(def_format_shape, data_type, i_tensor_desc), - "Init ND InputTensor failed"); + "[Invoke][InitNDTensor] failed"); // Output GE_RETURN_WITH_LOG_IF_ERROR(InitNDTensor(def_format_shape, data_type, o_tensor_desc), - "Init ND Output Tensor failed"); + "[Invoke][InitNDTensor] failed"); } } i_tensor_desc.SetFormat(ge::TypeUtils::DomiFormatToFormat(GetParserContext().format)); i_tensor_desc.SetOriginFormat(ge::TypeUtils::DomiFormatToFormat(GetParserContext().format)); o_tensor_desc.SetFormat(ge::TypeUtils::DomiFormatToFormat(GetParserContext().format)); if (op->AddInputDesc(i_tensor_desc) != ge::GRAPH_SUCCESS) { - GELOGE(domi::INTERNAL_ERROR, "AddInputDesc failed for op %s.", op->GetName().c_str()); + REPORT_CALL_ERROR("E19999", "AddInputDesc failed for op %s.", op->GetName().c_str()); + GELOGE(domi::INTERNAL_ERROR, "[Invoke][AddInputDesc] failed for op %s.", op->GetName().c_str()); return FAILED; } if (op->AddOutputDesc(o_tensor_desc) != ge::GRAPH_SUCCESS) { - GELOGE(domi::INTERNAL_ERROR, "AddOutputDesc failed for op %s.", op->GetName().c_str()); + REPORT_CALL_ERROR("E19999", "AddOutputDesc failed for op %s.", op->GetName().c_str()); + GELOGE(domi::INTERNAL_ERROR, "[Invoke][AddOutputDesc] failed for op %s.", op->GetName().c_str()); return FAILED; } return SUCCESS; @@ -102,7 +108,8 @@ Status DataOpParser::Init5DInputTensor(const vector &shape, ge::GeTenso int64_t tensor_size = 0; ge::graphStatus graph_status = ge::TensorUtils::GetTensorSizeInBytes(tensor_desc, tensor_size); if (graph_status != ge::GRAPH_SUCCESS) { - GELOGE(FAILED, "GetTensorSizeInBytes failed!"); + REPORT_CALL_ERROR("E19999", "GetTensorSizeInBytes failed"); + GELOGE(FAILED, "[Invoke][GetTensorSizeInBytes] failed!"); return domi::FAILED; } // Set the actual occupied space size @@ -146,7 +153,8 @@ Status DataOpParser::Init5DOutputTensor(const vector &shape, ge::GeTens int64_t output_size = 0; ge::graphStatus graph_status = ge::TensorUtils::GetTensorMemorySizeInBytes(output, output_size); if (graph_status != ge::GRAPH_SUCCESS) { - GELOGE(FAILED, "GetTensorMemorySizeInBytes failed!"); + REPORT_CALL_ERROR("E19999", "GetTensorMemorySizeInBytes failed!"); + GELOGE(FAILED, "[Invoke][GetTensorMemorySizeInBytes] failed!"); return domi::FAILED; } // Set the actual occupied space size @@ -186,7 +194,14 @@ Status DataOpParser::InitOutputTensor(const vector &shape, ge::GeTensor ge::graphStatus graph_status = ge::TensorUtils::CalcTensorMemSize(output_shape, format, data_type, output_size); if (graph_status != ge::GRAPH_SUCCESS) { - GELOGE(FAILED, "CalcTensorMemSize failed!"); + REPORT_CALL_ERROR("E19999", "CalcTensorMemSize failed, shape:%s, format:%s, datatype:%s", + output_shape.ToString().c_str(), + ge::TypeUtils::FormatToSerialString(format).c_str(), + ge::TypeUtils::DataTypeToSerialString(data_type).c_str()); + GELOGE(FAILED, "[Invoke][CalcTensorMemSize] failed, shape:%s, format:%s, datatype:%s", + output_shape.ToString().c_str(), + ge::TypeUtils::FormatToSerialString(format).c_str(), + ge::TypeUtils::DataTypeToSerialString(data_type).c_str()); return FAILED; } @@ -198,7 +213,14 @@ Status DataOpParser::InitOutputTensor(const vector &shape, ge::GeTensor int64_t size = output_size; auto valid_max_size = INT64_MAX - kTwoTimesAlign * kDataMemAlignSize; if (size > valid_max_size || size < 0) { - GELOGE(FAILED, "The updated mem size is out of data range [0, %ld]", valid_max_size); + REPORT_INNER_ERROR("E19999", "updated mem size is out of data range [0, %ld], shape:%s, format:%s, datatype:%s", + valid_max_size, output_shape.ToString().c_str(), + ge::TypeUtils::FormatToSerialString(format).c_str(), + ge::TypeUtils::DataTypeToSerialString(data_type).c_str()); + GELOGE(FAILED, "[Check][Size] updated mem size is out of data range [0, %ld], shape:%s, format:%s, datatype:%s", + valid_max_size, output_shape.ToString().c_str(), + ge::TypeUtils::FormatToSerialString(format).c_str(), + ge::TypeUtils::DataTypeToSerialString(data_type).c_str()); return FAILED; } else { size = ((size + kTwoTimesAlign * kDataMemAlignSize - 1) / kDataMemAlignSize) * kDataMemAlignSize; diff --git a/parser/common/model_saver.cc b/parser/common/model_saver.cc index 3bceeb9..34a2cde 100644 --- a/parser/common/model_saver.cc +++ b/parser/common/model_saver.cc @@ -35,7 +35,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelSaver::SaveJsonToFi const Json &model) { Status ret = SUCCESS; if (file_path == nullptr || SUCCESS != CheckPath(file_path)) { - GELOGE(FAILED, "Check output file failed."); + REPORT_INNER_ERROR("E19999", "param file_path is nullptr or checkpath not return success"); + GELOGE(FAILED, "[Check][Param]Check output file failed."); return FAILED; } std::string model_str; @@ -43,16 +44,18 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelSaver::SaveJsonToFi model_str = model.dump(kInteval, ' ', false, Json::error_handler_t::ignore); } catch (std::exception &e) { ErrorManager::GetInstance().ATCReportErrMessage("E19007", {"exception"}, {e.what()}); - GELOGE(FAILED, "Failed to convert JSON to string, reason: %s.", e.what()); + GELOGE(FAILED, "[Invoke][Dump] Failed to convert JSON to string, reason: %s, savefile:%s.", e.what(), file_path); return FAILED; } catch (...) { ErrorManager::GetInstance().ATCReportErrMessage("E19008"); - GELOGE(FAILED, "Failed to convert JSON to string."); + GELOGE(FAILED, "[Invoke][Dump] Failed to convert JSON to string, savefile:%s.", file_path); return FAILED; } char real_path[PATH_MAX] = {0}; - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(strlen(file_path) >= PATH_MAX, return FAILED, "file path is too long!"); + GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(strlen(file_path) >= PATH_MAX, + REPORT_INNER_ERROR("E19999", "file path %s is too long!", file_path); + return FAILED, "[Check][Param] file path %s is too long!", file_path); if (realpath(file_path, real_path) == nullptr) { GELOGI("File %s does not exit, it will be created.", file_path); } @@ -62,7 +65,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelSaver::SaveJsonToFi int32_t fd = mmOpen2(real_path, O_RDWR | O_CREAT | O_TRUNC, mode); if (fd == EN_ERROR || fd == EN_INVALID_PARAM) { ErrorManager::GetInstance().ATCReportErrMessage("E19001", {"file", "errmsg"}, {file_path, strerror(errno)}); - GELOGE(FAILED, "Open file[%s] failed. %s", file_path, strerror(errno)); + GELOGE(FAILED, "[Open][File] [%s] failed. %s", file_path, strerror(errno)); return FAILED; } const char *model_char = model_str.c_str(); @@ -73,12 +76,13 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelSaver::SaveJsonToFi ErrorManager::GetInstance().ATCReportErrMessage( "E19004", {"file", "errmsg"}, {file_path, strerror(errno)}); // Need to both print the error info of mmWrite and mmClose, so return ret after mmClose - GELOGE(FAILED, "Write to file failed. errno = %ld, %s", mmpa_ret, strerror(errno)); + GELOGE(FAILED, "[WriteTo][File] %s failed. errno = %ld, %s", file_path, mmpa_ret, strerror(errno)); ret = FAILED; } // Close file if (mmClose(fd) != EN_OK) { - GELOGE(FAILED, "Close file failed."); + REPORT_INNER_ERROR("E19999", "close file:%s failed", file_path); + GELOGE(FAILED, "[Close][File] %s failed.", file_path); ret = FAILED; } return ret; @@ -87,7 +91,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelSaver::SaveJsonToFi FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelSaver::CheckPath(const std::string &file_path) { // Determine file path length if (file_path.size() >= PATH_MAX) { - GELOGE(FAILED, "Path is too long:%zu", file_path.size()); + REPORT_INNER_ERROR("E19999", "Path is too long:%zu", file_path.size()); + GELOGE(FAILED, "[Check][Param] Path is too long:%zu", file_path.size()); return FAILED; } @@ -106,7 +111,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelSaver::CheckPath(co // If there is a path before the file name, create the path if (path_split_pos != -1) { if (CreateDirectory(std::string(file_path).substr(0, static_cast(path_split_pos))) != kFileOpSuccess) { - GELOGE(FAILED, "CreateDirectory failed, file path:%s.", file_path.c_str()); + GELOGE(FAILED, "[Create][Directory] failed, file path:%s.", file_path.c_str()); return FAILED; } } diff --git a/parser/common/op_def/ir_pb_converter.cc b/parser/common/op_def/ir_pb_converter.cc index 432a0d1..b17fe25 100644 --- a/parser/common/op_def/ir_pb_converter.cc +++ b/parser/common/op_def/ir_pb_converter.cc @@ -94,8 +94,16 @@ static void UpdateTensorForOpDesc(const ParserOperator &op, ge::OpDescPtr op_def FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY domi::Status ConvertToOpDesc(const ParserOperator &op, ge::OpDescPtr op_def) { - GE_RETURN_WITH_LOG_IF_TRUE(op_def == nullptr, "parameter is null."); - GE_CHK_BOOL_RET_STATUS(op.GetSchema(), domi::PARAM_INVALID, "Op schema is null, op type: %s", op.GetType().c_str()); + if (op_def == nullptr) { + REPORT_INNER_ERROR("E19999", "param op_def is nullptr, check invalid."); + GELOGE(ge::FAILED, "[Check][Param] param op_def is nullptr, check invalid."); + return ge::FAILED; + } + if (op.GetSchema() == nullptr) { + REPORT_INNER_ERROR("E19999", "Op schema is nullptr, op type: %s", op.GetType().c_str()); + GELOGE(domi::PARAM_INVALID, "[Get][Schema] Op schema is nullptr, op type: %s", op.GetType().c_str()); + return domi::PARAM_INVALID; + } op_def->SetName(op.GetName()); op_def->SetType(op.GetType()); GE_IF_BOOL_EXEC(op.GetType() == ge::parser::YOLO, op_def->SetType(ge::parser::REGION)); @@ -131,15 +139,21 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY domi::Status ConvertToOpDesc(co } } } - GE_CHK_BOOL_RET_STATUS(op.GetSchema()->Verify(op_def), domi::PARAM_INVALID, "Op schema verify failed, op name: %s", - op.GetName().c_str()); - + if (!op.GetSchema()->Verify(op_def)) { + REPORT_CALL_ERROR("E19999", "Op schema verify failed, op name: %s", op.GetName().c_str()); + GELOGE(domi::PARAM_INVALID, "[Invoke][Verify] Op schema verify failed, op name: %s", op.GetName().c_str()); + return domi::PARAM_INVALID; + } return domi::SUCCESS; } FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY domi::Status ConvertFromOpDesc(const ge::OpDescPtr op_def, ParserOperator &op) { - GE_RETURN_WITH_LOG_IF_TRUE(op_def == nullptr, "parameter is null."); + if (op_def == nullptr) { + REPORT_INNER_ERROR("E19999", "param op_def is nullptr, check invalid."); + GELOGE(ge::FAILED, "[Check][Param] param op_def is nullptr, check invalid."); + return ge::FAILED; + } op.Name(op_def->GetName()); map allattrs = op_def->GetAllAttrs(); diff --git a/parser/common/op_def/op_schema.cc b/parser/common/op_def/op_schema.cc index a6422ca..9d259a1 100644 --- a/parser/common/op_def/op_schema.cc +++ b/parser/common/op_def/op_schema.cc @@ -52,8 +52,10 @@ OpSchema &OpSchema::Attr(const Attribute &attr) { #define ATTR_SETTER_WITH_SINGLE_VALUE(Type, field, attrtype) \ OpSchema &OpSchema::Attr(const std::string &name, AttributeType attr_type, const Type &default_value) { \ if (attrtype != attr_type) { \ - GELOGE(FAILED, "Attribute specification param_type mismatch, input attr type %u, required attr type %u.", \ - (uint32_t)attr_type, (uint32_t)attrtype); \ + REPORT_INNER_ERROR("E19999", "Attribute specification param_type mismatch, input attr type %u, " \ + "required attr type %u.", (uint32_t)attr_type, (uint32_t)attrtype); \ + GELOGE(FAILED, "[Check][Param]Attribute specification param_type mismatch, " \ + "input attr type %u, required attr type %u.", (uint32_t)attr_type, (uint32_t)attrtype); \ return *this; \ } \ \ @@ -80,8 +82,10 @@ OpSchema &OpSchema::Attr(const Attribute &attr) { #define ATTR_SETTER_WITH_LIST_VALUE(Type, field, attrtype) \ OpSchema &OpSchema::Attr(const std::string &name, AttributeType attr_type, const std::vector &default_value) { \ if (attrtype != attr_type) { \ - GELOGE(FAILED, "Attribute specification vector param_type mismatch, input attr type %u, required attr type %u.", \ - (uint32_t)attr_type, (uint32_t)attrtype); \ + REPORT_INNER_ERROR("E19999", "Attribute specification vector param_type mismatch, " \ + "input attr type %u, required attr type %u.", (uint32_t)attr_type, (uint32_t)attrtype); \ + GELOGE(FAILED, "[Check][Param]Attribute specification vector param_type mismatch, " \ + "input attr type %u, required attr type %u.", (uint32_t)attr_type, (uint32_t)attrtype); \ return *this; \ } \ domi::AttrDef vec_a; \ @@ -93,8 +97,10 @@ OpSchema &OpSchema::Attr(const Attribute &attr) { } \ OpSchema &OpSchema::Attr(const std::string &name, AttributeType attr_type, const Tuple &default_value) { \ if (attrtype != attr_type) { \ - GELOGE(FAILED, "Attribute specification vector param_type mismatch, input attr type %u, required attr type %u.", \ - (uint32_t)attr_type, (uint32_t)attrtype); \ + REPORT_INNER_ERROR("E19999", "Attribute specification vector param_type mismatch, " \ + "input attr type %u, required attr type %u.", (uint32_t)attr_type, (uint32_t)attrtype); \ + GELOGE(FAILED, "[Check][Param]Attribute specification vector param_type mismatch, " \ + "input attr type %u, required attr type %u.", (uint32_t)attr_type, (uint32_t)attrtype); \ return *this; \ } \ domi::AttrDef tuple_a; \ @@ -168,7 +174,10 @@ const domi::AttrDef &OpSchema::GetDefaultAttr(const std::string &name) const { bool OpSchema::Verify(const ge::OpDescPtr op_def) const { if (op_def->GetType() != name_) { - GELOGE(FAILED, "Name not math, op schema name: %s, opdef type: %s.", name_.c_str(), op_def->GetType().c_str()); + REPORT_INNER_ERROR("E19999", "Name not math, op schema name: %s, opdef type: %s.", + name_.c_str(), op_def->GetType().c_str()); + GELOGE(FAILED, "[Check][Param]Name not math, op schema name: %s, opdef type: %s.", + name_.c_str(), op_def->GetType().c_str()); return false; } @@ -179,7 +188,10 @@ bool OpSchema::Verify(const ge::OpDescPtr op_def) const { continue; } if (!op_def->HasAttr(attr.name_)) { - GELOGE(FAILED, "Required attribute: %s of op: %s is missing.", attr.name_.c_str(), op_def->GetName().c_str()); + REPORT_INNER_ERROR("E19999", "Required attribute: %s of op: %s is missing.", + attr.name_.c_str(), op_def->GetName().c_str()); + GELOGE(FAILED, "[Invoke][HasAttr]Required attribute: %s of op: %s is missing.", + attr.name_.c_str(), op_def->GetName().c_str()); return false; } } diff --git a/parser/common/op_parser_factory.cc b/parser/common/op_parser_factory.cc index 1fbebbf..527cc96 100644 --- a/parser/common/op_parser_factory.cc +++ b/parser/common/op_parser_factory.cc @@ -54,7 +54,8 @@ FMK_FUNC_HOST_VISIBILITY std::shared_ptr OpParserFactory::Insta if (iter == instances.end()) { std::shared_ptr instance(new (std::nothrow) OpParserFactory()); if (instance == nullptr) { - GELOGE(INTERNAL_ERROR, "Create op parser factory failed."); + REPORT_CALL_ERROR("E19999", "create OpParserFactory failed"); + GELOGE(INTERNAL_ERROR, "[Create][OpParserFactory] failed."); return nullptr; } instances[framework] = instance; @@ -70,8 +71,8 @@ FMK_FUNC_HOST_VISIBILITY std::shared_ptr OpParserFactory::CreateOpPars if (iter != op_parser_creator_map_.end()) { return iter->second(); } - - GELOGE(FAILED, "OpParserFactory::CreateOpParser: Not supported type: %s", op_type.c_str()); + REPORT_INNER_ERROR("E19999", "param op_type invalid, Not supported type: %s", op_type.c_str()); + GELOGE(FAILED, "[Check][Param] OpParserFactory::CreateOpParser: Not supported type: %s", op_type.c_str()); return nullptr; } @@ -81,8 +82,8 @@ FMK_FUNC_HOST_VISIBILITY std::shared_ptr OpParserFactory::CreateFusion if (iter != fusion_op_parser_creator_map_.end()) { return iter->second(); } - - GELOGE(FAILED, "OpParserFactory::CreateOpParser: Not supported fusion op type: %s", op_type.c_str()); + REPORT_INNER_ERROR("E19999", "param op_type invalid, Not supported fusion op type: %s", op_type.c_str()); + GELOGE(FAILED, "[Check][Param] OpParserFactory::CreateOpParser: Not supported fusion op type: %s", op_type.c_str()); return nullptr; } diff --git a/parser/common/parser_factory.cc b/parser/common/parser_factory.cc index 0ba2736..9d53c64 100644 --- a/parser/common/parser_factory.cc +++ b/parser/common/parser_factory.cc @@ -28,8 +28,8 @@ std::shared_ptr WeightsParserFactory::CreateWeightsParser(const d if (iter != creator_map_.end()) { return iter->second(); } - - GELOGE(FAILED, "WeightsParserFactory::CreateWeightsParser: Not supported Type: %d", type); + REPORT_INNER_ERROR("E19999", "param type invalid, Not supported Type: %d", type); + GELOGE(FAILED, "[Check][Param]WeightsParserFactory::CreateWeightsParser: Not supported Type: %d", type); return nullptr; } @@ -58,8 +58,8 @@ std::shared_ptr ModelParserFactory::CreateModelParser(const domi::F if (iter != creator_map_.end()) { return iter->second(); } - - GELOGE(FAILED, "ModelParserFactory::CreateModelParser: Not supported Type: %d", type); + REPORT_INNER_ERROR("E19999", "param type invalid, Not supported Type: %d", type); + GELOGE(FAILED, "[Check][Param]ModelParserFactory::CreateModelParser: Not supported Type: %d", type); return nullptr; } diff --git a/parser/common/parser_utils.cc b/parser/common/parser_utils.cc index eddd8e7..58e178e 100644 --- a/parser/common/parser_utils.cc +++ b/parser/common/parser_utils.cc @@ -47,7 +47,8 @@ Status HandleNewOp(const NodePtr &node, GE_CHECK_NOTNULL(node); GE_CHECK_NOTNULL(new_node); if (new_node->SetOwnerComputeGraph(compute_graph) != GRAPH_SUCCESS) { - GELOGE(FAILED, "Set owner graph for node:%s failed.", new_node->GetName().c_str()); + REPORT_CALL_ERROR("E19999", "SetOwnerComputeGraph failed for node:%s", new_node->GetName().c_str()); + GELOGE(FAILED, "[Set][OwnerComputeGraph] for node:%s failed.", new_node->GetName().c_str()); return FAILED; } auto op_desc = new_node->GetOpDesc(); @@ -90,12 +91,13 @@ Status ParserUtils::ExpandOneToManyGraph(Graph &graph) { Operator op = OpDescUtils::CreateOperatorFromNode(n); Status ret = parse_op_to_graph_func(op, subgraph); if (ret != SUCCESS) { - GELOGE(FAILED, "Get one to many graph failed for op:%s.", op.GetName().c_str()); + REPORT_CALL_ERROR("E19999", "Get one to many graph failed for op:%s.", op.GetName().c_str()); + GELOGE(FAILED, "[Invoke][ParseOpToGraphFunc]Get one to many graph failed for op:%s.", op.GetName().c_str()); return FAILED; } ret = ExpandNodeToSubgraph(subgraph, n, graph); if (ret != SUCCESS) { - GELOGE(FAILED, "Expand one to many graph failed for op:%s.", op.GetName().c_str()); + GELOGE(FAILED, "[Invoke][ExpandNodeToSubgraph]Expand one to many graph failed for op:%s.", op.GetName().c_str()); return FAILED; } } @@ -116,7 +118,7 @@ Status ParserUtils::ExpandNodeToSubgraph(const Graph &subgraph, const NodePtr &n auto new_node = compute_graph->AddNode(n); GE_CHECK_NOTNULL(new_node); if (HandleNewOp(node, compute_graph, new_node, no_need_change_name) != SUCCESS) { - GELOGE(FAILED, "Handle new op[%s] for node[%s] failed.", new_node->GetName().c_str(), node->GetName().c_str()); + GELOGE(FAILED, "[Handle][NewOp][%s] for node[%s] failed.", new_node->GetName().c_str(), node->GetName().c_str()); return FAILED; } if (new_node->GetType() == ge::parser::DATA) { @@ -127,7 +129,7 @@ Status ParserUtils::ExpandNodeToSubgraph(const Graph &subgraph, const NodePtr &n // handle input context. Status ret = HandleInputContext(node, input_nodes, compute_graph); if (ret != SUCCESS) { - GELOGE(FAILED, "run ParserUtils::HandleInputContext failed."); + GELOGE(FAILED, "[Run][HandleInputContext] failed, node:%s.", node->GetName().c_str()); return FAILED; } @@ -135,18 +137,22 @@ Status ParserUtils::ExpandNodeToSubgraph(const Graph &subgraph, const NodePtr &n std::vector> out_node_index = sub_compute_graph->GetGraphOutNodesInfo(); ret = HandleOutputContext(node, out_node_index); if (ret != SUCCESS) { - GELOGE(FAILED, "run ParserUtils::HandleOutputContext failed."); + GELOGE(FAILED, "[Run][HandleOutputContext] failed, node:%s.", node->GetName().c_str()); return FAILED; } graphStatus graph_status = GraphUtils::RemoveNodeWithoutRelink(compute_graph, node); if (graph_status != GRAPH_SUCCESS) { - GELOGE(FAILED, "Remove node:%s failed.", node->GetName().c_str()); + REPORT_CALL_ERROR("E19999", "Remove node:%s from graph:%s failed.", node->GetName().c_str(), + compute_graph->GetName().c_str()); + GELOGE(FAILED, "[Remove][Node] %s from graph:%s failed.", node->GetName().c_str(), + compute_graph->GetName().c_str()); return FAILED; } graph_status = compute_graph->TopologicalSorting(); if (graph_status != GRAPH_SUCCESS) { - GELOGE(FAILED, "Topological sorting failed."); + REPORT_CALL_ERROR("E19999", "TopologicalSorting failed, graph:%s.", compute_graph->GetName().c_str()); + GELOGE(FAILED, "[Invoke][TopologicalSorting] failed, graph:%s.", compute_graph->GetName().c_str()); return FAILED; } return SUCCESS; @@ -160,7 +166,8 @@ Status ParserUtils::HandleInputContext(const NodePtr &node, GE_CHECK_NOTNULL(in_n); int index; if (!AttrUtils::GetInt(in_n->GetOpDesc(), ATTR_NAME_INDEX, index)) { - GELOGE(FAILED, "Get attr index of node:%s failed.", in_n->GetName().c_str()); + REPORT_INNER_ERROR("E19999", "GetInt failed, node:%s", in_n->GetName().c_str()); + GELOGE(FAILED, "[Get][AttrIndex] of node:%s failed.", in_n->GetName().c_str()); return FAILED; } GELOGD("Begin to handle input node:%s with index:%d.", in_n->GetName().c_str(), index); @@ -175,17 +182,29 @@ Status ParserUtils::HandleInputContext(const NodePtr &node, // add data edge graphStatus ret = GraphUtils::RemoveEdge(data_out_anchor, peer_in_anchor); if (ret != GRAPH_SUCCESS) { - GELOGE(FAILED, "remove data out anchor and peer in anchor failed."); + REPORT_CALL_ERROR("E19999", "remove edge from %s to %s failed.", + data_out_anchor->GetOwnerNode()->GetName().c_str(), + peer_in_anchor->GetOwnerNode()->GetName().c_str()); + GELOGE(FAILED, "[Remove][Edge] from %s to %s failed.", data_out_anchor->GetOwnerNode()->GetName().c_str(), + peer_in_anchor->GetOwnerNode()->GetName().c_str()); return FAILED; } ret = GraphUtils::RemoveEdge(src_out_anchor, node_in_anchor); if (ret != GRAPH_SUCCESS) { - GELOGE(FAILED, "remove node in anchor and peer out anchor failed."); + REPORT_CALL_ERROR("E19999", "remove edge from %s to %s failed.", + src_out_anchor->GetOwnerNode()->GetName().c_str(), + node_in_anchor->GetOwnerNode()->GetName().c_str()); + GELOGE(FAILED, "[Remove][Edge] from %s to %s failed.", src_out_anchor->GetOwnerNode()->GetName().c_str(), + node_in_anchor->GetOwnerNode()->GetName().c_str()); return FAILED; } ret = GraphUtils::AddEdge(src_out_anchor, peer_in_anchor); if (ret != GRAPH_SUCCESS) { - GELOGE(FAILED, "link node's peer out anchor and data's peer in anchor failed."); + REPORT_CALL_ERROR("E19999", "add edge from %s to %s failed.", + src_out_anchor->GetOwnerNode()->GetName().c_str(), + peer_in_anchor->GetOwnerNode()->GetName().c_str()); + GELOGE(FAILED, "[Add][Edge] from %s to %s failed.", src_out_anchor->GetOwnerNode()->GetName().c_str(), + peer_in_anchor->GetOwnerNode()->GetName().c_str()); return FAILED; } @@ -194,7 +213,11 @@ Status ParserUtils::HandleInputContext(const NodePtr &node, for (const auto &out_anchor : node->GetInControlAnchor()->GetPeerAnchors()) { graphStatus ret = GraphUtils::AddEdge(out_anchor, peer_in_anchor->GetOwnerNode()->GetInControlAnchor()); if (ret != GRAPH_SUCCESS) { - GELOGE(FAILED, "add control edge failed."); + REPORT_CALL_ERROR("E19999", "add control edge from %s to %s failed.", + out_anchor->GetOwnerNode()->GetName().c_str(), + peer_in_anchor->GetOwnerNode()->GetName().c_str()); + GELOGE(FAILED, "[Invoke][AddEdge]add control edge from %s to %s failed.", + out_anchor->GetOwnerNode()->GetName().c_str(), peer_in_anchor->GetOwnerNode()->GetName().c_str()); return FAILED; } } @@ -202,7 +225,9 @@ Status ParserUtils::HandleInputContext(const NodePtr &node, } graphStatus ret = GraphUtils::RemoveNodeWithoutRelink(compute_graph, in_n); if (ret != GRAPH_SUCCESS) { - GELOGE(FAILED, "remove node:%s failed.", in_n->GetName().c_str()); + REPORT_CALL_ERROR("E19999", "RemoveNodeWithoutRelink failed, graph:%s, node:%s.", + compute_graph->GetName().c_str(), in_n->GetName().c_str()); + GELOGE(FAILED, "[Remove][Node] %s failed, graph:%s.", in_n->GetName().c_str(), compute_graph->GetName().c_str()); return FAILED; } } @@ -227,12 +252,21 @@ Status ParserUtils::HandleOutputContext(const NodePtr &node, for (const auto &dest_in_anchor : node_out_anchor->GetPeerInDataAnchors()) { graphStatus ret = GraphUtils::RemoveEdge(node_out_anchor, dest_in_anchor); if (ret != GRAPH_SUCCESS) { - GELOGE(FAILED, "remove node's out anchor and peer in anchor failed."); + REPORT_CALL_ERROR("E19999", "remove edge from node %s to node %s failed.", + node_out_anchor->GetOwnerNode()->GetName().c_str(), + dest_in_anchor->GetOwnerNode()->GetName().c_str()); + GELOGE(FAILED, "[Remove][Edge] from node %s to node %s failed.", + node_out_anchor->GetOwnerNode()->GetName().c_str(), + dest_in_anchor->GetOwnerNode()->GetName().c_str()); return FAILED; } ret = GraphUtils::AddEdge(src_out_anchor, dest_in_anchor); if (ret != GRAPH_SUCCESS) { - GELOGE(FAILED, "link node's peer out anchor and out node's out anchor failed."); + REPORT_CALL_ERROR("E19999", "Add edge from %s to %s failed.", + src_out_anchor->GetOwnerNode()->GetName().c_str(), + dest_in_anchor->GetOwnerNode()->GetName().c_str()); + GELOGE(FAILED, "[Add][Edge] from %s to %s failed.", src_out_anchor->GetOwnerNode()->GetName().c_str(), + dest_in_anchor->GetOwnerNode()->GetName().c_str()); return FAILED; } } diff --git a/parser/common/pass_manager.cc b/parser/common/pass_manager.cc index 7219e60..6672c7e 100644 --- a/parser/common/pass_manager.cc +++ b/parser/common/pass_manager.cc @@ -55,7 +55,8 @@ Status PassManager::Run(const ComputeGraphPtr &graph, vectorGetAllSubgraphs()) { GE_CHECK_NOTNULL(subgraph); - GE_CHK_STATUS_RET(pass->ClearStatus(), "pass clear status failed for subgraph %s", subgraph->GetName().c_str()); + GE_CHK_STATUS_RET(pass->ClearStatus(), "[Invoke][ClearStatus]pass clear status failed for subgraph %s", + subgraph->GetName().c_str()); string subgraph_pass_name = pass_name + "::" + graph->GetName(); PARSER_TIMESTAMP_START(PassRunSubgraph); status = pass->Run(subgraph); @@ -63,7 +64,10 @@ Status PassManager::Run(const ComputeGraphPtr &graph, vectorGetName().c_str()); + REPORT_CALL_ERROR("E19999", "Pass Run failed on subgraph %s, pass name:%s", + subgraph->GetName().c_str(), subgraph_pass_name.c_str()); + GELOGE(status, "[Invoke][Run]Pass Run failed on subgraph %s, pass name:%s", + subgraph->GetName().c_str(), subgraph_pass_name.c_str()); return status; } } diff --git a/parser/common/pre_checker.cc b/parser/common/pre_checker.cc index 96a6345..9171087 100644 --- a/parser/common/pre_checker.cc +++ b/parser/common/pre_checker.cc @@ -75,7 +75,8 @@ FMK_FUNC_HOST_VISIBILITY PreChecker &PreChecker::Instance() { FMK_FUNC_HOST_VISIBILITY void PreChecker::SetModelName(const string &name) { model_name_ = name; } FMK_FUNC_HOST_VISIBILITY Status PreChecker::AddOp(OpId id, const string &name, const string &type) { - GE_RETURN_WITH_LOG_IF_TRUE(op_map_.find(id) != op_map_.end(), "Id already exists."); + GE_RETURN_WITH_LOG_IF_TRUE(op_map_.find(id) != op_map_.end(), + "[Check][Param] Id already exists, name:%s, type:%s.", name.c_str(), type.c_str()); Info info; info.id = id; @@ -89,7 +90,7 @@ FMK_FUNC_HOST_VISIBILITY Status PreChecker::AddOp(OpId id, const string &name, c Status PreChecker::CheckName(OpId id) { auto iter = op_map_.find(id); - GE_RETURN_WITH_LOG_IF_TRUE(iter == op_map_.end(), "Id does not exist."); + GE_RETURN_WITH_LOG_IF_TRUE(iter == op_map_.end(), "[Check][Param] Id does not exist."); Info &info = iter->second; for (auto &v : op_map_) { @@ -101,8 +102,8 @@ Status PreChecker::CheckName(OpId id) { GELOGI("Name %s repeated.", info.name.c_str()); ErrorManager::GetInstance().ATCReportErrMessage("E19009", {"opname"}, {info.name}); - GE_RETURN_WITH_LOG_IF_ERROR(AddCause(id, cause), "Add cause failed."); - GE_RETURN_WITH_LOG_IF_ERROR(AddCause(v.first, cause), "Add cause failed."); + GE_RETURN_WITH_LOG_IF_ERROR(AddCause(id, cause), "[Add][Cause] failed."); + GE_RETURN_WITH_LOG_IF_ERROR(AddCause(v.first, cause), "[Add][Cause] failed."); break; } } @@ -112,7 +113,7 @@ Status PreChecker::CheckName(OpId id) { FMK_FUNC_HOST_VISIBILITY Status PreChecker::CheckType(OpId id, bool is_tensorflow) { auto iter = op_map_.find(id); - GE_RETURN_WITH_LOG_IF_TRUE(iter == op_map_.end(), "Id does not exist."); + GE_RETURN_WITH_LOG_IF_TRUE(iter == op_map_.end(), "[Check][Param] Id does not exist."); Info &info = iter->second; string type = info.type; @@ -125,8 +126,9 @@ FMK_FUNC_HOST_VISIBILITY Status PreChecker::CheckType(OpId id, bool is_tensorflo } // Judge whether the type is supported - GE_RETURN_WITH_LOG_IF_ERROR( - CheckTypeSupported(info.id, type, info.name, is_tensorflow), "Check type supported failed."); + GE_RETURN_WITH_LOG_IF_ERROR(CheckTypeSupported(info.id, type, info.name, is_tensorflow), + "[Invoke][CheckTypeSupported] failed, type:%s, name:%s.", + type.c_str(), info.name.c_str()); return SUCCESS; } @@ -151,7 +153,7 @@ FMK_FUNC_HOST_VISIBILITY void PreChecker::RefreshErrorMessageByName(const string Status PreChecker::AddCause(OpId id, const Cause &cause) { auto iter = op_map_.find(id); - GE_RETURN_WITH_LOG_IF_TRUE(iter == op_map_.end(), "Id does not exist."); + GE_RETURN_WITH_LOG_IF_TRUE(iter == op_map_.end(), "[Check][Param] Id does not exist."); Info &info = iter->second; @@ -171,7 +173,7 @@ void PreChecker::Clear() { Init(); } Status PreChecker::Clear(OpId id, const string &message) { auto iter = op_map_.find(id); - GE_RETURN_WITH_LOG_IF_TRUE(iter == op_map_.end(), "Id does not exist."); + GE_RETURN_WITH_LOG_IF_TRUE(iter == op_map_.end(), "[Check][Param] Id does not exist."); Info &info = iter->second; info.causes.clear(); @@ -181,7 +183,7 @@ Status PreChecker::Clear(OpId id, const string &message) { Cause cause; cause.code = ErrorCode::OK; cause.message = message; - GE_RETURN_WITH_LOG_IF_ERROR(AddCause(id, cause), "Add cause failed."); + GE_RETURN_WITH_LOG_IF_ERROR(AddCause(id, cause), "[Add][Cause] failed."); } return SUCCESS; @@ -216,7 +218,7 @@ Status PreChecker::Save(string file) { // Constructing JSON information of operators in order of network for (auto id : ops_) { auto iter = op_map_.find(id); - GE_CHK_BOOL_RET_STATUS(iter != op_map_.end(), FAILED, "don't find this op."); + GE_CHK_BOOL_RET_STATUS(iter != op_map_.end(), FAILED, "[Check][Param] don't find this op."); Info &info = iter->second; // Initialization operator general information @@ -233,7 +235,8 @@ Status PreChecker::Save(string file) { } // Save JSON data to a file - GE_RETURN_WITH_LOG_IF_ERROR(ge::parser::ModelSaver::SaveJsonToFile(file.c_str(), model), "Save failed."); + GE_RETURN_WITH_LOG_IF_ERROR(ge::parser::ModelSaver::SaveJsonToFile(file.c_str(), model), + "[Invoke][SaveJsonToFile]Save failed, file:%s.", file.c_str()); return SUCCESS; } @@ -250,7 +253,7 @@ Status PreChecker::CheckTypeSupported(OpId id, const string &type, const string if (!is_tensorflow) { ErrorManager::GetInstance().ATCReportErrMessage("E19010", {"opname", "optype"}, {name, type}); } - GE_RETURN_WITH_LOG_IF_ERROR(AddCause(id, cause), "Add cause failed."); + GE_RETURN_WITH_LOG_IF_ERROR(AddCause(id, cause), "[Add][Cause] failed."); } return SUCCESS; } @@ -265,7 +268,7 @@ Status PreChecker::CheckTypeSupported(OpId id, const string &type, const string if (!is_tensorflow) { ErrorManager::GetInstance().ATCReportErrMessage("E19010", {"opname", "optype"}, {name, type}); } - GE_RETURN_WITH_LOG_IF_ERROR(AddCause(id, cause), "Add cause failed."); + GE_RETURN_WITH_LOG_IF_ERROR(AddCause(id, cause), "[Add][Cause] failed."); } return SUCCESS; @@ -273,7 +276,7 @@ Status PreChecker::CheckTypeSupported(OpId id, const string &type, const string bool PreChecker::HasError(OpId id) { auto iter = op_map_.find(id); - GE_RETURN_WITH_LOG_IF_TRUE(iter == op_map_.end(), "Id does not exist."); + GE_RETURN_WITH_LOG_IF_TRUE(iter == op_map_.end(), "[Check][Param] Id does not exist."); Info &info = iter->second; for (const Cause &cause : info.causes) { diff --git a/parser/common/proto_file_parser.cc b/parser/common/proto_file_parser.cc index 9e24d65..ddde269 100644 --- a/parser/common/proto_file_parser.cc +++ b/parser/common/proto_file_parser.cc @@ -130,12 +130,16 @@ bool SaveIdentifierOpMapInfo(const string &line, std::map factory = OpParserFactory::Instance(domi::TENSORFLOW); if (factory == nullptr) { - GELOGE(INTERNAL_ERROR, "Get op parser factory for tf failed."); + REPORT_CALL_ERROR("E19999", "Get OpParserFactory failed."); + GELOGE(INTERNAL_ERROR, "[Get][OpParserFactory] for tf failed."); return false; } if (reg_data.GetParseParamFn() != nullptr || reg_data.GetParseParamByOperatorFn() != nullptr) { @@ -79,7 +80,8 @@ bool OpRegistrationTbe::RegisterParser(const OpRegistrationData ®_data) { std::shared_ptr tf_parser_adapter = ge::parser::MakeShared(); if (tf_parser_adapter == nullptr) { - GELOGE(PARAM_INVALID, "Create tf parser adapter failed."); + REPORT_CALL_ERROR("E19999", "Create TensorFlowCustomParserAdapter failed."); + GELOGE(PARAM_INVALID, "[Create][TensorFlowCustomParserAdapter] failed."); return false; } OpParserRegisterar registerar __attribute__((unused)) = OpParserRegisterar( @@ -95,7 +97,8 @@ bool OpRegistrationTbe::RegisterParser(const OpRegistrationData ®_data) { std::shared_ptr tf_fusion_parser_adapter = ge::parser::MakeShared(); if (tf_fusion_parser_adapter == nullptr) { - GELOGE(PARAM_INVALID, "Create tf fusion parser adapter failed."); + REPORT_CALL_ERROR("E19999", "Create TensorFlowFusionCustomParserAdapter failed."); + GELOGE(PARAM_INVALID, "[Create][TensorFlowFusionCustomParserAdapter] failed."); return false; } OpParserRegisterar registerar __attribute__((unused)) = OpParserRegisterar( @@ -105,7 +108,9 @@ bool OpRegistrationTbe::RegisterParser(const OpRegistrationData ®_data) { } else { std::shared_ptr factory = OpParserFactory::Instance(reg_data.GetFrameworkType()); if (factory == nullptr) { - GELOGE(INTERNAL_ERROR, "Get op parser factory for %s failed.", + REPORT_CALL_ERROR("E19999", "Get OpParserFactory for %s failed.", + TypeUtils::FmkTypeToSerialString(reg_data.GetFrameworkType()).c_str()); + GELOGE(INTERNAL_ERROR, "[Get][OpParserFactory] for %s failed.", TypeUtils::FmkTypeToSerialString(reg_data.GetFrameworkType()).c_str()); return false; } @@ -117,7 +122,9 @@ bool OpRegistrationTbe::RegisterParser(const OpRegistrationData ®_data) { PARSER_CREATOR_FN func = CustomParserAdapterRegistry::Instance()->GetCreateFunc(reg_data.GetFrameworkType()); if (func == nullptr) { - GELOGE(INTERNAL_ERROR, "Get custom parser adapter failed for fmk type %s.", + REPORT_CALL_ERROR("E19999", "Get custom parser adapter failed for fmk type %s.", + TypeUtils::FmkTypeToSerialString(reg_data.GetFrameworkType()).c_str()); + GELOGE(INTERNAL_ERROR, "[Get][CustomParserAdapter] failed for fmk type %s.", TypeUtils::FmkTypeToSerialString(reg_data.GetFrameworkType()).c_str()); return false; } diff --git a/parser/onnx/onnx_constant_parser.cc b/parser/onnx/onnx_constant_parser.cc index 0bc8d97..19d2e85 100644 --- a/parser/onnx/onnx_constant_parser.cc +++ b/parser/onnx/onnx_constant_parser.cc @@ -36,7 +36,8 @@ namespace ge { Status OnnxConstantParser::ParseConvertData(const ge::onnx::TensorProto &tensor_proto, ge::Tensor &tensor, int count) { int64_t data_type = tensor_proto.data_type(); if (ge::OnnxUtil::ConvertOnnxDataType(data_type) == ge::DataType::DT_UNDEFINED) { - GELOGE(FAILED, "data_type %ld not support.", data_type); + REPORT_INNER_ERROR("E19999", "data_type %ld not support.", data_type); + GELOGE(FAILED, "[Check][Param] data_type %ld not support.", data_type); return FAILED; } @@ -74,14 +75,16 @@ Status OnnxConstantParser::ParseConvertData(const ge::onnx::TensorProto &tensor_ if (iter != datatype_val_size_map.end()) { datatype_val_size = iter->second; } else { - GELOGE(domi::PARAM_INVALID, "data_type %ld not support.", data_type); + REPORT_INNER_ERROR("E19999", "data_type %ld not support.", data_type); + GELOGE(domi::PARAM_INVALID, "[Find][DataType]data_type %ld not support.", data_type); return FAILED; } // find raw data if (datatype_val_size == 0) { if (tensor_proto.raw_data().empty()) { - GELOGE(domi::PARAM_INVALID, "tensor_proto has no data() elements or raw_data()"); + REPORT_INNER_ERROR("E19999", "tensor_proto has no elements or raw_data"); + GELOGE(domi::PARAM_INVALID, "[Check][Param]tensor_proto has no elements or raw_data"); return FAILED; } @@ -161,7 +164,8 @@ Status OnnxConstantParser::ParseConvertTensor(const ge::onnx::TensorProto &tenso int64_t dim = tmp_shape[i]; // support weights shape [0],have no weights if (dim < 0 || (count != 0 && (dim >= INT64_MAX / count))) { - GELOGE(FAILED, "Dim size is invalid, dim is less than zero or dim size exceeds INT64_MAX."); + REPORT_INNER_ERROR("E19999", "Dim size is invalid, dim is less than zero or dim size exceeds INT64_MAX."); + GELOGE(FAILED, "[Check][Param] Dim size is invalid, dim is less than zero or dim size exceeds INT64_MAX."); return FAILED; } count *= dim; @@ -172,7 +176,7 @@ Status OnnxConstantParser::ParseConvertTensor(const ge::onnx::TensorProto &tenso // set data if (ParseConvertData(tensor_proto, tensor, count) != SUCCESS) { - GELOGE(FAILED, "Convert ge tensor data and format failed."); + GELOGE(FAILED, "[Invoke][ParseConvertData]Convert ge tensor data and format failed."); return FAILED; } return SUCCESS; @@ -182,7 +186,8 @@ Status OnnxConstantParser::ParseConvertDataType(const ge::onnx::TensorProto &ten int64_t data_type = tensor_proto.data_type(); ge::DataType type = ge::OnnxUtil::ConvertOnnxDataType(data_type); if (type == ge::DataType::DT_UNDEFINED) { - GELOGE(domi::PARAM_INVALID, "tensor_proto date type %ld is undefined.", data_type); + REPORT_INNER_ERROR("E19999", "tensor_proto date type %ld is undefined.", data_type); + GELOGE(domi::PARAM_INVALID, "[Check][Param] tensor_proto date type %ld is undefined.", data_type); return FAILED; } @@ -204,12 +209,13 @@ Status OnnxConstantParser::ParseConstFromInput(const ge::onnx::NodeProto *op_src } const ::ge::onnx::TensorProto it_tensor = it.t(); if (ParseConvertDataType(it_tensor, tensor) != SUCCESS) { - GELOGE(FAILED, "Convert ge tensor date type failed, attribute name is %s.", it.name().c_str()); + GELOGE(FAILED, "[Check][Param] Convert ge tensor date type failed, attribute name is %s.", it.name().c_str()); return FAILED; } if (ParseConvertTensor(it_tensor, tensor) != SUCCESS) { - GELOGE(FAILED, "Convert ge tensor shape and format failed, attribute name is %s.", it.name().c_str()); + GELOGE(FAILED, "[Check][Param] Convert ge tensor shape and format failed, attribute name is %s.", + it.name().c_str()); return FAILED; } } @@ -225,7 +231,7 @@ Status OnnxConstantParser::ParseParams(const Message *op_src, ge::Operator &op_d GELOGD("Onnx op node name = %s, op type= %s, parse params", node->name().c_str(), node->op_type().c_str()); if (ParseConstFromInput(node, op_def) != SUCCESS) { - GELOGE(FAILED, "Parse constant node %s failed", node->name().c_str()); + GELOGE(FAILED, "[Parse][Constant] node %s failed", node->name().c_str()); return FAILED; } return SUCCESS; diff --git a/parser/onnx/onnx_custom_parser_adapter.cc b/parser/onnx/onnx_custom_parser_adapter.cc index fa7d702..3b7e7b0 100644 --- a/parser/onnx/onnx_custom_parser_adapter.cc +++ b/parser/onnx/onnx_custom_parser_adapter.cc @@ -34,7 +34,7 @@ Status OnnxCustomParserAdapter::ParseParams(const Message *op_src, ge::Operator custom_op_parser = domi::OpRegistry::Instance()->GetParseParamFunc(op_dest.GetOpType(), node_src->op_type()); GE_CHECK_NOTNULL(custom_op_parser); if (custom_op_parser(op_src, op_dest) != SUCCESS) { - GELOGE(FAILED, "Custom parser params failed."); + GELOGE(FAILED, "[Invoke][Custom_Op_Parser] Custom parser params failed."); return FAILED; } return SUCCESS; diff --git a/parser/onnx/onnx_data_parser.cc b/parser/onnx/onnx_data_parser.cc index 367eb32..e0ee308 100644 --- a/parser/onnx/onnx_data_parser.cc +++ b/parser/onnx/onnx_data_parser.cc @@ -32,7 +32,7 @@ Status OnnxDataParser::ParseParams(const Message *op_src, ge::Operator &op_def) GE_CHECK_NOTNULL(node_src); GELOGD("Onnx op node name = %s, op type= %s, parse params", node_src->name().c_str(), node_src->op_type().c_str()); if (ParseInputFromModel(op_src, op_def) != SUCCESS) { - GELOGE(FAILED, "parse shape of data op %s from model failed", op_def.GetName().c_str()); + GELOGE(FAILED, "[Parse][Shape] of data op %s from model failed", op_def.GetName().c_str()); return FAILED; } // Subgraph data operator don't need parse input shape @@ -42,7 +42,7 @@ Status OnnxDataParser::ParseParams(const Message *op_src, ge::Operator &op_def) } if (ParseInputFromUser(op_def) != SUCCESS) { - GELOGE(FAILED, "parse shape of data op %s from user failed", op_def.GetName().c_str()); + GELOGE(FAILED, "[Parse][Shape] of data op %s from user failed", op_def.GetName().c_str()); return FAILED; } @@ -97,7 +97,8 @@ Status OnnxDataParser::ParseInputFromModel(const Message *op_src, ge::Operator & // Trans onnx type to ge type DataType type = OnnxUtil::ConvertOnnxDataType(data_type); if (type == ge::DataType::DT_UNDEFINED) { - GELOGE(domi::PARAM_INVALID, "tensor_proto date type %ld is undefined.", data_type); + REPORT_INNER_ERROR("E19999", "tensor_proto date type %ld is undefined.", data_type); + GELOGE(domi::PARAM_INVALID, "[Check][Param]tensor_proto date type %ld is undefined.", data_type); return FAILED; } op_def.SetAttr(ge::DATA_ATTR_NAME_DATA_TYPE, static_cast(type)); diff --git a/parser/onnx/onnx_parser.cc b/parser/onnx/onnx_parser.cc index 39b4bc8..3eb3f2d 100644 --- a/parser/onnx/onnx_parser.cc +++ b/parser/onnx/onnx_parser.cc @@ -51,13 +51,15 @@ graphStatus PrepareBeforeParse(AclGrphParseUtil &acl_graph_parse_util, options.insert(std::pair(string(ge::FRAMEWORK_TYPE), to_string(domi::ONNX))); if (acl_graph_parse_util.AclParserInitialize(options) != ge::SUCCESS) { - GELOGE(ge::FAILED, "Acl parser initialize failed."); + REPORT_CALL_ERROR("E19999", "AclParserInitialize failed."); + GELOGE(ge::FAILED, "[Init][AclParser] failed."); return ge::FAILED; } string output_name; if (acl_graph_parse_util.ParseParamsBeforeGraph(parser_params, output_name) != ge::SUCCESS) { - GELOGE(ge::FAILED, "Parser params before graph failed."); + REPORT_CALL_ERROR("E19999", "ParseParamsBeforeGraph failed."); + GELOGE(ge::FAILED, "[Parser][Params] before graph failed."); return ge::FAILED; } // Create an empty computegraph @@ -75,12 +77,14 @@ graphStatus HandleAfterParse(AclGrphParseUtil &acl_graph_parse_util, const std::map &parser_params, ge::Graph &graph) { if (acl_graph_parse_util.ParseParamsAfterGraph(graph, parser_params) != ge::SUCCESS) { - GELOGE(ge::FAILED, "Parser params after graph failed."); + REPORT_CALL_ERROR("E19999", "ParseParamsAfterGraph failed."); + GELOGE(ge::FAILED, "[Parser][Params] after graph failed."); return ge::FAILED; } if (acl_graph_parse_util.SetOutputNodeInfo(graph, parser_params) != ge::SUCCESS) { - GELOGE(ge::FAILED, "Set graph %s default output node failed.", graph.GetName().c_str()); + REPORT_CALL_ERROR("E19999", "Set graph default output node failed."); + GELOGE(ge::FAILED, "[Update][NodeInfo] Set graph %s default output node failed.", graph.GetName().c_str()); return ge::FAILED; } return ge::SUCCESS; @@ -94,7 +98,7 @@ graphStatus aclgrphParseONNX(const char *model_file, std::shared_ptr model_parser; if (PrepareBeforeParse(acl_graph_parse_util, parser_params, graph, model_parser) != ge::SUCCESS) { - GELOGE(ge::FAILED, "Prepare before parse failed."); + GELOGE(ge::FAILED, "[Invoke][PrepareBeforeParse] failed."); return ge::FAILED; } @@ -102,13 +106,14 @@ graphStatus aclgrphParseONNX(const char *model_file, // parse onnx model_file to GE graph ge::graphStatus ret = model_parser->Parse(model_file, graph); if (ret != ge::SUCCESS) { - GELOGE(ret, "Parser graph %s failed.", graph.GetName().c_str()); + REPORT_CALL_ERROR("E19999", "parse modelfile %s failed, graph:%s", model_file, graph.GetName().c_str()); + GELOGE(ret, "[Parse][ModelFile] %s failed, graph %s.", model_file, graph.GetName().c_str()); return ge::FAILED; } GELOGI("Parser graph %s success.", graph.GetName().c_str()); if (HandleAfterParse(acl_graph_parse_util, parser_params, graph) != ge::SUCCESS) { - GELOGE(ge::FAILED, "Handle after parse failed."); + GELOGE(ge::FAILED, "[Invoke][HandleAfterParse] failed."); return ge::FAILED; } @@ -124,20 +129,21 @@ graphStatus aclgrphParseONNXFromMem(const char *buffer, size_t size, std::shared_ptr model_parser; if (PrepareBeforeParse(acl_graph_parse_util, parser_params, graph, model_parser) != ge::SUCCESS) { - GELOGE(ge::FAILED, "Prepare before parse failed."); + GELOGE(ge::FAILED, "[Invoke][PrepareBeforeParse] failed."); return ge::FAILED; } // parse caffe model_file to GE graph ge::graphStatus ret = model_parser->ParseFromMemory(buffer, (uint32_t)size, graph); if (ret != ge::SUCCESS) { - GELOGE(ret, "Parser graph %s failed.", graph.GetName().c_str()); + REPORT_CALL_ERROR("E19999", "ParseFromMemory failed"); + GELOGE(ret, "[Parser][Graph] %s failed.", graph.GetName().c_str()); return ge::FAILED; } GELOGI("Parser graph %s success.", graph.GetName().c_str()); if (HandleAfterParse(acl_graph_parse_util, parser_params, graph) != ge::SUCCESS) { - GELOGE(ge::FAILED, "Handle after parse failed."); + GELOGE(ge::FAILED, "[Invoke][HandleAfterParse] failed."); return ge::FAILED; } GELOGI("AclgrphParse graph %s success.", graph.GetName().c_str()); @@ -380,7 +386,8 @@ Status OnnxModelParser::ConstructOriType(const ge::onnx::NodeProto *node_proto, if (it != domain_verseion_.end()) { version = it->second; } else { - GELOGE(PARAM_INVALID, "The opset of domain[%s] has no responding version.", domain.c_str()); + REPORT_INNER_ERROR("E19999", "The opset of domain[%s] has no responding version.", domain.c_str()); + GELOGE(PARAM_INVALID, "[Check][Param]The opset of domain[%s] has no responding version.", domain.c_str()); return PARAM_INVALID; } } else { @@ -389,9 +396,9 @@ Status OnnxModelParser::ConstructOriType(const ge::onnx::NodeProto *node_proto, domain = domain_verseion_.begin()->first; version = domain_verseion_.begin()->second; } else { - GELOGE(PARAM_INVALID, "The size of domain_version[%zu] should be equal to one.", domain_version_size); - ErrorManager::GetInstance().ATCReportErrMessage("E16005", - {"domain_version_size"}, + GELOGE(PARAM_INVALID, "[Check][Param]The size of domain_version[%zu] should be equal to one.", + domain_version_size); + ErrorManager::GetInstance().ATCReportErrMessage("E16005", {"domain_version_size"}, {to_string(domain_version_size)}); return PARAM_INVALID; } @@ -419,13 +426,13 @@ Status OnnxModelParser::AdapterOpType(const ge::onnx::NodeProto *node_proto, std Status ret = ConstructOriType(node_proto, ori_type); if (ret != SUCCESS) { - GELOGE(ret, "Construct ori type for [%s] failed.", ori_type.c_str()); + GELOGE(ret, "[Construct][OriType] for [%s] failed.", ori_type.c_str()); return ret; } if (!domi::OpRegistry::Instance()->GetOmTypeByOriOpType(ori_type, op_type)) { ErrorManager::GetInstance().ATCReportErrMessage("E16002", {"optype"}, {ori_type}); - GELOGE(PARAM_INVALID, "Get omType according ori_type : %s failed.", ori_type.c_str()); + GELOGE(PARAM_INVALID, "[Get][OmType] according ori_type : %s failed.", ori_type.c_str()); return PARAM_INVALID; } @@ -440,7 +447,8 @@ Status OnnxModelParser::TransNodeToOperator(const ge::onnx::NodeProto *node_prot op = ge::OperatorFactory::CreateOperator(node_name, op_type); if (op.GetName() != node_name) { ErrorManager::GetInstance().ATCReportErrMessage("E16003", {"opname", "optype"}, {node_name, op_type}); - GELOGE(INTERNAL_ERROR, "[Creat][Op] IR for op[%s] optype[%s] is not registered.", node_name.c_str(), op_type.c_str()); + GELOGE(INTERNAL_ERROR, "[Creat][Op] IR for op[%s] optype[%s] is not registered.", + node_name.c_str(), op_type.c_str()); REPORT_INNER_ERROR("E19999", "IR for op[%s] optype[%s] is not registered.", node_name.c_str(), op_type.c_str()); return INTERNAL_ERROR; } @@ -484,12 +492,16 @@ Status OnnxModelParser::SetOperatorInputs() { for (auto out_node_index : output_node_indexs) { auto input_op_iter = name_operator_.find(input_node_index.first); if (input_op_iter == name_operator_.end()) { - GELOGE(INTERNAL_ERROR, "Node: %s can not find in name_operator map.", input_node_index.first.c_str()); + REPORT_INNER_ERROR("E19999", "Node: %s can not find in name_operator map.", input_node_index.first.c_str()); + GELOGE(INTERNAL_ERROR, "[Check][Param] Node: %s can not find in name_operator map.", + input_node_index.first.c_str()); return INTERNAL_ERROR; } auto output_op_iter = name_operator_.find(out_node_index.first); if (output_op_iter == name_operator_.end()) { - GELOGE(INTERNAL_ERROR, "Node: %s can not find in name_operator map.", out_node_index.first.c_str()); + REPORT_INNER_ERROR("E19999", "Node: %s can not find in name_operator map.", out_node_index.first.c_str()); + GELOGE(INTERNAL_ERROR, "[Check][Param] Node: %s can not find in name_operator map.", + out_node_index.first.c_str()); return INTERNAL_ERROR; } @@ -518,21 +530,24 @@ Status OnnxModelParser::Prechecker(ge::onnx::GraphProto &onnx_graph) { std::string ori_type; Status ret = ConstructOriType(node, ori_type); if (ret != SUCCESS) { - GELOGE(ret, "Construct ori type for [%s] failed.", ori_type.c_str()); + GELOGE(ret, "[Construct][OriType] for [%s] failed.", ori_type.c_str()); return ret; } GELOGI("Construct ori type : %s ", ori_type.c_str()); if (ge::PreChecker::Instance().AddOp(node, node->name(), ori_type) != SUCCESS) { - GELOGE(FAILED, "Add node_def to PreChecker failed, node name: %s.", node->name().c_str()); + REPORT_CALL_ERROR("E19999", "AddOp failed, node:%s", node->name().c_str()); + GELOGE(FAILED, "[Add][NodeDef] to PreChecker failed, node name: %s.", node->name().c_str()); return FAILED; } if (ge::PreChecker::Instance().CheckName(node) != SUCCESS) { - GELOGE(FAILED, "Check node_def name failed, node name: %s.", node->name().c_str()); + REPORT_CALL_ERROR("E19999", "CheckName failed for node:%s", node->name().c_str()); + GELOGE(FAILED, "[Check][Name] failed, node name: %s.", node->name().c_str()); return FAILED; } if (kOnnxOpMap.find(ori_type) == kOnnxOpMap.end()) { if (ge::PreChecker::Instance().CheckType(node) != SUCCESS) { - GELOGE(FAILED, "Check node_def type failed, node name: %s.", node->name().c_str()); + REPORT_CALL_ERROR("E19999", "CheckType failed for node:%s", node->name().c_str()); + GELOGE(FAILED, "[Check][Type] failed, node name: %s.", node->name().c_str()); return FAILED; } } @@ -575,7 +590,8 @@ Status OnnxModelParser::ParseAllNodeProto(ge::onnx::GraphProto &onnx_graph, ge:: GE_CHECK_NOTNULL(onnx_op_parser); status = onnx_op_parser->ParseParams(node_proto, op); if (status != SUCCESS) { - GELOGE(status, "Parse params for %s:%s failed.", node_name.c_str(), op_type.c_str()); + REPORT_CALL_ERROR("E19999", "ParseParams for %s:%s failed ret:%d.", node_name.c_str(), op_type.c_str(), status); + GELOGE(status, "[Parse][Params] for %s:%s failed ret:%d.", node_name.c_str(), op_type.c_str(), status); return status; } @@ -594,7 +610,8 @@ Status OnnxModelParser::ParseAllNodeProto(ge::onnx::GraphProto &onnx_graph, ge:: // 8. Construct input output relation of every node status = ConstructInputOutputContext(node_proto); if (status != SUCCESS) { - GELOGE(status, "Construct input output relation map failed."); + REPORT_INNER_ERROR("E19999", "ConstructInputOutputContext failed."); + GELOGE(status, "[Construct][RelationMap] to input and output failed."); return status; } } @@ -661,7 +678,7 @@ Status OnnxModelParser::GetModelFromFile(const char *file, ge::onnx::ModelProto if (!ge::parser::ReadProtoFromBinaryFile(file, &onnx_model)) { ErrorManager::GetInstance().ATCReportErrMessage( "E19021", {"reason"}, {"Read onnx model file failed."}); - GELOGE(PARAM_INVALID, "Read onnx model file failed."); + GELOGE(PARAM_INVALID, "[Read][ModeFile] failed."); return FAILED; } return SUCCESS; @@ -674,7 +691,7 @@ Status OnnxModelParser::GetModelFromMemory(const char *data, uint32_t size, ge:: if (!ge::parser::ReadProtoFromArray(data, size, &onnx_model)) { ErrorManager::GetInstance().ATCReportErrMessage( "E19021", {"reason"}, {"Read onnx model from memory failed."}); - GELOGE(PARAM_INVALID, "Read onnx model from memory failed."); + GELOGE(PARAM_INVALID, "[Read][OnnxModel] from memory failed."); return FAILED; } return SUCCESS; @@ -836,7 +853,7 @@ Status OnnxModelParser::ModelParseToGraphImpl(bool is_subgraph, ge::onnx::GraphP Status ret = ParseInput(initializer_name_tensor, is_subgraph, onnx_graph); if (ret != SUCCESS) { - GELOGE(ret, "Parse input for onnx failed."); + GELOGE(ret, "[Parse][Input] for onnx failed."); return ret; } GELOGI("The size of initializer_name_tensor is %zu after ParseInput", initializer_name_tensor.size()); @@ -844,7 +861,7 @@ Status OnnxModelParser::ModelParseToGraphImpl(bool is_subgraph, ge::onnx::GraphP // 4. Parse Constant from graph. ret = ParseInitializer(onnx_graph, initializer_name_tensor); if (ret != SUCCESS) { - GELOGE(ret, "Parse initializer for onnx failed."); + GELOGE(ret, "[Parse][Initializer] for onnx failed."); return ret; } @@ -857,7 +874,7 @@ Status OnnxModelParser::ModelParseToGraphImpl(bool is_subgraph, ge::onnx::GraphP // 5. Update node name for node do not has name. ret = UpdateAllNodeName(onnx_graph); if (ret != SUCCESS) { - GELOGE(ret, "Update all node name for onnx failed."); + GELOGE(ret, "[Update][Name] of all node for onnx failed."); return ret; } @@ -865,7 +882,7 @@ Status OnnxModelParser::ModelParseToGraphImpl(bool is_subgraph, ge::onnx::GraphP ret = Prechecker(onnx_graph); bool is_precheck_failed = (ret != SUCCESS) || (ge::PreChecker::Instance().HasError()); if (is_precheck_failed) { - GELOGE(FAILED, "Prechecker failed."); + GELOGE(FAILED, "[Invoke][Prechecker] failed."); return FAILED; } @@ -877,7 +894,7 @@ Status OnnxModelParser::ModelParseToGraphImpl(bool is_subgraph, ge::onnx::GraphP // 7. Construct all operator and input output tensor relation. ret = ParseAllNodeProto(onnx_graph, graph); if (ret != SUCCESS) { - GELOGE(ret, "Parse all node proto failed."); + GELOGE(ret, "[Parse][AllNodeProto] failed."); return ret; } @@ -888,7 +905,7 @@ Status OnnxModelParser::ModelParseToGraphImpl(bool is_subgraph, ge::onnx::GraphP // 8. Set all operator input. ret = SetOperatorInputs(); if (ret != SUCCESS) { - GELOGE(ret, "Set operator input failed."); + GELOGE(ret, "[Set][OperatorInputs] failed."); return ret; } @@ -896,7 +913,7 @@ Status OnnxModelParser::ModelParseToGraphImpl(bool is_subgraph, ge::onnx::GraphP std::vector input_ops; ret = GetGraphInputs(onnx_graph, input_ops); if (ret != SUCCESS) { - GELOGE(ret, "Get graph inputs failed."); + GELOGE(ret, "[Get][GraphInputs] failed."); return ret; } graph.SetInputs(input_ops); @@ -906,7 +923,7 @@ Status OnnxModelParser::ModelParseToGraphImpl(bool is_subgraph, ge::onnx::GraphP std::vector>> output_ops; ret = GetGraphOutputs(output_ops); if (ret != SUCCESS) { - GELOGE(ret, "[Get][Outputs]Get graph outputs failed."); + GELOGE(ret, "[Get][Outputs] failed."); return ret; } graph.SetOutputs(output_ops); @@ -923,12 +940,12 @@ Status OnnxModelParser::Parse(const char *file, ge::Graph &graph) { ge::onnx::ModelProto onnx_model; Status ret = GetModelFromFile(file, onnx_model); if (ret != SUCCESS) { - GELOGE(FAILED, "get model from file failed."); + GELOGE(FAILED, "[Get][Model] From File:%s failed.", file); return FAILED; } ret = ModelParseToGraph(onnx_model, graph); if (ret != SUCCESS) { - GELOGE(FAILED, "parse model failed."); + GELOGE(FAILED, "[Parse][Model] To Graph failed."); return FAILED; } return SUCCESS; @@ -939,12 +956,12 @@ Status OnnxModelParser::ParseFromMemory(const char *data, uint32_t size, ge::Gra ge::onnx::ModelProto onnx_model; Status ret = GetModelFromMemory(data, size, onnx_model); if (ret != SUCCESS) { - GELOGE(FAILED, "get model from file failed."); + GELOGE(FAILED, "[Get][Model] From Memory failed."); return FAILED; } ret = ModelParseToGraph(onnx_model, graph); if (ret != SUCCESS) { - GELOGE(FAILED, "parse model failed."); + GELOGE(FAILED, "[Parse][Model] To Graph failed."); return FAILED; } return SUCCESS; @@ -952,17 +969,19 @@ Status OnnxModelParser::ParseFromMemory(const char *data, uint32_t size, ge::Gra Status OnnxModelParser::ToJson(const char *model_file, const char *json_file) { if (model_file == nullptr) { - GELOGE(FAILED, "Model file is nullptr."); + REPORT_INNER_ERROR("E19999", "param model file is nullprt, check invalid."); + GELOGE(FAILED, "[Check][Param] Model file is nullptr."); return FAILED; } if (json_file == nullptr) { - GELOGE(FAILED, "Json file is nullptr."); + REPORT_INNER_ERROR("E19999", "param json file is nullptr, check invalid."); + GELOGE(FAILED, "[Check][Param]Json file is nullptr."); return FAILED; } ge::onnx::ModelProto onnx_model; GE_RETURN_WITH_LOG_IF_FALSE(ge::parser::ReadProtoFromBinaryFile(model_file, &onnx_model), - "ReadProtoFromBinaryFile failed, file:%s.", model_file); + "[Invoke][ReadProtoFromBinaryFile] failed, file:%s.", model_file); ge::onnx::GraphProto graph_proto = onnx_model.graph(); nlohmann::json j; ge::Pb2Json::Message2Json(graph_proto, std::set(), j, true);