diff --git a/parser/common/acl_graph_parser_util.cc b/parser/common/acl_graph_parser_util.cc index 2ff22dd..e5e3e48 100644 --- a/parser/common/acl_graph_parser_util.cc +++ b/parser/common/acl_graph_parser_util.cc @@ -47,47 +47,13 @@ using google::protobuf::io::ZeroCopyInputStream; using namespace ge::parser; namespace { -static std::map kInputFormatStrToGeformat = { - {"ND", domi::DOMI_TENSOR_ND}, {"NCHW", domi::DOMI_TENSOR_NCHW}, {"NHWC", domi::DOMI_TENSOR_NHWC}, - {"CHWN", domi::DOMI_TENSOR_CHWN}, {"NC1HWC0", domi::DOMI_TENSOR_NC1HWC0}, {"NHWC1C0", domi::DOMI_TENSOR_NHWC1C0}, - {"NCDHW", domi::DOMI_TENSOR_NCDHW}, {"NDHWC", domi::DOMI_TENSOR_NDHWC}}; - -// datatype/formats from user to GE, Unified to util interface file later -const std::map kOutputTypeSupportDatatype = { - {"FP32", ge::DT_FLOAT}, {"FP16", ge::DT_FLOAT16}, {"UINT8", ge::DT_UINT8}}; -const char *const kOutputTypeSupport = "only support FP32, FP16, UINT8"; -const char *const kInputShapeSample1 = "\"input_name1:n1,c1,h1,w1\""; -const char *const kInputShapeSample2 = "\"input_name1:1,3,224,224\""; -const char *const kSplitError1 = "size not equal to 2 split by \":\""; -const char *const kEmptyError = "can not be empty"; -const char *const kFloatNumError = "exist float number"; -const char *const kDigitError = "is not digit"; const std::string kGraphDefaultName = "domi_default"; -const char *const kOutputTypeSample = "correct sample is \"opname:index:dtype\""; -const char *const kOutputTypeError = "The multiple out nodes set in output_type must be found in out_nodes."; -static std::set kCaffeSupportInputFormatSet = {"NCHW", "ND"}; -static std::set kTfSupportInputFormatSet = {"NCHW", "NHWC", "ND", "NCDHW", "NDHWC"}; -const char *const kCaffeFormatSupport = "only support NCHW, ND in Caffe model"; -const char *const kTFFormatSupport = "only support NCHW, NHWC, ND, NCDHW, NDHWC in TF model"; /// The maximum length of the file. /// Based on the security coding specification and the current actual (protobuf) model size, it is determined as 2G-1 const int kMaxFileSizeLimit = INT_MAX; const int kMaxBuffSize = 256; const int kProtoReadBytesLimit = INT_MAX; // Max size of 2 GB minus 1 byte. const int kWarningThreshold = 536870912 * 2; // 536870912 represent 512M -const int kOutputTypeNode = 0; -const int kOutputTypeIndex = 1; -const int kOutputTypeDataType = 2; - -vector SplitInputShape(const std::string &input_shape) { - vector shape_pair_vec; - size_t pos = input_shape.rfind(":"); - if (pos != std::string::npos) { - shape_pair_vec.emplace_back(input_shape.substr(0, pos)); - shape_pair_vec.emplace_back(input_shape.substr(pos + 1, input_shape.size() - pos)); - } - return shape_pair_vec; -} static string GetSoPath() { Dl_info dl_info; @@ -166,51 +132,6 @@ static bool CheckDigitStr(std::string &str) { } return true; } - -// Remove the space and tab before and after the string -std::string TrimConf(const std::string &str) { - if (str.empty()) { - return str; - } - - std::string::size_type start = str.find_first_not_of(" \t\r\n"); - if (start == std::string::npos) { - return str; - } - - std::string::size_type end = str.find_last_not_of(" \t\r\n") + 1; - return str.substr(start, end); -} - -// Parsing the command line -bool ParseSingleLine(const std::string &line, std::map &op_conf_map) { - std::string temp = TrimConf(line); - std::string delimiter = ":"; - // Comment or newline returns true directly - if (temp.find_first_of('#') == 0 || *(temp.c_str()) == '\n') { - return true; - } - - if (!temp.empty()) { - std::string::size_type pos = temp.find_first_of(delimiter); - if (pos == std::string::npos) { - GELOGE(ge::PARAM_INVALID, "Incorrect line [%s], it must include [%s].Perhaps you use illegal chinese symbol", - line.c_str(), delimiter.c_str()); - return false; - } - - std::string map_key = TrimConf(temp.substr(0, pos)); - std::string value = TrimConf(temp.substr(pos + 1)); - if (map_key.empty() || value.empty()) { - GELOGE(ge::PARAM_INVALID, "Map_key or value empty. %s", line.c_str()); - return false; - } - - op_conf_map[map_key] = value; - } - return true; -} - } // namespace namespace ge { @@ -224,38 +145,6 @@ static bool CheckInputTrueOrFalse(const std::string &s, const std::string &atc_p } } -static domi::Status CheckOutPutDataTypeSupport(const std::string &output_type) { - auto it = kOutputTypeSupportDatatype.find(output_type); - if (it == kOutputTypeSupportDatatype.end()) { - ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, - {"output_type", output_type, kOutputTypeSupport}); - GELOGE(PARAM_INVALID, "Invalid value for output_type[%s], %s.", output_type.c_str(), kOutputTypeSupport); - return domi::PARAM_INVALID; - } - return domi::SUCCESS; -} - -static domi::Status StringToInt(std::string &str, int32_t &value) { - try { - if (!CheckDigitStr(str)) { - GELOGE(PARAM_INVALID, "Invalid of digit string: %s ", str.c_str()); - ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, - {"output_type", str, "is not positive integer"}); - return PARAM_INVALID; - } - value = stoi(str); - } catch (std::invalid_argument &) { - GELOGE(PARAM_INVALID, "Invalid of digit string: %s, catch invalid_argument.", str.c_str()); - ErrorManager::GetInstance().ATCReportErrMessage("E10014", {"parameter", "value"}, {"output_type", str}); - return PARAM_INVALID; - } catch (std::out_of_range &) { - GELOGE(PARAM_INVALID, "Invalid of digit string: %s, catch out_of_range.", str.c_str()); - ErrorManager::GetInstance().ATCReportErrMessage("E10013", {"parameter", "value"}, {"output_type", str}); - return PARAM_INVALID; - } - return SUCCESS; -} - static Status CheckOutNode(ge::OpDescPtr op_desc, int32_t index) { int32_t out_size = op_desc->GetOutputsSize(); if (index < 0 || index >= out_size) { @@ -272,25 +161,6 @@ static Status CheckOutNode(ge::OpDescPtr op_desc, int32_t index) { return domi::SUCCESS; } -domi::Status VerifyOutputTypeAndOutNodes(std::vector &out_type_vec) { - std::vector> user_out_nodes = ge::GetParserContext().user_out_nodes; - std::set out_nodes_info; - for (uint32_t i = 0; i < user_out_nodes.size(); ++i) { - // out_nodes set should include output_type and output_format - std::string tmp = user_out_nodes[i].first + ":" + to_string(user_out_nodes[i].second); - out_nodes_info.emplace(tmp); - } - for (uint32_t i = 0; i < out_type_vec.size(); ++i) { - if (out_nodes_info.find(out_type_vec[i]) == out_nodes_info.end()) { - ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, - {"output_type", out_type_vec[i], kOutputTypeError}); - GELOGE(domi::FAILED, "Invalid value for output_type[%s], %s.", out_type_vec[i].c_str(), kOutputTypeError); - return domi::FAILED; - } - } - return domi::SUCCESS; -} - domi::Status AclGrphParseUtil::LoadOpsProtoLib() { string opsproto_path; GetOpsProtoPath(opsproto_path); @@ -367,148 +237,12 @@ domi::Status AclGrphParseUtil::AclParserInitialize(const std::mapsecond; - } else { - GELOGE(PARAM_INVALID, "Input format %s not support , expect ND/NCHW/NHWC/CHWN/NC1HWC0/NHWC1C0.", - input_format.c_str()); - return PARAM_INVALID; - } - } - return SUCCESS; -} - -bool AclGrphParseUtil::ParseInputShape(const string &input_shape, - std::unordered_map> &shape_map, - vector>> &user_shape_map) { - vector shape_vec = StringUtils::Split(input_shape, ';'); - const int DEFAULT_SHAPE_PAIR_SIZE = 2; - for (const auto &shape : shape_vec) { - vector shape_pair_vec = SplitInputShape(shape); - if (shape_pair_vec.size() != DEFAULT_SHAPE_PAIR_SIZE) { - ErrorManager::GetInstance().ATCReportErrMessage("E10002", {"shape", "reason", "sample"}, - {shape, kSplitError1, kInputShapeSample1}); - GELOGW("Parse input parameter [input_shape]'s shape[%s] failed, reason: %s, correct sample is %s.", shape.c_str(), - kSplitError1, kInputShapeSample1); - return false; - } - if (shape_pair_vec[1].empty()) { - ErrorManager::GetInstance().ATCReportErrMessage("E10002", {"shape", "reason", "sample"}, - {shape, kEmptyError, kInputShapeSample1}); - GELOGW("Parse input parameter [input_shape]'s shape[%s] failed, reason: %s, correct sample is %s.", shape.c_str(), - kEmptyError, kInputShapeSample1); - return false; - } - - vector shape_value_strs = StringUtils::Split(shape_pair_vec[1], ','); - vector shape_values; - for (auto &shape_value_str : shape_value_strs) { - // stoul: The method may throw an exception: invalid_argument/out_of_range - if (std::string::npos != shape_value_str.find('.')) { - ErrorManager::GetInstance().ATCReportErrMessage("E10002", {"shape", "reason", "sample"}, - {shape, kFloatNumError, kInputShapeSample2}); - GELOGW("Parse input parameter [input_shape]'s shape[%s] failed, reason: %s, correct sample is %s.", - shape.c_str(), kFloatNumError, kInputShapeSample2); - return false; - } - - long left_result = 0; - try { - left_result = stol(StringUtils::Trim(shape_value_str)); - if (!shape_value_str.empty() && (shape_value_str.front() == '-')) { - // The value maybe dynamic shape [-1], need substr it and verify isdigit. - shape_value_str = shape_value_str.substr(1); - } - for (char c : shape_value_str) { - if (!isdigit(c)) { - ErrorManager::GetInstance().ATCReportErrMessage("E10002", {"shape", "reason", "sample"}, - {shape, kDigitError, kInputShapeSample2}); - GELOGE(PARAM_INVALID, "input_shape's shape value[%s] is not digit", shape_value_str.c_str()); - return false; - } - } - } catch (const std::out_of_range &) { - ErrorManager::GetInstance().ATCReportErrMessage("E10013", {"parameter", "value"}, - {"input_shape", shape_value_str}); - GELOGW("Input parameter[input_shape]’s value[%s] cause out of range execption!", shape_value_str.c_str()); - return false; - } catch (const std::invalid_argument &) { - ErrorManager::GetInstance().ATCReportErrMessage("E10014", {"parameter", "value"}, - {"input_shape", shape_value_str}); - GELOGW("Input parameter[input_shape]’s value[%s] cause invalid argument!", shape_value_str.c_str()); - return false; - } catch (...) { - ErrorManager::GetInstance().ATCReportErrMessage("E10015", {"parameter", "value"}, - {"input_shape", shape_value_str}); - GELOGW("Input parameter[input_shape]’s value[%s] cause unkown execption!", shape_value_str.c_str()); - return false; - } - int64_t result = left_result; - shape_values.push_back(result); - } - - shape_map.emplace(make_pair(StringUtils::Trim(shape_pair_vec[0]), shape_values)); - user_shape_map.push_back(make_pair(StringUtils::Trim(shape_pair_vec[0]), shape_values)); - } - - return true; -} - -// Parse user input shape info -domi::Status AclGrphParseUtil::ParseAclShape(const string &input_shape) { - ge::GetParserContext().input_dims.clear(); - ge::GetParserContext().user_input_dims.clear(); - - if (input_shape.empty()) { - return SUCCESS; - } - - std::unordered_map> &shape_map = ge::GetParserContext().input_dims; - if (!ParseInputShape(input_shape, ge::GetParserContext().input_dims, ge::GetParserContext().user_input_dims) || - shape_map.empty()) { - GELOGE(PARAM_INVALID, "Failed to parse input shape: %s", input_shape.c_str()); - return PARAM_INVALID; +void AclGrphParseUtil::SetDefaultFormat() { + if (ge::GetParserContext().type == domi::TENSORFLOW) { + ge::GetParserContext().format = "NHWC"; + } else { + ge::GetParserContext().format = "NCHW"; } - return SUCCESS; } domi::Status AclGrphParseUtil::ParseAclOutputNodes(const string &out_nodes) { @@ -600,41 +334,6 @@ domi::Status AclGrphParseUtil::ParseAclOutputFp16NodesFormat(const string &is_ou return SUCCESS; } -domi::Status AclGrphParseUtil::ParseAclOpConf(const std::string &op_conf) { - if (op_conf.empty()) { - return SUCCESS; - } - // Normalize the path - string resolved_file_path = ge::parser::RealPath(op_conf.c_str()); - if (resolved_file_path.empty()) { - ErrorManager::GetInstance().ATCReportErrMessage("E10016", {"parameter", "opname"}, {"op_map_conf", op_conf}); - GELOGE(domi::FAILED, "Invalid input file path [%s], make sure that the file path is correct.", op_conf.c_str()); - return FAILED; - } - std::ifstream fs(resolved_file_path, std::ifstream::in); - - if (!fs.is_open()) { - GELOGE(PARAM_INVALID, "Open %s failed.", op_conf.c_str()); - return FAILED; - } - - std::string line; - - while (getline(fs, line)) { // line not with \n - if (!ParseSingleLine(line, ge::GetParserContext().op_conf_map)) { - ErrorManager::GetInstance().ATCReportErrMessage("E10016", {"parameter", "opname"}, - {"op_map_conf_line_info", line}); - GELOGE(PARAM_INVALID, "Parse line failed. content is [%s].", line.c_str()); - fs.close(); - return FAILED; - } - } - fs.close(); // close the file - - GELOGI("LoadFileContent success."); - return SUCCESS; -} - domi::Status AclGrphParseUtil::ParseAclEnableScope(const string &enable_scope_fusion_passes) { ge::GetParserContext().enable_scope_fusion_passes.clear(); if (enable_scope_fusion_passes.empty()) { @@ -746,54 +445,6 @@ domi::Status AclGrphParseUtil::ParseAclWeightCompressConf(const ComputeGraphPtr return SUCCESS; } -domi::Status AclGrphParseUtil::ParseAclOutputType(const std::string &output_type, - std::map> &output_node_dt_map) { - if (output_type.find(':') == std::string::npos) { - GELOGI("output_type is not multiple nodes, means all out nodes"); - return CheckOutPutDataTypeSupport(output_type); - } - std::vector out_type_vec; - vector nodes_v = StringUtils::Split(output_type, ';'); - for (const string &node : nodes_v) { - vector node_index_type_v = StringUtils::Split(node, ':'); - if (node_index_type_v.size() != 3) { // The size must be 3. - ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, - {"output_type", node, kOutputTypeSample}); - GELOGE(PARAM_INVALID, "Invalid value for output_type[%s], %s.", node.c_str(), kOutputTypeSample); - return domi::FAILED; - } - ge::DataType tmp_dt; - std::string node_name = StringUtils::Trim(node_index_type_v[kOutputTypeNode]); - std::string index_str = StringUtils::Trim(node_index_type_v[kOutputTypeIndex]); - int32_t index; - if (StringToInt(index_str, index) != SUCCESS) { - GELOGE(PARAM_INVALID, "This str must be digit string, while the actual input is %s.", index_str.c_str()); - return domi::FAILED; - } - std::string dt_value = StringUtils::Trim(node_index_type_v[kOutputTypeDataType]); - auto it = kOutputTypeSupportDatatype.find(dt_value); - if (it == kOutputTypeSupportDatatype.end()) { - ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, - {"output_type", dt_value, kOutputTypeSupport}); - GELOGE(ge::PARAM_INVALID, "Invalid value for output_type[%s], %s.", dt_value.c_str(), kOutputTypeSupport); - return domi::FAILED; - } else { - tmp_dt = it->second; - } - out_type_vec.push_back(node_name + ":" + index_str); - std::string index_dt_str = index_str + ":" + TypeUtils::DataTypeToSerialString(tmp_dt); - auto it1 = output_node_dt_map.find(node_name); - if (it1 == output_node_dt_map.end()) { - vector tmp_vec; - tmp_vec.push_back(index_dt_str); - output_node_dt_map.emplace(node_name, tmp_vec); - } else { - it1->second.push_back(index_dt_str); - } - } - return VerifyOutputTypeAndOutNodes(out_type_vec); -} - void AclGrphParseUtil::GetOutputNodesNameAndIndex(std::vector> &output_nodes_info, std::vector &output_nodes_name) { output_nodes_name.clear(); @@ -880,20 +531,10 @@ domi::Status AclGrphParseUtil::SetOutputNodeInfo(ge::Graph &graph, ge::ComputeGraphPtr compute_graph = ge::GraphUtils::GetComputeGraph(graph); GE_CHECK_NOTNULL(compute_graph); - string output_type; - GetAclParams(parser_params, ge::ir_option::OUTPUT_TYPE, output_type); - std::vector> user_out_nodes = ge::GetParserContext().user_out_nodes; std::vector output_formats = ge::GetParserContext().output_formats; std::vector> output_nodes_info; std::vector output_nodes_name; - std::map> output_node_dt_map; - if (!output_type.empty()) { - if (ParseAclOutputType(output_type, output_node_dt_map) != SUCCESS) { - GELOGE(domi::FAILED, "Parse output_type failed."); - return domi::FAILED; - } - } // User declared outputs for (uint32_t i = 0; i < user_out_nodes.size(); ++i) { @@ -923,11 +564,6 @@ domi::Status AclGrphParseUtil::SetOutputNodeInfo(ge::Graph &graph, (void)ge::AttrUtils::SetListStr(op_desc, "_user_defined_output_fp16_5hd", output_fp16_5hd_vec); } } - auto it = output_node_dt_map.find(user_out_nodes[i].first); - if (it != output_node_dt_map.end()) { - GELOGI("The output node [%s] need to be set output_type", user_out_nodes[i].first.c_str()); - (void)ge::AttrUtils::SetListStr(op_desc, "_user_defined_output_data_type", it->second); - } output_nodes_info.push_back(std::make_pair(out_node, user_out_nodes[i].second)); } // default output node (leaf) @@ -944,34 +580,6 @@ domi::Status AclGrphParseUtil::SetOutputNodeInfo(ge::Graph &graph, return domi::SUCCESS; } -domi::Status AclGrphParseUtil::ParseAclLogLevel(const std::string &log) { - if (log.empty()) { - return SUCCESS; - } - int ret = -1; - if (log == "default") { - ret = 0; - } else if (log == "null") { - ret = dlog_setlevel(-1, DLOG_NULL, 0); - } else if (log == "debug") { - ret = dlog_setlevel(-1, DLOG_DEBUG, 1); - } else if (log == "info") { - ret = dlog_setlevel(-1, DLOG_INFO, 1); - } else if (log == "warning") { - ret = dlog_setlevel(-1, DLOG_WARN, 1); - } else if (log == "error") { - ret = dlog_setlevel(-1, DLOG_ERROR, 1); - } else { - ErrorManager::GetInstance().ATCReportErrMessage("E10016", {"parameter", "opname"}, {"log", log}); - GELOGE(PARAM_INVALID, "Invalid value for log:%s, only support debug, info, warning, error, null", log.c_str()); - return PARAM_INVALID; - } - if (ret != 0) { - GELOGE(PARAM_INVALID, "Log setlevel fail !"); - } - return domi::SUCCESS; -} - domi::Status AclGrphParseUtil::CheckOptions(const std::map &parser_params) { for (auto &ele : parser_params) { const char *key_ascend = ele.first.GetString(); @@ -993,73 +601,13 @@ domi::Status AclGrphParseUtil::CheckOptions(const std::mapFindNode(node_name); - if (node == nullptr) { - ErrorManager::GetInstance().ATCReportErrMessage("E10016", {"parameter", "opname"}, {"input_shape", node_name}); - GELOGE(PARAM_INVALID, "Input parameter[input_shape]'s opname[%s] is not exist in model", node_name.c_str()); - return PARAM_INVALID; - } - if (node->GetType() != ge::parser::DATA) { - ErrorManager::GetInstance().ATCReportErrMessage("E10017", {"parameter", "opname"}, {"input_shape", node_name}); - GELOGE(PARAM_INVALID, "Input parameter[input_shape]'s opname[%s] is not a input opname", node_name.c_str()); - return PARAM_INVALID; - } - } - return SUCCESS; -} - -domi::Status AclGrphParseUtil::CheckAclOpNameMap(const ComputeGraphPtr &graph, const std::string &op_conf) { - GE_CHECK_NOTNULL(graph); - unordered_map graphNodeTypes; - for (const NodePtr &node : graph->GetAllNodes()) { - auto op_desc = node->GetOpDesc(); - if (op_desc == nullptr) { - GELOGE(PARAM_INVALID, "Invalid parameter for opDesc."); - return PARAM_INVALID; - } - graphNodeTypes[op_desc->GetType()] = ""; - } - std::map &propertiesMap = ge::GetParserContext().op_conf_map; - if (propertiesMap.empty()) { - ErrorManager::GetInstance().ATCReportErrMessage("E10003", {"parameter", "value", "reason"}, - {"op_name_map", op_conf, "the file content is empty"}); - GELOGE(PARAM_INVALID, "op_name_map file content is empty, please check file!"); - return PARAM_INVALID; - } - for (auto iter = propertiesMap.begin(); iter != propertiesMap.end(); iter++) { - GE_IF_BOOL_EXEC(graphNodeTypes.find(iter->second) == graphNodeTypes.end(), - ErrorManager::GetInstance().ATCReportErrMessage( - "E10003", {"parameter", "value", "reason"}, - {"op_name_map", op_conf, "type[" + iter->second + "] is not found in model"}); - GELOGE(PARAM_INVALID, "Invalid parameter for op_name_map."); return PARAM_INVALID;); - } - return SUCCESS; -} - domi::Status AclGrphParseUtil::ParseParamsBeforeGraph(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."); - // support paragrams: log, input_format, input_shape, out_nodes - // is_output_adjust_hw_layout, output, op_name_map, enable_scope_fusion_passes - string log_level; - GetAclParams(parser_params, ge::ir_option::LOG_LEVEL, log_level); - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclLogLevel(log_level) != SUCCESS, return PARAM_INVALID, - "Parse log_level failed"); - - string input_format; - GetAclParams(parser_params, ge::ir_option::INPUT_FORMAT, input_format); - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclFormat(input_format) != SUCCESS, return PARAM_INVALID, - "Parse input_format failed"); - - string input_shape; - GetAclParams(parser_params, ge::ir_option::INPUT_SHAPE, input_shape); - GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclShape(input_shape) != SUCCESS, return PARAM_INVALID, - "Parse input_shape failed"); + // 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); @@ -1071,11 +619,6 @@ domi::Status AclGrphParseUtil::ParseParamsBeforeGraph(const std::map &parser_params, std::string &graph_name); domi::Status ParseParamsAfterGraph(ge::Graph &graph, const std::map &parser_params); - domi::Status ParseOutputInfo(ge::Graph &graph, const std::map &parser_params); private: bool parser_initialized = false; @@ -53,27 +52,17 @@ class AclGrphParseUtil { domi::Status GetOutputLeaf(NodePtr node, std::vector> &output_nodes_info); void GetOutputNodesNameAndIndex(std::vector> &output_nodes_info, std::vector &output_nodes_name); - domi::Status ParseAclLogLevel(const std::string &log); - bool CheckAclInputFormat(string &input_format); - domi::Status ParseAclFormat(std::string &input_format); - bool ParseInputShape(const std::string &input_shape, std::unordered_map> &shape_map, - vector>> &user_shape_map); - domi::Status ParseAclShape(const std::string &input_shape); + void SetDefaultFormat(); domi::Status ParseAclOutputNodes(const std::string &out_nodes); domi::Status ParseAclOutputFp16NodesFormat(const std::string &is_output_fp16); - domi::Status ParseAclOpConf(const std::string &op_conf); domi::Status ParseAclEnableScope(const std::string &enable_scope_fusion_passes); static void AddAttrsForInputNodes(const vector &adjust_fp16_format_vec, const string &fp16_nodes_name, uint32_t index, OpDescPtr &op_desc); domi::Status ParseAclInputFp16Nodes(const ComputeGraphPtr &graph, const string &input_fp16_nodes, const string &is_input_adjust_hw_layout); domi::Status ParseAclWeightCompressConf(const ComputeGraphPtr &graph, const string &compress_weight_conf); - domi::Status ParseAclOutputType(const std::string &output_type, - std::map> &output_node_dt_map); domi::Status GetDefaultOutInfo(ge::ComputeGraphPtr &compute_graph, std::vector> &output_nodes_info); - domi::Status CheckAclInputShapeNode(const ComputeGraphPtr &graph); - domi::Status CheckAclOpNameMap(const ComputeGraphPtr &graph, const std::string &op_conf); }; namespace parser {