wangwei
/
parser
Not watched
1
0
Fork 0
Code
Releases 0 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 8ac6749131
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8ac6749131'
${ noResults }
parser/parser/common/acl_graph_parser_util.cc

1286 lines
56 kB
Raw Blame History 

  1. /**

  2.  * Copyright 2020 Huawei Technologies Co., Ltd

  3. 

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7. 

  8.  * http://www.apache.org/licenses/LICENSE-2.0

  9. 

  10.  * Unless required by applicable law or agreed to in writing, software

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15. */

  16. 

  17. #include "parser/common/acl_graph_parser_util.h"

  18. 

  19. #include <dlfcn.h>

  20. #include <cstdlib>

  21. #include <fstream>

  22. #include <regex.h>

  23. #include <ctime>

  24. 

  25. #include "common/string_util.h"

  26. #include "common/debug/log.h"

  27. #include "common/op/ge_op_utils.h"

  28. #include "common/properties_manager.h"

  29. #include "common/types.h"

  30. #include "common/util.h"

  31. #include "common/util/error_manager/error_manager.h"

  32. #include "ge/ge_api_types.h"

  33. #include "graph/opsproto_manager.h"

  34. #include "graph/utils/type_utils.h"

  35. #include "omg/parser/parser_inner_ctx.h"

  36. #include "tbe_plugin_loader.h"

  37. #include "framework/common/debug/ge_log.h"

  38. #include "framework/omg/parser/parser_types.h"

  39. #include "google/protobuf/io/coded_stream.h"

  40. #include "google/protobuf/io/zero_copy_stream_impl.h"

  41. #include "parser/common/register_tbe.h"

  42. 

  43. using google::protobuf::io::CodedInputStream;

  44. using google::protobuf::io::FileInputStream;

  45. using google::protobuf::io::ZeroCopyInputStream;

  46. using namespace ge::parser;

  47. 

  48. namespace {

  49. static std::map<std::string, domiTensorFormat_t> kInputFormatStrToGeformat = {

  50.     {"ND", domi::DOMI_TENSOR_ND},

  51.     {"NCHW", domi::DOMI_TENSOR_NCHW},

  52.     {"NHWC", domi::DOMI_TENSOR_NHWC},

  53.     {"CHWN", domi::DOMI_TENSOR_CHWN},

  54.     {"NC1HWC0", domi::DOMI_TENSOR_NC1HWC0},

  55.     {"NHWC1C0", domi::DOMI_TENSOR_NHWC1C0},

  56.     {"NCDHW", domi::DOMI_TENSOR_NCDHW},

  57.     {"NDHWC", domi::DOMI_TENSOR_NDHWC}

  58. };

  59. const char *const kIsOutputAdjustHwLayoutKey = "is_output_adjust_hw_layout";

  60. // datatype/formats from user to GE, Unified to util interface file later

  61. const std::map<std::string, ge::DataType> kOutputTypeSupportDatatype = {

  62.     {"FP32", ge::DT_FLOAT}, {"FP16", ge::DT_FLOAT16}, {"UINT8", ge::DT_UINT8}};

  63. const char *const kOutputTypeSupport = "only support FP32, FP16, UINT8";

  64. const char *const kInputShapeSample1 = "\"input_name1:n1,c1,h1,w1\"";

  65. const char *const kInputShapeSample2 = "\"input_name1:1,3,224,224\"";

  66. const char *const kSplitError1 = "size not equal to 2 split by \":\"";

  67. const char *const kEmptyError = "can not be empty";

  68. const char *const kFloatNumError = "exist float number";

  69. const char *const kDigitError = "is not digit";

  70. const std::string kGraphDefaultName = "domi_default";

  71. const char *const kOutputTypeSample = "correct sample is \"opname:index:dtype\"";

  72. const char *const kOutputTypeError = "The multiple out nodes set in output_type must be found in out_nodes.";

  73. static std::set<std::string> kCaffeSupportInputFormatSet = {"NCHW", "ND"};

  74. static std::set<std::string> kTfSupportInputFormatSet = {"NCHW", "NHWC", "ND", "NCDHW", "NDHWC"};

  75. static const char *const kCaffeFormatSupport = "only support NCHW, ND in Caffe model";

  76. static const char *const kTFFormatSupport = "only support NCHW, NHWC, ND, NCDHW, NDHWC in TF model";

  77. /// The maximum length of the file.

  78. /// Based on the security coding specification and the current actual (protobuf) model size, it is determined as 2G-1

  79. const int kMaxFileSizeLimit = INT_MAX;

  80. const int kMaxBuffSize = 256;

  81. const int kProtoReadBytesLimit = INT_MAX;     // Max size of 2 GB minus 1 byte.

  82. const int kWarningThreshold = 536870912 * 2;  // 536870912 represent 512M

  83. 

  84. vector<string> SplitInputShape(const std::string &input_shape) {

  85.   vector<string> shape_pair_vec;

  86.   size_t pos = input_shape.rfind(":");

  87.   if (pos != std::string::npos) {

  88.     shape_pair_vec.emplace_back(input_shape.substr(0, pos));

  89.     shape_pair_vec.emplace_back(input_shape.substr(pos + 1, input_shape.size() - pos));

  90.   }

  91.   return shape_pair_vec;

  92. }

  93. 

  94. static string GetSoPath() {

  95.   Dl_info dl_info;

  96.   if (dladdr(reinterpret_cast<void *>(&GetSoPath), &dl_info) == 0) {

  97.     GELOGW("Failed to read so_path!");

  98.     return string();

  99.   } else {

  100.     std::string so_path = dl_info.dli_fname;

  101.     char path[PATH_MAX] = {0};

  102.     if (so_path.length() >= PATH_MAX) {

  103.       GELOGW("File path is too long!");

  104.       return string();

  105.     }

  106.     if (realpath(so_path.c_str(), path) == nullptr) {

  107.       GELOGW("Failed to get realpath of %s", so_path.c_str());

  108.       return string();

  109.     }

  110. 

  111.     so_path = path;

  112.     so_path = so_path.substr(0, so_path.rfind('/') + 1);

  113.     return so_path;

  114.   }

  115. }

  116. 

  117. static void GetOpsProtoPath(string &opsproto_path) {

  118.   GELOGD("Start to get ops proto path schedule.");

  119.   const char *path_env = std::getenv("ASCEND_OPP_PATH");

  120.   if (path_env != nullptr) {

  121.     string path = path_env;

  122.     string file_path = ge::parser::RealPath(path.c_str());

  123.     if (file_path.empty()) {

  124.       GELOGE(ge::FAILED, "File path %s is invalid.", path.c_str());

  125.       return;

  126.     }

  127.     opsproto_path = (path + "/op_proto/custom/" + ":") + (path + "/op_proto/built-in/");

  128.     GELOGI("Get opsproto so path from env : %s", path.c_str());

  129.     return;

  130.   }

  131.   string path_base = GetSoPath();

  132.   GELOGI("path_base is %s", path_base.c_str());

  133.   path_base = path_base.substr(0, path_base.rfind('/'));

  134.   path_base = path_base.substr(0, path_base.rfind('/') + 1);

  135.   opsproto_path = (path_base + "ops/op_proto/custom/" + ":") + (path_base + "ops/op_proto/built-in/");

  136. }

  137. 

  138. static void GetAclParams(const std::map<string, string> &parser_params,

  139.                            const string &key, string &value) {

  140.   auto iter = parser_params.find(key);

  141.   if (iter != parser_params.end()) {

  142.     value = iter->second;

  143.   } else {

  144.     value = "";

  145.   }

  146. }

  147. 

  148. static bool CheckDigitStr(std::string &str) {

  149.   for (char c : str) {

  150.     if (!isdigit(c)) {

  151.       GELOGE(domi::FAILED, "value[%s] is not positive integer", str.c_str());

  152.       return false;

  153.     }

  154.   }

  155.   return true;

  156. }

  157. 

  158. // Remove the space and tab before and after the string

  159. std::string TrimConf(const std::string &str) {

  160.   if (str.empty()) {

  161.     return str;

  162.   }

  163. 

  164.   std::string::size_type start = str.find_first_not_of(" \t\r\n");

  165.   if (start == std::string::npos) {

  166.     return str;

  167.   }

  168. 

  169.   std::string::size_type end = str.find_last_not_of(" \t\r\n") + 1;

  170.   return str.substr(start, end);

  171. }

  172. 

  173. // Parsing the command line

  174. bool ParseSingleLine(const std::string &line, std::map<std::string, std::string> &op_conf_map) {

  175.   std::string temp = TrimConf(line);

  176.   std::string delimiter = ":";

  177.   // Comment or newline returns true directly

  178.   if (temp.find_first_of('#') == 0 || *(temp.c_str()) == '\n') {

  179.     return true;

  180.   }

  181. 

  182.   if (!temp.empty()) {

  183.     std::string::size_type pos = temp.find_first_of(delimiter);

  184.     if (pos == std::string::npos) {

  185.       GELOGE(ge::PARAM_INVALID, "Incorrect line [%s], it must include [%s].Perhaps you use illegal chinese symbol",

  186.              line.c_str(), delimiter.c_str());

  187.       return false;

  188.     }

  189. 

  190.     std::string map_key = TrimConf(temp.substr(0, pos));

  191.     std::string value = TrimConf(temp.substr(pos + 1));

  192.     if (map_key.empty() || value.empty()) {

  193.       GELOGE(ge::PARAM_INVALID, "Map_key or value empty. %s", line.c_str());

  194.       return false;

  195.     }

  196. 

  197.     op_conf_map[map_key] = value;

  198.   }

  199.   return true;

  200. }

  201. 

  202. }  // namespace

  203. 

  204. namespace ge {

  205. static bool CheckInputTrueOrFalse(const std::string &s, const std::string &atc_param) {

  206.   if ((s == "true") || (s == "false")) {

  207.     return true;

  208.   } else {

  209.     ErrorManager::GetInstance().ATCReportErrMessage("E10005", {"parameter", "value"}, {atc_param, s});

  210.     GELOGE(PARAM_INVALID, "Input parameter[--%s]'s value[%s] must be true or false.", atc_param.c_str(), s.c_str());

  211.     return false;

  212.   }

  213. }

  214. 

  215. static domi::Status CheckOutPutDataTypeSupport(const std::string &output_type) {

  216.   auto it = kOutputTypeSupportDatatype.find(output_type);

  217.   if (it == kOutputTypeSupportDatatype.end()) {

  218.     ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},

  219.                                                     {"--output_type", output_type, kOutputTypeSupport});

  220.     GELOGE(PARAM_INVALID, "Invalid value for --output_type[%s], %s.", output_type.c_str(), kOutputTypeSupport);

  221.     return domi::PARAM_INVALID;

  222.   }

  223.   return domi::SUCCESS;

  224. }

  225. 

  226. static domi::Status StringToInt(std::string &str, int32_t &value) {

  227.   try {

  228.     if (!CheckDigitStr(str)) {

  229.       GELOGE(PARAM_INVALID, "Invalid of digit string: %s ", str.c_str());

  230.       ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},

  231.                                                       {"--output_type", str, "is not positive integer"});

  232.       return PARAM_INVALID;

  233.     }

  234.     value = stoi(str);

  235.   } catch (std::invalid_argument &) {

  236.     GELOGE(PARAM_INVALID, "Invalid of digit string: %s, catch invalid_argument.", str.c_str());

  237.     ErrorManager::GetInstance().ATCReportErrMessage("E10014", {"parameter", "value"}, {"--output_type", str});

  238.     return PARAM_INVALID;

  239.   } catch (std::out_of_range &) {

  240.     GELOGE(PARAM_INVALID, "Invalid of digit string: %s, catch out_of_range.", str.c_str());

  241.     ErrorManager::GetInstance().ATCReportErrMessage("E10013", {"parameter", "value"}, {"--output_type", str});

  242.     return PARAM_INVALID;

  243.   }

  244.   return SUCCESS;

  245. }

  246. 

  247. static Status CheckOutNode(ge::OpDescPtr op_desc, int32_t index) {

  248.   int32_t out_size = op_desc->GetOutputsSize();

  249.   if (index < 0 || index >= out_size) {

  250.     GELOGE(domi::FAILED,

  251.            "out_node [%s] output index:%d must be smaller "

  252.            "than node output size:%d and can not be negative!",

  253.            op_desc->GetName().c_str(), index, out_size);

  254.     std::string fail_reason = "output index:" + to_string(index) + " must be smaller than output size:" +

  255.                               to_string(out_size) + " and can not be negative!";

  256.     ErrorManager::GetInstance().ATCReportErrMessage("E10003", {"parameter", "value", "reason"},

  257.                                                     {"out_nodes", op_desc->GetName(), fail_reason});

  258.     return domi::FAILED;

  259.   }

  260.   return domi::SUCCESS;

  261. }

  262. 

  263. domi::Status VerifyOutputTypeAndOutNodes(std::vector<std::string> &out_type_vec) {

  264.   std::vector<std::pair<std::string, int32_t>> user_out_nodes = ge::GetParserContext().user_out_nodes;

  265.   std::set<std::string> out_nodes_info;

  266.   for (uint32_t i = 0; i < user_out_nodes.size(); ++i) {

  267.     // out_nodes set should include output_type and output_format

  268.     std::string tmp = user_out_nodes[i].first + ":" + to_string(user_out_nodes[i].second);

  269.     out_nodes_info.emplace(tmp);

  270.   }

  271.   for (uint32_t i = 0; i < out_type_vec.size(); ++i) {

  272.     if (out_nodes_info.find(out_type_vec[i]) == out_nodes_info.end()) {

  273.       ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},

  274.                                                       {"--output_type", out_type_vec[i], kOutputTypeError});

  275.       GELOGE(domi::FAILED, "Invalid value for --output_type[%s], %s.", out_type_vec[i].c_str(), kOutputTypeError);

  276.       return domi::FAILED;

  277.     }

  278.   }

  279.   return domi::SUCCESS;

  280. }

  281. 

  282. domi::Status AclGrphParseUtil::LoadOpsProtoLib() {

  283.   string opsproto_path;

  284.   GetOpsProtoPath(opsproto_path);

  285.   GELOGI("Get opsproto path is %s", opsproto_path.c_str());

  286.   OpsProtoManager *manager = OpsProtoManager::Instance();

  287.   map<string, string> option_tmp;

  288.   option_tmp.emplace(std::pair<string, string>(string("ge.opsProtoLibPath"), opsproto_path));

  289.   bool is_proto_init = manager->Initialize(option_tmp);

  290.   if (!is_proto_init) {

  291.     GELOGE(FAILED, "Load ops_proto lib failed, ops proto path is invalid.");

  292.     return FAILED;

  293.   }

  294.   return SUCCESS;

  295. }

  296. 

  297. void AclGrphParseUtil::SaveCustomCaffeProtoPath() {

  298.   GELOGD("Enter save custom caffe proto path.");

  299.   std::string path_base = GetSoPath();

  300.   path_base = path_base.substr(0, path_base.rfind('/'));

  301.   path_base = path_base.substr(0, path_base.rfind('/') + 1);

  302.   ge::GetParserContext().caffe_proto_path = path_base + "include/proto/";

  303. 

  304.   string custom_op_path;

  305.   const char *path_env = std::getenv("ASCEND_OPP_PATH");

  306.   if (path_env != nullptr) {

  307.     std::string path = path_env;

  308.     custom_op_path = path + "/framework/custom/caffe/";

  309.     GELOGI("Get custom proto path from env : %s", path_env);

  310.     GetParserContext().custom_proto_path = custom_op_path;

  311.     return;

  312.   }

  313.   custom_op_path = path_base + "ops/framework/custom/caffe/";

  314.   ge::GetParserContext().custom_proto_path = custom_op_path;

  315.   return;

  316. }

  317. 

  318. // Initialize PARSER, load custom op plugin

  319. // options will be used later for parser decoupling

  320. domi::Status AclGrphParseUtil::AclParserInitialize(const std::map<std::string, std::string> &options) {

  321.   GELOGT(TRACE_INIT, "AclParserInitialize start");

  322.   // check init status

  323.   if (parser_initialized) {

  324.     GELOGW("AclParserInitialize is called more than once");

  325.     return SUCCESS;

  326.   }

  327. 

  328.   // load custom op plugin

  329.   TBEPluginLoader::Instance().LoadPluginSo(options);

  330. 

  331.   // load and save custom op proto for prediction

  332.   (void)LoadOpsProtoLib();

  333.   SaveCustomCaffeProtoPath();

  334. 

  335.   auto op_registry = domi::OpRegistry::Instance();

  336.   if (op_registry == nullptr) {

  337.     GELOGE(FAILED, "Get OpRegistry instance failed");

  338.     return FAILED;

  339.   }

  340. 

  341.   std::vector<OpRegistrationData> registrationDatas = op_registry->registrationDatas;

  342.   GELOGI("The size of registrationDatas in parser is: %zu", registrationDatas.size());

  343.   for (OpRegistrationData &reg_data : registrationDatas) {

  344.     (void)OpRegistrationTbe::Instance()->Finalize(reg_data, false);

  345.     domi::OpRegistry::Instance()->Register(reg_data);

  346.   }

  347. 

  348.   // set init status

  349.   if (!parser_initialized) {

  350.     // Initialize success, first time calling initialize

  351.     parser_initialized = true;

  352.   }

  353. 

  354.   GELOGT(TRACE_STOP, "AclParserInitialize finished");

  355.   return SUCCESS;

  356. }

  357. 

  358. bool AclGrphParseUtil::CheckAclInputFormat(string &input_format) {

  359.   if (input_format.empty()) {

  360.     // Set default format

  361.     if (ge::GetParserContext().type == domi::TENSORFLOW) {

  362.       input_format = "NHWC";

  363.     } else {

  364.       input_format = "NCHW";

  365.     }

  366.     return true;

  367.   } else if (ge::GetParserContext().type == domi::CAFFE) { // caffe

  368.     if (kCaffeSupportInputFormatSet.find(input_format) != kCaffeSupportInputFormatSet.end()) {

  369.       return true;

  370.     }

  371.     // only support NCHW ND

  372.     ErrorManager::GetInstance().ATCReportErrMessage(

  373.         "E10001", {"parameter", "value", "reason"}, {"--input_format", input_format, kCaffeFormatSupport});

  374.     GELOGE(ge::FAILED,

  375.         "Invalid value for --input_format[%s], %s.", input_format.c_str(), kCaffeFormatSupport);

  376.     return false;

  377.   } else if (ge::GetParserContext().type ==domi::TENSORFLOW) { // tf

  378.     if (kTfSupportInputFormatSet.find(input_format) != kTfSupportInputFormatSet.end()) {

  379.       return true;

  380.     }

  381.     // only support NCHW NHWC ND NCDHW NDHWC

  382.     ErrorManager::GetInstance().ATCReportErrMessage(

  383.         "E10001", {"parameter", "value", "reason"}, {"--input_format", input_format, kTFFormatSupport});

  384.     GELOGE(ge::FAILED,

  385.         "Invalid value for --input_format[%s], %s.", input_format.c_str(), kTFFormatSupport);

  386.     return false;

  387.   }

  388.   return true;

  389. }

  390. 

  391. domi::Status AclGrphParseUtil::ParseAclFormat(string &input_format) {

  392.   ge::GetParserContext().format = domi::DOMI_TENSOR_ND;

  393.   if (!CheckAclInputFormat(input_format)) {

  394.     GELOGE(PARAM_INVALID, "Check input_format failed");

  395.     return PARAM_INVALID;

  396.   }

  397.   if (!input_format.empty()) {

  398.     auto iter = kInputFormatStrToGeformat.find(input_format);

  399.     if (iter != kInputFormatStrToGeformat.end()) {

  400.       ge::GetParserContext().format = iter->second;

  401.     } else {

  402.       GELOGE(PARAM_INVALID, "Input format %s not support , expect ND/NCHW/NHWC/CHWN/NC1HWC0/NHWC1C0.",

  403.              input_format.c_str());

  404.       return PARAM_INVALID;

  405.     }

  406.   }

  407.   return SUCCESS;

  408. }

  409. 

  410. bool AclGrphParseUtil::ParseInputShape(const string &input_shape,

  411.                                        std::unordered_map<string, vector<int64_t>> &shape_map,

  412.                                        vector<pair<string, vector<int64_t>>> &user_shape_map,

  413.                                        bool is_dynamic_input) {

  414.   vector<string> shape_vec = StringUtils::Split(input_shape, ';');

  415.   const int DEFAULT_SHAPE_PAIR_SIZE = 2;

  416.   for (const auto &shape : shape_vec) {

  417.     vector<string> shape_pair_vec = SplitInputShape(shape);

  418.     if (shape_pair_vec.size() != DEFAULT_SHAPE_PAIR_SIZE) {

  419.       ErrorManager::GetInstance().ATCReportErrMessage("E10002", {"shape", "reason", "sample"},

  420.                                                       {shape, kSplitError1, kInputShapeSample1});

  421.       GELOGW("Parse input parameter [--input_shape]'s shape[%s] failed, reason: %s, correct sample is %s.",

  422.              shape.c_str(), kSplitError1, kInputShapeSample1);

  423.       return false;

  424.     }

  425.     if (shape_pair_vec[1].empty()) {

  426.       ErrorManager::GetInstance().ATCReportErrMessage("E10002", {"shape", "reason", "sample"},

  427.                                                       {shape, kEmptyError, kInputShapeSample1});

  428.       GELOGW("Parse input parameter [--input_shape]'s shape[%s] failed, reason: %s, correct sample is %s.",

  429.              shape.c_str(), kEmptyError, kInputShapeSample1);

  430.       return false;

  431.     }

  432. 

  433.     vector<string> shape_value_strs = StringUtils::Split(shape_pair_vec[1], ',');

  434.     vector<int64_t> shape_values;

  435.     for (auto &shape_value_str : shape_value_strs) {

  436.       // stoul: The method may throw an exception: invalid_argument/out_of_range

  437.       if (std::string::npos != shape_value_str.find('.')) {

  438.         ErrorManager::GetInstance().ATCReportErrMessage("E10002", {"shape", "reason", "sample"},

  439.                                                         {shape, kFloatNumError, kInputShapeSample2});

  440.         GELOGW("Parse input parameter [--input_shape]'s shape[%s] failed, reason: %s, correct sample is %s.",

  441.                shape.c_str(), kFloatNumError, kInputShapeSample2);

  442.         return false;

  443.       }

  444. 

  445.       long left_result = 0;

  446.       try {

  447.         left_result = stol(StringUtils::Trim(shape_value_str));

  448.         if (!shape_value_str.empty() && (shape_value_str.front() == '-')) {

  449.           // The value maybe dynamic shape [-1], need substr it and verify isdigit.

  450.           shape_value_str = shape_value_str.substr(1);

  451.         }

  452.         for (char c : shape_value_str) {

  453.           if (!isdigit(c)) {

  454.             ErrorManager::GetInstance().ATCReportErrMessage("E10002", {"shape", "reason", "sample"},

  455.                                                             {shape, kDigitError, kInputShapeSample2});

  456.             GELOGE(PARAM_INVALID, "--input_shape's shape value[%s] is not digit", shape_value_str.c_str());

  457.             return false;

  458.           }

  459.         }

  460.       } catch (const std::out_of_range &) {

  461.         ErrorManager::GetInstance().ATCReportErrMessage("E10013", {"parameter", "value"},

  462.                                                         {"--input_shape", shape_value_str});

  463.         GELOGW("Input parameter[--input_shape]’s value[%s] cause out of range execption!", shape_value_str.c_str());

  464.         return false;

  465.       } catch (const std::invalid_argument &) {

  466.         ErrorManager::GetInstance().ATCReportErrMessage("E10014", {"parameter", "value"},

  467.                                                         {"--input_shape", shape_value_str});

  468.         GELOGW("Input parameter[--input_shape]’s value[%s] cause invalid argument!", shape_value_str.c_str());

  469.         return false;

  470.       } catch (...) {

  471.         ErrorManager::GetInstance().ATCReportErrMessage("E10015", {"parameter", "value"},

  472.                                                         {"--input_shape", shape_value_str});

  473.         GELOGW("Input parameter[--input_shape]’s value[%s] cause unkown execption!", shape_value_str.c_str());

  474.         return false;

  475.       }

  476.       int64_t result = left_result;

  477.       // - 1 is not currently supported

  478.       if (!is_dynamic_input && result <= 0) {

  479.         ErrorManager::GetInstance().ATCReportErrMessage("E10011", {"shape", "result"}, {shape, std::to_string(result)});

  480.         GELOGW(

  481.             "Input parameter[--input_shape]’s shape value[%s] is invalid, "

  482.             "expect positive integer, but value is %ld.",

  483.             shape.c_str(), result);

  484.         return false;

  485.       }

  486.       shape_values.push_back(result);

  487.     }

  488. 

  489.     shape_map.emplace(make_pair(StringUtils::Trim(shape_pair_vec[0]), shape_values));

  490.     user_shape_map.push_back(make_pair(StringUtils::Trim(shape_pair_vec[0]), shape_values));

  491.   }

  492. 

  493.   return true;

  494. }

  495. 

  496. //Parse user input shape info

  497. domi::Status AclGrphParseUtil::ParseAclShape(const string &input_shape, bool is_dynamic_input) {

  498.   ge::GetParserContext().input_dims.clear();

  499.   ge::GetParserContext().user_input_dims.clear();

  500.   ge::GetParserContext().is_dynamic_input = is_dynamic_input;

  501. 

  502.   if (input_shape.empty()) {

  503.     return SUCCESS;

  504.   }

  505. 

  506.   std::unordered_map<string, vector<int64_t>> &shape_map = ge::GetParserContext().input_dims;

  507.   if (!ParseInputShape(input_shape, ge::GetParserContext().input_dims,

  508.                        ge::GetParserContext().user_input_dims, is_dynamic_input) || shape_map.empty()) {

  509.     GELOGE(PARAM_INVALID, "Failed to parse input shape: %s", input_shape.c_str());

  510.     return PARAM_INVALID;

  511.   }

  512.   return SUCCESS;

  513. }

  514. 

  515. domi::Status AclGrphParseUtil::ParseAclOutputNodes(const string &out_nodes) {

  516.   try {

  517.     // parse output node

  518.     if (!out_nodes.empty()) {

  519.       ge::GetParserContext().out_nodes_map.clear();

  520.       ge::GetParserContext().user_out_nodes.clear();

  521.       ge::GetParserContext().user_out_nodes_top_vec.clear();

  522. 

  523.       vector<string> nodes_v = StringUtils::Split(out_nodes, ';');

  524.       for (const string &node : nodes_v) {

  525.         vector<string> key_value_v = StringUtils::Split(node, ':');

  526.         if (key_value_v.size() != 2) {  // The size must be 2.

  527.           if (key_value_v.size() == 1 && ge::GetParserContext().type == domi::CAFFE) {

  528.             ge::GetParserContext().user_out_nodes_top_vec.push_back(node);

  529.             continue;

  530.           }

  531.           ErrorManager::GetInstance().ATCReportErrMessage(

  532.               "E10001", {"parameter", "value", "reason"},

  533.               {"--out_nodes", node, "the correct format is \"node_name1:0;node_name1:1;node_name2:0\""});

  534.           GELOGE(PARAM_INVALID,

  535.                  "The input format of --out_nodes is invalid, the correct format is "

  536.                  "\"node_name1:0;node_name1:1;node_name2:0\", while the actual input is %s.",

  537.                  node.c_str());

  538.           return PARAM_INVALID;

  539.         }

  540.         if (!ge::GetParserContext().user_out_nodes_top_vec.empty()) {

  541.           ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},

  542.                                                           {"--out_nodes", out_nodes, "is not all index or top_name"});

  543.           GELOGE(PARAM_INVALID, "This out_nodes str must be all index or top_name, while the actual input is %s", out_nodes.c_str());

  544.           return PARAM_INVALID;

  545.         }

  546.         // stoi: The method may throw an exception: invalid_argument/out_of_range

  547.         if (!CheckDigitStr(key_value_v[1])) {

  548.           ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},

  549.                                                           {"--out_nodes", out_nodes, "is not positive integer"});

  550.           GELOGE(PARAM_INVALID, "This str must be digit string, while the actual input is %s", out_nodes.c_str());

  551.           return PARAM_INVALID;

  552.         }

  553. 

  554.         auto iter = ge::GetParserContext().out_nodes_map.find(key_value_v[0]);

  555.         int32_t index = stoi(StringUtils::Trim(key_value_v[1]));

  556.         GELOGD("Get output info: node[%s] and index[%ld]", key_value_v[0].c_str(), index);

  557.         if (iter != ge::GetParserContext().out_nodes_map.end()) {

  558.           iter->second.emplace_back(index);

  559.         } else {

  560.           std::vector<int32_t> index_v;

  561.           index_v.emplace_back(index);

  562.           ge::GetParserContext().out_nodes_map.emplace(key_value_v[0], index_v);

  563.         }

  564.         ge::GetParserContext().user_out_nodes.push_back(std::make_pair(key_value_v[0], index));

  565.       }

  566.     }

  567.   } catch (std::invalid_argument &) {

  568.     GELOGE(PARAM_INVALID, "Invalid of out_nodes: %s ", out_nodes.c_str());

  569.     ErrorManager::GetInstance().ATCReportErrMessage("E10014", {"parameter", "value"}, {"--out_nodes", out_nodes});

  570.     return PARAM_INVALID;

  571.   } catch (std::out_of_range &) {

  572.     GELOGE(PARAM_INVALID, "Invalid of out_nodes: %s ", out_nodes.c_str());

  573.     ErrorManager::GetInstance().ATCReportErrMessage("E10013", {"parameter", "value"}, {"--out_nodes", out_nodes});

  574.     return PARAM_INVALID;

  575.   }

  576.   return SUCCESS;

  577. }

  578. 

  579. domi::Status AclGrphParseUtil::ParseAclOutputFp16NodesFormat(const string &is_output_fp16) {

  580.   if (is_output_fp16.empty()) {

  581.     return SUCCESS;

  582.   }

  583. 

  584.   vector<domiTensorFormat_t> &output_formats = ge::GetParserContext().output_formats;

  585.   output_formats.clear();

  586.   vector<string> node_format_vec = StringUtils::Split(is_output_fp16, ',');

  587.   for (auto &is_fp16 : node_format_vec) {

  588.     StringUtils::Trim(is_fp16);

  589.     if (!CheckInputTrueOrFalse(is_fp16, "is_output_adjust_hw_layout")) {

  590.       GELOGE(PARAM_INVALID, "Invalid Param, is_output_adjust_hw_layout only support true/false: but is [%s]",

  591.              is_output_fp16.c_str());

  592.       return PARAM_INVALID;

  593.     }

  594.     if (is_fp16 == "false") {

  595.       output_formats.push_back(DOMI_TENSOR_ND);

  596.     } else if (is_fp16 == "true") {

  597.       output_formats.push_back(domi::DOMI_TENSOR_NC1HWC0);

  598.     }

  599.   }

  600.   return SUCCESS;

  601. }

  602. 

  603. domi::Status AclGrphParseUtil::ParseAclOpConf(const std::string &op_conf) {

  604.   if (op_conf.empty()) {

  605.     return SUCCESS;

  606.   }

  607.   // Normalize the path

  608.   string resolved_file_path = ge::parser::RealPath(op_conf.c_str());

  609.   if (resolved_file_path.empty()) {

  610.     GELOGE(domi::FAILED, "Invalid input file path [%s], make sure that the file path is correct.", op_conf.c_str());

  611.     return FAILED;

  612.   }

  613.   std::ifstream fs(resolved_file_path, std::ifstream::in);

  614. 

  615.   if (!fs.is_open()) {

  616.     GELOGE(PARAM_INVALID, "Open %s failed.", op_conf.c_str());

  617.     return FAILED;

  618.   }

  619. 

  620.   std::string line;

  621. 

  622.   while (getline(fs, line)) {  // line not with \n

  623.     if (!ParseSingleLine(line, ge::GetParserContext().op_conf_map)) {

  624.       GELOGE(PARAM_INVALID, "Parse line failed. content is [%s].", line.c_str());

  625.       fs.close();

  626.       return FAILED;

  627.     }

  628.   }

  629.   fs.close();  // close the file

  630. 

  631.   GELOGI("LoadFileContent success.");

  632.   return SUCCESS;

  633. }

  634. 

  635. domi::Status AclGrphParseUtil::ParseAclEnableScope(const string &enable_scope_fusion_passes) {

  636.   ge::GetParserContext().enable_scope_fusion_passes.clear();

  637.   if (enable_scope_fusion_passes.empty()) {

  638.     return SUCCESS;

  639.   }

  640.   ge::GetParserContext().enable_scope_fusion_passes = enable_scope_fusion_passes;

  641.   return SUCCESS;

  642. }

  643. 

  644. void AclGrphParseUtil::AddAttrsForInputNodes(const vector<string> &adjust_fp16_format_vec,

  645.                                                     const string &fp16_nodes_name, uint32_t index,

  646.                                                     OpDescPtr &op_desc) {

  647.   if (AttrUtils::SetStr(op_desc, ATTR_ATC_USER_DEFINE_DATATYPE, TypeUtils::DataTypeToSerialString(DT_FLOAT16))) {

  648.     if ((index < adjust_fp16_format_vec.size()) && (adjust_fp16_format_vec[index] == "true")) {

  649.       GELOGI("This node [%s] should be set NC1HWC0", fp16_nodes_name.c_str());

  650.       if (!AttrUtils::SetStr(op_desc, ATTR_ATC_USER_DEFINE_FORMAT, TypeUtils::FormatToSerialString(FORMAT_NC1HWC0))) {

  651.         GELOGW("This node [%s] set NC1HWC0 failed", fp16_nodes_name.c_str());

  652.       }

  653.     }

  654.   }

  655. }

  656. 

  657. domi::Status AclGrphParseUtil::ParseAclInputFp16Nodes(const ComputeGraphPtr &graph,

  658.                                                       const string &input_fp16_nodes,

  659.                                                       const string &is_input_adjust_hw_layout) {

  660.   GE_CHECK_NOTNULL(graph);

  661.   vector<string> adjust_fp16_format_vec;

  662.   if (!is_input_adjust_hw_layout.empty()) {

  663.     adjust_fp16_format_vec = StringUtils::Split(is_input_adjust_hw_layout, ',');

  664.     for (auto &s : adjust_fp16_format_vec) {

  665.       StringUtils::Trim(s);

  666.       if (!CheckInputTrueOrFalse(s, "is_input_adjust_hw_layout")) {

  667.         GELOGE(PARAM_INVALID, "Invalid Param, is_input_adjust_hw_layout only support true/false: but is [%s]",

  668.                is_input_adjust_hw_layout.c_str());

  669.         return PARAM_INVALID;

  670.       }

  671.     }

  672.   }

  673.   if (input_fp16_nodes.empty()) {

  674.     return SUCCESS;

  675.   }

  676.   GELOGI("The input_fp16_nodes is set %s", input_fp16_nodes.c_str());

  677.   vector<string> input_fp16_nodes_vec = StringUtils::Split(input_fp16_nodes, ';');

  678.   for (uint32_t i = 0; i < input_fp16_nodes_vec.size(); ++i) {

  679.     ge::NodePtr node = graph->FindNode(input_fp16_nodes_vec[i]);

  680.     if (node == nullptr) {

  681.       ErrorManager::GetInstance().ATCReportErrMessage("E10016", {"parameter", "opname"},

  682.                                                       {"input_fp16_nodes", input_fp16_nodes_vec[i]});

  683.       GELOGE(PARAM_INVALID, "Input parameter[--input_fp16_nodes]'s opname[%s] is not exist in model",

  684.              input_fp16_nodes_vec[i].c_str());

  685.       return PARAM_INVALID;

  686.     }

  687.     auto op_desc = node->GetOpDesc();

  688.     GE_CHECK_NOTNULL(op_desc);

  689.     if (op_desc->GetType() != ge::parser::DATA) {

  690.       ErrorManager::GetInstance().ATCReportErrMessage("E10017", {"parameter", "opname"},

  691.                                                       {"input_fp16_nodes", input_fp16_nodes_vec[i]});

  692.       GELOGE(PARAM_INVALID, "Input parameter[--input_fp16_nodes]'s opname[%s] is not a input opname",

  693.              input_fp16_nodes_vec[i].c_str());

  694.       return PARAM_INVALID;

  695.     }

  696.     AddAttrsForInputNodes(adjust_fp16_format_vec, input_fp16_nodes_vec[i], i, op_desc);

  697.   }

  698.   return SUCCESS;

  699. }

  700. 

  701. domi::Status AclGrphParseUtil::ParseAclWeightCompressConf(const ComputeGraphPtr &graph,

  702.                                                           const string &compress_weight_conf) {

  703.   GE_CHECK_NOTNULL(graph);

  704.   if (compress_weight_conf.empty()) {

  705.     return SUCCESS;

  706.   }

  707.   std::string real_path = ge::parser::RealPath(compress_weight_conf.c_str());

  708.   if (real_path.empty()) {

  709.     GELOGE(PARAM_INVALID, "Can not get real path for %s.", compress_weight_conf.c_str());

  710.     return PARAM_INVALID;

  711.   }

  712.   std::ifstream ifs(real_path);

  713.   if (!ifs.is_open()) {

  714.     GELOGE(FAILED, "Open file %s failed", compress_weight_conf.c_str());

  715.     return FAILED;

  716.   }

  717. 

  718.   std::string compress_nodes;

  719.   ifs >> compress_nodes;

  720.   ifs.close();

  721.   GELOGI("Compress weight of nodes: %s", compress_nodes.c_str());

  722. 

  723.   vector<string> compress_node_vec = StringUtils::Split(compress_nodes, ';');

  724.   for (size_t i = 0; i < compress_node_vec.size(); ++i) {

  725.     ge::NodePtr node = graph->FindNode(compress_node_vec[i]);

  726.     if (node == nullptr) {

  727.       GELOGW("node %s is not in graph", compress_node_vec[i].c_str());

  728.       continue;

  729.     }

  730.     auto op_desc = node->GetOpDesc();

  731.     GE_CHECK_NOTNULL(op_desc);

  732.     if (!ge::AttrUtils::SetBool(op_desc, ge::ATTR_NAME_COMPRESS_WEIGHT, true)) {

  733.       GELOGE(domi::FAILED, "node %s SetBool failed.", compress_node_vec[i].c_str());

  734.       return domi::FAILED;

  735.     }

  736.   }

  737.   return SUCCESS;

  738. }

  739. 

  740. domi::Status AclGrphParseUtil::ParseAclOutputType(const std::string &output_type, 

  741.                                                   std::map<std::string, vector<std::string>> &output_node_dt_map) {

  742.   if (output_type.find(':') == std::string::npos) {

  743.     GELOGI("output_type is not multiple nodes, means all out nodes");

  744.     return CheckOutPutDataTypeSupport(output_type);

  745.   }

  746.   std::vector<std::string> out_type_vec;

  747.   vector<string> nodes_v = StringUtils::Split(output_type, ';');

  748.   for (const string &node : nodes_v) {

  749.     vector<string> node_index_type_v = StringUtils::Split(node, ':');

  750.     if (node_index_type_v.size() != 3) {  // The size must be 3.

  751.       ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},

  752.                                                       {"--output_type", node, kOutputTypeSample});

  753.       GELOGE(PARAM_INVALID, "Invalid value for --output_type[%s], %s.", node.c_str(), kOutputTypeSample);

  754.       return domi::FAILED;

  755.     }

  756.     ge::DataType tmp_dt;

  757.     std::string node_name = StringUtils::Trim(node_index_type_v[0]);

  758.     std::string index_str = StringUtils::Trim(node_index_type_v[1]);

  759.     int32_t index;

  760.     if (StringToInt(index_str, index) != SUCCESS) {

  761.       GELOGE(PARAM_INVALID, "This str must be digit string, while the actual input is %s.", index_str.c_str());

  762.       return domi::FAILED;

  763.     }

  764.     std::string dt_value = StringUtils::Trim(node_index_type_v[2]);

  765.     auto it = kOutputTypeSupportDatatype.find(dt_value);

  766.     if (it == kOutputTypeSupportDatatype.end()) {

  767.       ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},

  768.                                                       {"--output_type", dt_value, kOutputTypeSupport});

  769.       GELOGE(ge::PARAM_INVALID, "Invalid value for --output_type[%s], %s.", dt_value.c_str(), kOutputTypeSupport);

  770.       return domi::FAILED;

  771.     } else {

  772.       tmp_dt = it->second;

  773.     }

  774.     out_type_vec.push_back(node_name + ":" + index_str);

  775.     std::string index_dt_str = index_str + ":" + TypeUtils::DataTypeToSerialString(tmp_dt);

  776.     auto it1 = output_node_dt_map.find(node_name);

  777.     if (it1 == output_node_dt_map.end()) {

  778.       vector<string> tmp_vec;

  779.       tmp_vec.push_back(index_dt_str);

  780.       output_node_dt_map.emplace(node_name, tmp_vec);

  781.     } else {

  782.       it1->second.push_back(index_dt_str);

  783.     }

  784.   }

  785.   return VerifyOutputTypeAndOutNodes(out_type_vec);

  786. }

  787. 

  788. void AclGrphParseUtil::GetOutputNodesNameAndIndex(std::vector<std::pair<ge::NodePtr, int32_t>> &output_nodes_info,

  789.                                                   std::vector<std::string> &output_nodes_name) {

  790.   output_nodes_name.clear();

  791.   if (ge::GetParserContext().out_top_names.empty()) {

  792.     // tf process, no top name.

  793.     for (const auto output_node_info : output_nodes_info) {

  794.       std::string node_name = output_node_info.first->GetName();

  795.       int32_t index = output_node_info.second;

  796.       output_nodes_name.push_back(node_name + ":" + std::to_string(index));

  797.     }

  798.     return;

  799.   }

  800.   // caffe process, need add top name after node_name:index

  801.   for (size_t i = 0; i < output_nodes_info.size(); ++i) {

  802.     std::string node_name = output_nodes_info[i].first->GetName();

  803.     int32_t index = output_nodes_info[i].second;

  804.     if (i < ge::GetParserContext().out_top_names.size()) {

  805.       output_nodes_name.push_back(node_name + ":" + std::to_string(index) + ":" + ge::GetParserContext().out_top_names[i]);

  806.     } else {

  807.       GELOGW("Get top name of node [%s] fail.", node_name.c_str());

  808.       output_nodes_name.push_back(node_name + ":" + std::to_string(index));

  809.     }

  810.   }

  811. }

  812. 

  813. domi::Status AclGrphParseUtil::GetOutputLeaf(NodePtr node,

  814.                                              std::vector<std::pair<ge::NodePtr, int32_t>> &output_nodes_info) {

  815.   ge::OpDescPtr tmpDescPtr = node->GetOpDesc();

  816.   if (tmpDescPtr == nullptr) {

  817.     GELOGE(domi::FAILED, "Get outnode op desc fail.");

  818.     return domi::FAILED;

  819.   }

  820.   size_t size = tmpDescPtr->GetOutputsSize();

  821.   if (node->GetType() != ge::parser::NETOUTPUT) {

  822.     for (size_t index = 0; index < size; ++index) {

  823.       output_nodes_info.push_back(std::make_pair(node, index));

  824.       GELOGD("Get output leaf node:%s.", node->GetName().c_str());

  825.     }

  826.   } else {

  827.     const auto in_anchors = node->GetAllInDataAnchors();

  828.     for (auto in_anchor : in_anchors) {

  829.       auto out_anchor = in_anchor->GetPeerOutAnchor();

  830.       if (out_anchor == nullptr) {

  831.         GELOGE(domi::FAILED, "Get leaf node op desc fail.");

  832.         return domi::FAILED;

  833.       }

  834.       auto out_node = out_anchor->GetOwnerNode();

  835.       output_nodes_info.push_back(std::make_pair(out_node, out_anchor->GetIdx()));

  836.     }

  837.   }

  838.   return SUCCESS;

  839. }

  840. 

  841. domi::Status AclGrphParseUtil::GetDefaultOutInfo(ge::ComputeGraphPtr &compute_graph,

  842.                                                  std::vector<std::pair<ge::NodePtr, int32_t>> &output_nodes_info) {

  843.   std::vector<std::pair<std::string, int32_t>> default_out_nodes = ge::GetParserContext().default_out_nodes;

  844.   if (ge::GetParserContext().type == domi::CAFFE && !default_out_nodes.empty()) {

  845.     for (uint32_t i = 0; i < default_out_nodes.size(); ++i) {

  846.       ge::NodePtr out_node = compute_graph->FindNode(default_out_nodes[i].first);

  847.       if (out_node == nullptr) {

  848.         ErrorManager::GetInstance().ATCReportErrMessage("E10016", {"parameter", "opname"},

  849.                                                         {"out_nodes", default_out_nodes[i].first});

  850.         GELOGE(domi::FAILED, "Can not find src node (%s) in graph.", default_out_nodes[i].first.c_str());

  851.         return domi::FAILED;

  852.       }

  853.       output_nodes_info.push_back(std::make_pair(out_node, default_out_nodes[i].second));

  854.       GELOGD("Get default output node:%s.", out_node->GetName().c_str());

  855.     }

  856.     return domi::SUCCESS;

  857.   }

  858. 

  859.   for (ge::NodePtr node : compute_graph->GetDirectNode()) {

  860.     if (!node->GetInAllNodes().empty() && node->GetOutAllNodes().empty()) {

  861.       Status ret = GetOutputLeaf(node, output_nodes_info);

  862.       GE_CHK_BOOL_RET_STATUS(ret == SUCCESS, ret, "find leaf fail.");

  863.     }

  864.   }

  865.   return domi::SUCCESS;

  866. }

  867. 

  868. domi::Status AclGrphParseUtil::SetOutputNodeInfo(ge::Graph &graph,

  869.                                                  const std::map<std::string, std::string> &parser_params) {

  870.   ge::ComputeGraphPtr compute_graph = ge::GraphUtils::GetComputeGraph(graph);

  871.   GE_CHECK_NOTNULL(compute_graph);

  872. 

  873.   string output_type;

  874.   GetAclParams(parser_params, "output_type", output_type);

  875. 

  876.   std::vector<std::pair<std::string, int32_t>> user_out_nodes = ge::GetParserContext().user_out_nodes;

  877.   std::vector<domiTensorFormat_t> output_formats = ge::GetParserContext().output_formats;

  878.   std::vector<std::pair<ge::NodePtr, int32_t>> output_nodes_info;

  879.   std::vector<std::string> output_nodes_name;

  880.   std::map<std::string, vector<std::string>> output_node_dt_map;

  881.   if (!output_type.empty()) {

  882.     if (ParseAclOutputType(output_type, output_node_dt_map) != SUCCESS) {

  883.       GELOGE(domi::FAILED, "Parse output_type failed.");

  884.       return domi::FAILED;

  885.     }

  886.   }

  887. 

  888.   // User declared outputs

  889.   for (uint32_t i = 0; i < user_out_nodes.size(); ++i) {

  890.     ge::NodePtr out_node = compute_graph->FindNode(user_out_nodes[i].first);

  891.     if (out_node == nullptr) {

  892.       ErrorManager::GetInstance().ATCReportErrMessage("E10016", {"parameter", "opname"},

  893.                                                       {"out_nodes", user_out_nodes[i].first});

  894.       GELOGE(domi::FAILED, "Can not find src node (%s) in graph.", user_out_nodes[i].first.c_str());

  895.       return domi::FAILED;

  896.     }

  897.     auto op_desc = out_node->GetOpDesc();

  898.     GE_CHECK_NOTNULL(op_desc);

  899.     if (CheckOutNode(op_desc, user_out_nodes[i].second) != SUCCESS) {

  900.       GELOGE(domi::FAILED, "Check out node (%s) fail.", user_out_nodes[i].first.c_str());

  901.       return domi::FAILED;

  902.     }

  903.     if (i < output_formats.size()) {

  904.       if (output_formats[i] == domi::DOMI_TENSOR_NC1HWC0) {

  905.         GELOGI("The output node [%s] should be set NC1HWC0", user_out_nodes[i].first.c_str());

  906.         vector<string> output_fp16_5hd_vec;

  907.         (void)ge::AttrUtils::GetListStr(op_desc, "_user_defined_output_fp16_5hd", output_fp16_5hd_vec);

  908.         output_fp16_5hd_vec.push_back(std::to_string(user_out_nodes[i].second) + ":" + "NC1HWC0");

  909.         (void)ge::AttrUtils::SetListStr(op_desc, "_user_defined_output_fp16_5hd", output_fp16_5hd_vec);

  910.       }

  911.     }

  912.     auto it = output_node_dt_map.find(user_out_nodes[i].first);

  913.     if (it != output_node_dt_map.end()) {

  914.       GELOGI("The output node [%s] need to be set output_type", user_out_nodes[i].first.c_str());

  915.       (void)ge::AttrUtils::SetListStr(op_desc, "_user_defined_output_data_type", it->second);

  916.     }

  917.     output_nodes_info.push_back(std::make_pair(out_node, user_out_nodes[i].second));

  918.   }

  919.   // default output node (leaf)

  920.   if (user_out_nodes.empty()) {

  921.     if (GetDefaultOutInfo(compute_graph, output_nodes_info) != SUCCESS) {

  922.       GELOGE(domi::FAILED, "Get default output info failed.");

  923.       return domi::FAILED;

  924.     }

  925.   }

  926.   GetOutputNodesNameAndIndex(output_nodes_info, output_nodes_name);

  927.   compute_graph->SetGraphOutNodesInfo(output_nodes_info);

  928.   ge::GetParserContext().net_out_nodes = output_nodes_name;

  929.   GELOGI("Set graph %s output node success.", graph.GetName().c_str());

  930.   return domi::SUCCESS;

  931. }

  932. 

  933. domi::Status AclGrphParseUtil::ParseAclLogLevel(const std::string &log) {

  934.   if (log.empty()) {

  935.     return SUCCESS;

  936.   }

  937.   int ret = -1;

  938.   if (log == "default") {

  939.     ret = 0;

  940.   } else if (log == "null") {

  941.     ret = dlog_setlevel(-1, DLOG_NULL, 0);

  942.   } else if (log == "debug") {

  943.     ret = dlog_setlevel(-1, DLOG_DEBUG, 1);

  944.   } else if (log == "info") {

  945.     ret = dlog_setlevel(-1, DLOG_INFO, 1);

  946.   } else if (log == "warning") {

  947.     ret = dlog_setlevel(-1, DLOG_WARN, 1);

  948.   } else if (log == "error") {

  949.     ret = dlog_setlevel(-1, DLOG_ERROR, 1);

  950.   } else {

  951.     GELOGE(PARAM_INVALID, "invalid value for log:%s, only support debug, info, warning, error, null", log.c_str());

  952.     return PARAM_INVALID;

  953.   }

  954.   if (ret != 0) {

  955.     GELOGE(PARAM_INVALID, "Log setlevel fail !");

  956.   }

  957.   return domi::SUCCESS;

  958. }

  959. 

  960. domi::Status AclGrphParseUtil::ParseParamsBeforeGraph(const std::map<std::string, std::string> &parser_params,

  961.                                                       string &graph_name) {

  962.   GELOGI("Parse graph user options start.");

  963.   // support paragrams: log, input_format, is_dynamic_input, input_shape, out_nodes

  964.   //                    is_output_adjust_hw_layout, output, op_name_map, enable_scope_fusion_passes

  965.   string log_level;

  966.   GetAclParams(parser_params, "log", log_level);

  967.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclLogLevel(log_level) != SUCCESS,

  968.                                  return PARAM_INVALID, "Parse log_level failed");

  969. 

  970. 

  971.   string input_format;

  972.   GetAclParams(parser_params, "input_format", input_format);

  973.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclFormat(input_format) != SUCCESS,

  974.                                  return PARAM_INVALID, "Parse input_format failed");

  975. 

  976.   string dynamic_input_str;

  977.   GetAclParams(parser_params, "is_dynamic_input", dynamic_input_str);

  978.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(!CheckInputTrueOrFalse(dynamic_input_str, "is_dynamic_input"),

  979.                                  return PARAM_INVALID, "Parse is_dynamic_input failed");

  980.   bool is_dynamic_input = dynamic_input_str == "true" ? true : false;

  981. 

  982.   string input_shape;

  983.   GetAclParams(parser_params, "input_shape", input_shape);

  984.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclShape(input_shape, is_dynamic_input) != SUCCESS,

  985.                                  return PARAM_INVALID, "Parse input_shape failed");

  986. 

  987.   string out_nodes;

  988.   GetAclParams(parser_params, "out_nodes", out_nodes);

  989.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclOutputNodes(out_nodes) != SUCCESS,

  990.                                  return PARAM_INVALID, "Parse out_nodes failed");

  991. 

  992. 

  993.   string is_output_adjust_hw_layout;

  994.   GetAclParams(parser_params, "is_output_adjust_hw_layout", is_output_adjust_hw_layout);

  995.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclOutputFp16NodesFormat(is_output_adjust_hw_layout) != SUCCESS,

  996.                                  return PARAM_INVALID, "Parse is_output_adjust_hw_layout failed");

  997. 

  998.   string op_conf_str;

  999.   GetAclParams(parser_params, "op_name_map", op_conf_str);

  1000.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclOpConf(op_conf_str) != SUCCESS,

  1001.                                  return PARAM_INVALID, "Parse op_name_map failed");

  1002. 

  1003.   string tmp_name;

  1004.   GetAclParams(parser_params, "output", tmp_name);

  1005.   graph_name = tmp_name.empty() ? (kGraphDefaultName + "_" + ge::parser::CurrentTimeInStr()) : tmp_name;

  1006. 

  1007.   string enable_scope_fusion_passes;

  1008.   GetAclParams(parser_params, "enable_scope_fusion_passes", enable_scope_fusion_passes);

  1009.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclEnableScope(enable_scope_fusion_passes) != SUCCESS,

  1010.                                  return PARAM_INVALID, "Parse enable_scope_fusion_passes failed");

  1011. 

  1012.   return SUCCESS;

  1013. }

  1014. 

  1015. domi::Status AclGrphParseUtil::ParseParamsAfterGraph(ge::Graph &graph,

  1016.                                                      const std::map<std::string, std::string> &parser_params) {

  1017.   // support paragrams: input_fp16_nodes, is_input_adjust_hw_layout, compress_weight_conf,

  1018.   ComputeGraphPtr compute_graph = GraphUtils::GetComputeGraph(graph);

  1019. 

  1020.   string input_fp16_nodes;

  1021.   GetAclParams(parser_params, "input_fp16_nodes", input_fp16_nodes);

  1022. 

  1023.   string is_input_adjust_hw_layout;

  1024.   GetAclParams(parser_params, "is_input_adjust_hw_layout", is_input_adjust_hw_layout);

  1025.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclInputFp16Nodes(compute_graph, input_fp16_nodes, is_input_adjust_hw_layout) != SUCCESS,

  1026.                                  return PARAM_INVALID, "Parse input_fp16_nodes failed");

  1027.   //GE_RETURN_IF_ERROR(CheckInputShapeNode(compute_graph, is_dynamic_input));

  1028.   string compress_weight_conf;

  1029.   GetAclParams(parser_params, "compress_weight_conf", compress_weight_conf);

  1030.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ParseAclWeightCompressConf(compute_graph, compress_weight_conf) != SUCCESS,

  1031.                                  return PARAM_INVALID, "Parse compress_weight_conf failed");

  1032.   return SUCCESS;

  1033. }

  1034. 

  1035. namespace parser {

  1036. FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY std::string RealPath(const char *path) {

  1037.   if (path == nullptr) {

  1038.     GELOGE(ge::FAILED, "path pointer is NULL.");

  1039.     return "";

  1040.   }

  1041.   if (strlen(path) >= PATH_MAX) {

  1042.     ErrorManager::GetInstance().ATCReportErrMessage("E19002", {"filepath", "size"}, {path, std::to_string(PATH_MAX)});

  1043.     GELOGE(ge::FAILED, "Path[%s] len is too long, it must be less than %d", path, PATH_MAX);

  1044.     return "";

  1045.   }

  1046.   // Nullptr is returned when the path does not exist or there is no permission

  1047.   // Return absolute path when path is accessible

  1048.   std::string res;

  1049.   char resolved_path[PATH_MAX] = {0};

  1050.   if (realpath(path, resolved_path) != nullptr) {

  1051.     res = resolved_path;

  1052.   }

  1053. 

  1054.   return res;

  1055. }

  1056. 

  1057. // Get file length

  1058. FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY long GetFileLength(const std::string &input_file) {

  1059.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(input_file.empty(), return -1, "input_file path is null.");

  1060. 

  1061.   std::string real_path = RealPath(input_file.c_str());

  1062. 

  1063.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(), return -1, "input_file path '%s' not valid", input_file.c_str());

  1064.   unsigned long long file_length = 0;

  1065.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(mmGetFileSize(input_file.c_str(), &file_length) != EN_OK,

  1066.                                  ErrorManager::GetInstance().ATCReportErrMessage("E19001", {"file", "errmsg"},

  1067.                                                                                  {input_file, strerror(errno)});

  1068.                                          return -1, "Open file[%s] failed. %s", input_file.c_str(), strerror(errno));

  1069. 

  1070.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((file_length == 0),

  1071.                                  ErrorManager::GetInstance().ATCReportErrMessage("E19015", {"filepath"}, {input_file});

  1072.                                          return -1, "File[%s] size is 0, not valid.", input_file.c_str());

  1073. 

  1074.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(file_length > kMaxFileSizeLimit,

  1075.                                  ErrorManager::GetInstance().ATCReportErrMessage(

  1076.                                          "E19016", {"filepath", "filesize", "maxlen"},

  1077.                                          {input_file, std::to_string(file_length), std::to_string(kMaxFileSizeLimit)});

  1078.                                          return -1, "File[%s] size %lld is out of limit: %d.",

  1079.                                  input_file.c_str(), file_length, kMaxFileSizeLimit);

  1080.   return static_cast<long>(file_length);

  1081. }

  1082. 

  1083. FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY uint64_t GetCurrentTimestamp() {

  1084.   struct timeval tv{};

  1085.   int ret = gettimeofday(&tv, nullptr);

  1086.   GE_LOGE_IF(ret != 0, "Func gettimeofday may failed: ret=%d", ret);

  1087.   auto total_use_time = tv.tv_usec + tv.tv_sec * 1000000;  // 1000000: seconds to microseconds

  1088.   return static_cast<uint64_t>(total_use_time);

  1089. }

  1090. 

  1091. static bool ReadProtoFromCodedInputStream(CodedInputStream &coded_stream, Message *proto) {

  1092.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(proto == nullptr,

  1093.                                  return false, "incorrect parameter. nullptr == proto");

  1094. 

  1095.   coded_stream.SetTotalBytesLimit(kProtoReadBytesLimit, kWarningThreshold);

  1096.   return proto->ParseFromCodedStream(&coded_stream);

  1097. }

  1098. 

  1099. /** @ingroup domi_common

  1100.  *  @brief Read all data from binary file

  1101.  *  @param [in] file_name  File path

  1102.  *  @param [out] buffer  The address of the output memory, which needs to be released by the caller

  1103.  *  @param [out] length  Output memory size

  1104.  *  @return false fail

  1105.  *  @return true success

  1106.  */

  1107. FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadBytesFromBinaryFile(const char *file_name, char **buffer,

  1108.                                                                               int &length) {

  1109.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((file_name == nullptr), return false, "incorrect parameter. file is nullptr");

  1110.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((buffer == nullptr), return false, "incorrect parameter. buffer is nullptr");

  1111. 

  1112.   std::string real_path = RealPath(file_name);

  1113.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(), return false, "file path '%s' not valid", file_name);

  1114. 

  1115.   std::ifstream file(real_path.c_str(), std::ios::binary | std::ios::ate);

  1116.   if (!file.is_open()) {

  1117.     GELOGE(ge::FAILED, "Read file %s failed.", file_name);

  1118.     return false;

  1119.   }

  1120. 

  1121.   length = static_cast<int>(file.tellg());

  1122. 

  1123.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((length <= 0), file.close(); return false, "file length <= 0");

  1124. 

  1125.   file.seekg(0, std::ios::beg);

  1126. 

  1127.   *buffer = new(std::nothrow) char[length]();

  1128.   GE_CHK_BOOL_TRUE_EXEC_RET_STATUS(*buffer == nullptr, false, file.close(), "new an object failed.");

  1129. 

  1130.   file.read(*buffer, length);

  1131.   file.close();

  1132.   return true;

  1133. }

  1134. 

  1135. FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromBinaryFile(const char *file, Message *proto) {

  1136.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((file == nullptr || proto == nullptr),

  1137.                                  return false,

  1138.                                  "Input parameter file or proto is nullptr!");

  1139. 

  1140.   std::string real_path = RealPath(file);

  1141.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(),

  1142.                                  return false, "pb file path '%s' not valid", file);

  1143. 

  1144.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(GetFileLength(real_path) == -1, return false, "file size not valid.");

  1145. 

  1146.   std::ifstream fs(real_path, std::ifstream::in | std::ifstream::binary);

  1147.   if (!fs.is_open()) {

  1148.     ErrorManager::GetInstance().ATCReportErrMessage("E19001", {"file", "errmsg"}, {file, "ifstream is_open failed"});

  1149.     GELOGE(ge::FAILED, "Open real path[%s] failed.", file);

  1150.     return false;

  1151.   }

  1152. 

  1153.   google::protobuf::io::IstreamInputStream istream(&fs);

  1154.   google::protobuf::io::CodedInputStream coded_stream(&istream);

  1155. 

  1156.   bool ret = ReadProtoFromCodedInputStream(coded_stream, proto);

  1157. 

  1158.   fs.close();

  1159. 

  1160.   if (!ret) {

  1161.     ErrorManager::GetInstance().ATCReportErrMessage("E19005", {"file"}, {file});

  1162.     GELOGE(ge::FAILED, "Parse file[%s] failed.", file);

  1163.     return ret;

  1164.   }

  1165. 

  1166.   return ret;

  1167. }

  1168. 

  1169. FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromArray(const void *data, int size, Message *proto) {

  1170.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((proto == nullptr || data == nullptr || size == 0), return false,

  1171.                                  "incorrect parameter. proto is nullptr || data is nullptr || size is 0");

  1172. 

  1173.   google::protobuf::io::CodedInputStream coded_stream(reinterpret_cast<uint8_t *>(const_cast<void *>(data)), size);

  1174.   return ReadProtoFromCodedInputStream(coded_stream, proto);

  1175. }

  1176. 

  1177. FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromText(const char *file,

  1178.                                                                         google::protobuf::Message *message) {

  1179.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((file == nullptr || message == nullptr), return false,

  1180.                                  "incorrect parameter. nullptr == file || nullptr == message");

  1181. 

  1182.   std::string real_path = RealPath(file);

  1183.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(),

  1184.                                  ErrorManager::GetInstance().ATCReportErrMessage("E19000", {"path", "errmsg"},

  1185.                                                                                  {file, strerror(errno)});

  1186.                                          return false, "Path[%s]'s realpath is empty, errmsg[%s]", file,

  1187.                                  strerror(errno));

  1188. 

  1189.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(GetFileLength(real_path) == -1, return false, "file size not valid.");

  1190. 

  1191.   std::ifstream fs(real_path.c_str(), std::ifstream::in);

  1192. 

  1193.   if (!fs.is_open()) {

  1194.     ErrorManager::GetInstance().ATCReportErrMessage("E19017", {"realpth", "protofile"}, {real_path, file});

  1195.     GELOGE(ge::FAILED,

  1196.            "Fail to open proto file real path is '%s' when orginal file path is '%s'.", real_path.c_str(), file);

  1197.     return false;

  1198.   }

  1199. 

  1200.   google::protobuf::io::IstreamInputStream input(&fs);

  1201.   bool ret = google::protobuf::TextFormat::Parse(&input, message);

  1202.   GE_IF_BOOL_EXEC(!ret,

  1203.                   ErrorManager::GetInstance().ATCReportErrMessage("E19018", {"protofile"}, {file});

  1204.                           GELOGE(ret, "Parse file[%s] through [google::protobuf::TextFormat::Parse] failed, "

  1205.                                       "please check whether the file is a valid protobuf format file.", file));

  1206.   fs.close();

  1207. 

  1208.   return ret;

  1209. }

  1210. 

  1211. FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromMem(const char *data, int size,

  1212.                                                                        google::protobuf::Message *message) {

  1213.   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((data == nullptr || message == nullptr), return false,

  1214.                                  "incorrect parameter. data is nullptr || message is nullptr");

  1215.   std::string str(data, static_cast<size_t>(size));

  1216.   std::istringstream fs(str);

  1217. 

  1218.   google::protobuf::io::IstreamInputStream input(&fs);

  1219.   bool ret = google::protobuf::TextFormat::Parse(&input, message);

  1220.   GE_IF_BOOL_EXEC(

  1221.           !ret, GELOGE(ret, "Call [google::protobuf::TextFormat::Parse] func ret fail, please check your text file."));

  1222. 

  1223.   return ret;

  1224. }

  1225. 

  1226. ///

  1227. /// @brief get the Original Type of FrameworkOp

  1228. /// @param [in] node

  1229. /// @param [out] type

  1230. /// @return Status

  1231. ///

  1232. Status GetOriginalType(const ge::NodePtr &node, string &type) {

  1233.   GE_CHECK_NOTNULL(node);

  1234.   type = node->GetType();

  1235.   GE_IF_BOOL_EXEC(type != FRAMEWORKOP, return SUCCESS);

  1236.   GE_CHECK_NOTNULL(node->GetOpDesc());

  1237.   bool ret = ge::AttrUtils::GetStr(node->GetOpDesc(), ATTR_NAME_FRAMEWORK_ORIGINAL_TYPE, type);

  1238.   if (!ret) {

  1239.     GELOGE(INTERNAL_ERROR, "Get FrameWorkOp original type [%s]", type.c_str());

  1240.     return INTERNAL_ERROR;

  1241.   }

  1242.   GELOGD("Get FrameWorkOp original type [%s]", type.c_str());

  1243.   return SUCCESS;

  1244. }

  1245. 

  1246. FMK_FUNC_HOST_VISIBILITY bool ValidateStr(const std::string &str, const std::string &mode) {

  1247.   char ebuff[kMaxBuffSize];

  1248.   regex_t reg;

  1249.   int cflags = REG_EXTENDED | REG_NOSUB;

  1250.   int ret = regcomp(&reg, mode.c_str(), cflags);

  1251.   if (ret) {

  1252.     regerror(ret, &reg, ebuff, kMaxBuffSize);

  1253.     GELOGW("regcomp failed, reason: %s", ebuff);

  1254.     regfree(&reg);

  1255.     return true;

  1256.   }

  1257. 

  1258.   ret = regexec(&reg, str.c_str(), 0, nullptr, 0);

  1259.   if (ret) {

  1260.     regerror(ret, &reg, ebuff, kMaxBuffSize);

  1261.     GELOGE(ge::PARAM_INVALID, "regexec failed, reason: %s", ebuff);

  1262.     regfree(&reg);

  1263.     return false;

  1264.   }

  1265. 

  1266.   regfree(&reg);

  1267.   return true;

  1268. }

  1269. 

  1270. FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY std::string CurrentTimeInStr() {

  1271.   std::time_t now = std::time(nullptr);

  1272.   std::tm *ptm = std::localtime(&now);

  1273.   if (ptm == nullptr) {

  1274.     GELOGE(ge::FAILED, "Localtime failed.");

  1275.     return "";

  1276.   }

  1277. 

  1278.   const int kTimeBufferLen = 32;

  1279.   char buffer[kTimeBufferLen + 1] = {0};

  1280.   // format: 20171122042550

  1281.   std::strftime(buffer, kTimeBufferLen, "%Y%m%d%H%M%S", ptm);

  1282.   return std::string(buffer);

  1283. }

  1284. }  // namespace parser

  1285. }  // namespace ge