Merge pull request !1771 from 王笑天/mastertags/v1.3.0
@@ -290,7 +290,6 @@ FileSaver::SaveToFile(const string &file_path, const ge::ModelData &model, const | |||
copy_header_ret); | |||
file_header.length = model.model_len; | |||
file_header.is_encrypt = ModelEncryptType::UNENCRYPTED; | |||
const Status ret = SaveWithFileHeader(file_path, file_header, model.model_data, file_header.length); | |||
if (ret != SUCCESS) { | |||
@@ -305,8 +304,6 @@ FileSaver::SaveToFile(const string &file_path, const ge::ModelData &model, const | |||
FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status | |||
FileSaver::SaveToFile(const string &file_path, ModelFileHeader &file_header, ModelPartitionTable &model_partition_table, | |||
const std::vector<ModelPartition> &partition_datas) { | |||
file_header.is_encrypt = ModelEncryptType::UNENCRYPTED; | |||
const Status ret = SaveWithFileHeader(file_path, file_header, model_partition_table, partition_datas); | |||
GE_CHK_BOOL_RET_STATUS(ret == SUCCESS, FAILED, "save file failed, file_path:%s, file header len:%u.", | |||
file_path.c_str(), file_header.length); | |||
@@ -317,8 +314,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status | |||
FileSaver::SaveToFile(const string &file_path, ModelFileHeader &file_header, | |||
vector<ModelPartitionTable *> &model_partition_tables, | |||
const vector<vector<ModelPartition>> &all_partition_datas) { | |||
file_header.is_encrypt = ModelEncryptType::UNENCRYPTED; | |||
const Status ret = SaveWithFileHeader(file_path, file_header, model_partition_tables, all_partition_datas); | |||
GE_CHK_BOOL_RET_STATUS(ret == SUCCESS, FAILED, "save file failed, file_path:%s, file header len:%u.", | |||
file_path.c_str(), file_header.length); | |||
@@ -126,8 +126,8 @@ Status PluginManager::LoadSo(const string &path, const vector<string> &func_chec | |||
if (handle == nullptr) { | |||
const char *error = mmDlerror(); | |||
GE_IF_BOOL_EXEC(error == nullptr, error = ""); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19012", {"function", "reason"}, | |||
{"mmDlopen", "shared library path is " + FmtToStr(file_path_dlopen) + ". Errormessage" + FmtToStr(error)}); | |||
REPORT_INNER_ERROR("E19999", "DLOpen SharedLibraryPath failed, path[%s]. Errormessage[%s]!", | |||
file_path_dlopen.c_str(), error); | |||
GELOGE(ACL_ERROR_GE_PLGMGR_PATH_INVALID, | |||
"[DLOpen][SharedLibraryPath]Failed, path[%s]. Errormessage[%s]!", | |||
file_path_dlopen.c_str(), error); | |||
@@ -141,9 +141,8 @@ Status PluginManager::LoadSo(const string &path, const vector<string> &func_chec | |||
if (real_fn == nullptr) { | |||
const char *error = mmDlerror(); | |||
GE_IF_BOOL_EXEC(error == nullptr, error = ""); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19012", {"function", "reason"}, | |||
{"mmDlsym", FmtToStr(func_name) + " is skipped since function" + | |||
FmtToStr(func_name) + " is not existed!"}); | |||
REPORT_INNER_ERROR("E19999", "[Check][So]%s is skipped since function %s is not existed! errmsg:%s", | |||
func_name.c_str(), func_name.c_str(), error); | |||
GELOGE(ACL_ERROR_GE_PLGMGR_PATH_INVALID, | |||
"[Check][So]%s is skipped since function %s is not existed! errmsg:%s", | |||
func_name.c_str(), func_name.c_str(), error); | |||
@@ -1672,10 +1672,9 @@ Status ModelCacheHelper::LoadOmModelFromCache(GeModelPtr &ge_model) const { | |||
} | |||
GELOGI("load model data from file: %s", om_path.c_str()); | |||
Status ret; | |||
string key_path; | |||
int32_t priority = 0; | |||
ModelData model_data; | |||
ret = ModelParserBase::LoadFromFile(om_path.c_str(), key_path.c_str(), priority, model_data); | |||
ret = ModelParserBase::LoadFromFile(om_path.c_str(), priority, model_data); | |||
if (ret != SUCCESS) { | |||
GELOGW("LoadOmModelFromCache: Load model from file failed. ret = %u", ret); | |||
return ret; | |||
@@ -39,8 +39,6 @@ Status ModelHelper::SaveModelPartition(std::shared_ptr<OmFileSaveHelper> &om_fil | |||
const uint8_t *data, size_t size, size_t model_index) { | |||
if (size < 1 || size > UINT32_MAX) { | |||
GELOGE(PARAM_INVALID, "[Add][ModelPartition]Failed, partition size %zu invalid", size); | |||
REPORT_INNER_ERROR("E19999", "Add model partition failed, partition size %zu " | |||
"invalid", size); | |||
if (size > UINT32_MAX) { | |||
string item = "item"; | |||
if (type == MODEL_DEF) { | |||
@@ -57,6 +55,8 @@ Status ModelHelper::SaveModelPartition(std::shared_ptr<OmFileSaveHelper> &om_fil | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19023", {"size", "item", "maxsize"}, | |||
{std::to_string(size), item, std::to_string(UINT32_MAX)}); | |||
} | |||
REPORT_INNER_ERROR("E19999", "Add model partition failed, partition size %zu " | |||
"invalid", size); | |||
return PARAM_INVALID; | |||
} | |||
if (data == nullptr) { | |||
@@ -1013,7 +1013,7 @@ Status ModelTool::GetModelInfoFromOm(const char *model_file, ge::proto::ModelDef | |||
ge::ModelData model; | |||
int32_t priority = 0; | |||
Status ret = ModelParserBase::LoadFromFile(model_file, "", priority, model); | |||
Status ret = ModelParserBase::LoadFromFile(model_file, priority, model); | |||
if (ret != SUCCESS) { | |||
GELOGE(ret, "[Load][ModelInfo]Failed from file %s, error_code %u", model_file, ret); | |||
REPORT_CALL_ERROR("E19999", "Load model info failed from file %s, error_code %u", | |||
@@ -1033,7 +1033,7 @@ Status ModelTool::GetModelInfoFromOm(const char *model_file, ge::proto::ModelDef | |||
ret = ModelParserBase::ParseModelContent(model, model_data, model_len); | |||
if (ret != SUCCESS) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10003", | |||
{"parameter", "value", "reason"}, {"om", model_file, "invalid om file"}); | |||
{"parameter", "value", "reason"}, {"om", model_file, "invalid om file, can't be parsed"}); | |||
GELOGE(ACL_ERROR_GE_PARAM_INVALID, | |||
"[Parse][ModelContent]Failed because of invalid om file %s, please check om param", | |||
model_file); | |||
@@ -1072,7 +1072,7 @@ Status ModelTool::GetModelInfoFromPbtxt(const char *model_file, ge::proto::Model | |||
ge::ModelData model; | |||
int32_t priority = 0; | |||
Status ret = ModelParserBase::LoadFromFile(model_file, "", priority, model); | |||
Status ret = ModelParserBase::LoadFromFile(model_file, priority, model); | |||
auto free_model_data = [](void **ptr) -> void { | |||
if (ptr != nullptr && *ptr != nullptr) { | |||
delete[] reinterpret_cast<char *>(*ptr); | |||
@@ -27,7 +27,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ModelParserBase::ModelParserBas | |||
FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ModelParserBase::~ModelParserBase() {} | |||
FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelParserBase::LoadFromFile(const char *model_path, | |||
const char *key, int32_t priority, | |||
int32_t priority, | |||
ge::ModelData &model_data) { | |||
std::string real_path = RealPath(model_path); | |||
if (real_path.empty()) { | |||
@@ -77,7 +77,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelParserBase::LoadFro | |||
model_data.model_data = data; | |||
model_data.model_len = len; | |||
model_data.priority = priority; | |||
model_data.key = (key == nullptr) ? "" : key; | |||
return SUCCESS; | |||
} | |||
@@ -113,23 +112,9 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelParserBase::ParseMo | |||
// Get data address | |||
uint8_t *data = reinterpret_cast<uint8_t *>(model.model_data) + sizeof(ModelFileHeader); | |||
if (file_header->is_encrypt == ModelEncryptType::UNENCRYPTED) { // Unencrypted model | |||
if (!model.key.empty()) { | |||
REPORT_INPUT_ERROR("E10003", std::vector<std::string>({"parameter", "value", "reason"}), | |||
std::vector<std::string>({"om", model.om_name.c_str(), "invalid om file"})); | |||
GELOGE(ACL_ERROR_GE_PARAM_INVALID, | |||
"[Check][Param] Invalid param, model is unencrypted, but key is not empty."); | |||
return ACL_ERROR_GE_PARAM_INVALID; | |||
} | |||
model_data = data; | |||
model_len = file_header->length; | |||
GELOGD("Model_len is %u, model_file_head_len is %zu.", model_len, sizeof(ModelFileHeader)); | |||
} else { | |||
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "[Check][Param]Invalid, model encrypt type not supported"); | |||
REPORT_INPUT_ERROR("E10003", std::vector<std::string>({"parameter", "value", "reason"}), | |||
std::vector<std::string>({"om", model.om_name.c_str(), "invalid om file"})); | |||
res = ACL_ERROR_GE_PARAM_INVALID; | |||
} | |||
model_data = data; | |||
model_len = file_header->length; | |||
GELOGD("Model_len is %u, model_file_head_len is %zu.", model_len, sizeof(ModelFileHeader)); | |||
return res; | |||
} | |||
@@ -43,12 +43,11 @@ class ModelParserBase { | |||
* @ingroup hiai | |||
* @brief Parsing a model file | |||
* @param [in] model_file model path | |||
* @param [in] model_key model secret key | |||
* @param [in] priority modle priority | |||
* @param [out] model_data model data | |||
* @return Status result | |||
*/ | |||
static Status LoadFromFile(const char *model_file, const char *model_key, int32_t priority, | |||
static Status LoadFromFile(const char *model_file, int32_t priority, | |||
ge::ModelData &model_data); | |||
/** | |||
@@ -41,12 +41,12 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelSaver::SaveJsonToFi | |||
try { | |||
model_str = model.dump(kInteval, ' ', false, Json::error_handler_t::ignore); | |||
} catch (std::exception &e) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19007", {"exception"}, {e.what()}); | |||
REPORT_INNER_ERROR("E19999", "Failed to convert JSON to string, reason: %s, savefile:%s.", e.what(), file_path); | |||
GELOGE(FAILED, "[Convert][File]Failed to convert JSON to string, file %s, reason %s", | |||
file_path, e.what()); | |||
return FAILED; | |||
} catch (...) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19008"); | |||
REPORT_INNER_ERROR("E19999", "Failed to convert JSON to string, savefile:%s.", file_path); | |||
GELOGE(FAILED, "[Convert][File]Failed to convert JSON to string, file %s", file_path); | |||
return FAILED; | |||
} | |||
@@ -70,39 +70,6 @@ static bool ReadProtoFromCodedInputStream(CodedInputStream &coded_stream, Messag | |||
return proto->ParseFromCodedStream(&coded_stream); | |||
} | |||
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!"); | |||
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); | |||
GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(GetFileLength(real_path) == kFileSizeOutLimitedOrOpenFailed, return false, | |||
"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][File]Failed, file path %s", file); | |||
return false; | |||
} | |||
google::protobuf::io::IstreamInputStream istream(&fs); | |||
google::protobuf::io::CodedInputStream coded_stream(&istream); | |||
bool ret = ReadProtoFromCodedInputStream(coded_stream, proto); | |||
fs.close(); | |||
if (!ret) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19005", {"file"}, {file}); | |||
GELOGE(ge::FAILED, "[Parse][File]Failed, file %s", file); | |||
return ret; | |||
} | |||
return ret; | |||
} | |||
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"); | |||
@@ -125,13 +92,13 @@ long GetFileLength(const std::string &input_file) { | |||
return kFileSizeOutLimitedOrOpenFailed, "Open file[%s] failed. errmsg:%s", input_file.c_str(), strerror(errno)); | |||
GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((file_length == 0), | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19015", {"filepath"}, {input_file}); | |||
REPORT_INNER_ERROR("E19999", "file:%s size is 0, not valid", input_file.c_str()); | |||
return -1, "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)}); | |||
file_length > kMaxFileSizeLimit, | |||
REPORT_INNER_ERROR("E19999", "file:%s size:%lld is out of limit: %d.", input_file.c_str(), file_length, | |||
kMaxFileSizeLimit); | |||
return kFileSizeOutLimitedOrOpenFailed, "File[%s] size %lld is out of limit: %d.", input_file.c_str(), file_length, | |||
kMaxFileSizeLimit); | |||
return static_cast<long>(file_length); | |||
@@ -227,7 +194,9 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY int CreateDirectory(const std:: | |||
int32_t ret = mmMkdir(tmp_dir_path, M_IRUSR | M_IWUSR | M_IXUSR); // 700 | |||
if (ret != 0) { | |||
if (errno != EEXIST) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19006", {"path"}, {directory_path}); | |||
REPORT_CALL_ERROR("E19999", | |||
"Can not create directory %s. Make sure the directory exists and writable. errmsg:%s", | |||
directory_path.c_str(), strerror(errno)); | |||
GELOGW("Can not create directory %s. Make sure the directory exists and writable. errmsg:%s", | |||
directory_path.c_str(), strerror(errno)); | |||
return ret; | |||
@@ -239,7 +208,9 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY int CreateDirectory(const std:: | |||
int32_t ret = mmMkdir(const_cast<char *>(directory_path.c_str()), M_IRUSR | M_IWUSR | M_IXUSR); // 700 | |||
if (ret != 0) { | |||
if (errno != EEXIST) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19006", {"path"}, {directory_path}); | |||
REPORT_CALL_ERROR("E19999", | |||
"Can not create directory %s. Make sure the directory exists and writable. errmsg:%s", | |||
directory_path.c_str(), strerror(errno)); | |||
GELOGW("Can not create directory %s. Make sure the directory exists and writable. errmsg:%s", | |||
directory_path.c_str(), strerror(errno)); | |||
return ret; | |||
@@ -279,7 +250,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromText(const ch | |||
std::ifstream fs(real_path.c_str(), std::ifstream::in); | |||
if (!fs.is_open()) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19017", {"realpth", "protofile"}, {real_path, file}); | |||
REPORT_INNER_ERROR("E19999", "open file:%s failed", real_path.c_str()); | |||
GELOGE(ge::FAILED, "[Open][ProtoFile]Failed, real path %s, orginal file path %s", | |||
real_path.c_str(), file); | |||
return false; | |||
@@ -374,14 +345,24 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool CheckInputPathValid(const | |||
// The specified path is empty | |||
std::map<std::string, std::string> args_map; | |||
if (file_path.empty()) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10004", {"parameter"}, {atc_param}); | |||
if (atc_param != "") { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10004", {"parameter"}, {atc_param}); | |||
} else { | |||
REPORT_INNER_ERROR("E19999", "Param file_path is empty, check invalid"); | |||
} | |||
GELOGW("Input parameter %s is empty.", file_path.c_str()); | |||
return false; | |||
} | |||
std::string real_path = RealPath(file_path.c_str()); | |||
// Unable to get absolute path (does not exist or does not have permission to access) | |||
if (real_path.empty()) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19000", {"path", "errmsg"}, {file_path, strerror(errno)}); | |||
if (atc_param != "") { | |||
std::string reason = "realpath error, errmsg:" + std::string(strerror(errno)); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, | |||
{atc_param, file_path, reason}); | |||
} else { | |||
REPORT_INNER_ERROR("E19999", "Path[%s]'s realpath is empty, errmsg[%s]", file_path.c_str(), strerror(errno)); | |||
} | |||
GELOGW("Path[%s]'s realpath is empty, errmsg[%s]", file_path.c_str(), strerror(errno)); | |||
return false; | |||
} | |||
@@ -397,13 +378,23 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool CheckInputPathValid(const | |||
GE_CHK_BOOL_TRUE_EXEC_WITH_LOG( | |||
!ValidateStr(real_path, mode), | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, | |||
{atc_param, real_path, kPathValidReason}); | |||
if (atc_param != "") { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, | |||
{atc_param, real_path, kPathValidReason}); | |||
} else { | |||
REPORT_INNER_ERROR("E19999", "Path[%s] has invalid char, %s", file_path.c_str(), kPathValidReason); | |||
} | |||
return false, "Invalid value for %s[%s], %s.", atc_param.c_str(), real_path.c_str(), kPathValidReason); | |||
// The absolute path points to a file that is not readable | |||
if (mmAccess2(real_path.c_str(), M_R_OK) != EN_OK) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19003", {"file", "errmsg"}, {file_path.c_str(), strerror(errno)}); | |||
if (atc_param != "") { | |||
std::string reason = "cat not access, errmsg:" + std::string(strerror(errno)); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, | |||
{atc_param, file_path, reason}); | |||
} else { | |||
REPORT_INNER_ERROR("E19999", "Path[%s] can't acccess, errmsg:%s", file_path.c_str(), strerror(errno)); | |||
} | |||
GELOGW("Read file[%s] failed, errmsg[%s]", file_path.c_str(), strerror(errno)); | |||
return false; | |||
} | |||
@@ -415,14 +406,27 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool CheckOutputPathValid(const | |||
const std::string &atc_param) { | |||
// The specified path is empty | |||
if (file_path.empty()) { | |||
if (atc_param != "") { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10004", {"parameter"}, {atc_param}); | |||
} else { | |||
REPORT_INNER_ERROR("E19999", "Param file_path is empty, check invalid"); | |||
} | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10004", {"parameter"}, {atc_param}); | |||
GELOGW("Input parameter's value is empty."); | |||
return false; | |||
} | |||
GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(strlen(file_path.c_str()) >= MMPA_MAX_PATH, | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E19002", {"filepath", "size"}, {file_path, std::to_string(MMPA_MAX_PATH)}); | |||
if (atc_param != "") { | |||
std::string reason = "len is too long, it must be less than " + | |||
std::to_string(MMPA_MAX_PATH); | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E10001", {"parameter", "value", "reason"}, | |||
{atc_param, file_path, reason}); | |||
} else { | |||
REPORT_INNER_ERROR("E19999", "Path[%s] len is too long, it must be less than %d", | |||
file_path.c_str(), MMPA_MAX_PATH); | |||
} | |||
return "", "Path[%s] len is too long, it must be less than %d", file_path.c_str(), | |||
MMPA_MAX_PATH); | |||
@@ -437,8 +441,12 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool CheckOutputPathValid(const | |||
GE_CHK_BOOL_TRUE_EXEC_WITH_LOG( | |||
!ValidateStr(file_path, mode), | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, | |||
{atc_param, file_path, kPathValidReason}); | |||
if (atc_param != "") { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, | |||
{atc_param, file_path, kPathValidReason}); | |||
} else { | |||
REPORT_INNER_ERROR("E19999", "Path[%s] has invalid char, %s", file_path.c_str(), kPathValidReason); | |||
} | |||
return false, "Invalid value for %s[%s], %s.", atc_param.c_str(), file_path.c_str(), kPathValidReason); | |||
std::string real_path = RealPath(file_path.c_str()); | |||
@@ -446,7 +454,13 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool CheckOutputPathValid(const | |||
if (!real_path.empty()) { | |||
// File is not readable or writable | |||
if (mmAccess2(real_path.c_str(), M_W_OK | M_F_OK) != EN_OK) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19004", {"file", "errmsg"}, {real_path, strerror(errno)}); | |||
if (atc_param != "") { | |||
std::string reason = "cat not access, errmsg:" + std::string(strerror(errno)); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, | |||
{atc_param, file_path, reason}); | |||
} else { | |||
REPORT_INNER_ERROR("E19999", "Path[%s] can't acccess, errmsg:%s", file_path.c_str(), strerror(errno)); | |||
} | |||
GELOGW("Write file[%s] failed, errmsg[%s]", real_path.c_str(), strerror(errno)); | |||
return false; | |||
} | |||
@@ -465,7 +479,12 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool CheckOutputPathValid(const | |||
std::string prefix_path = std::string(file_path).substr(0, static_cast<size_t>(path_split_pos)); | |||
// Determine whether the specified path is valid by creating the path | |||
if (CreateDirectory(prefix_path) != 0) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19006", {"path"}, {file_path}); | |||
if (atc_param != "") { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, | |||
{atc_param, file_path, "Can not create directory"}); | |||
} else { | |||
REPORT_INNER_ERROR("E19999", "Path[%s] Can not create directory", file_path.c_str()); | |||
} | |||
GELOGW("Can not create directory[%s].", file_path.c_str()); | |||
return false; | |||
} | |||
@@ -45,7 +45,6 @@ const char *const kAttch = "attach"; | |||
const char *const kVectorCore = "VectorCore"; | |||
const char *const kVectorEngine = "VectorEngine"; | |||
const char *const kAIcoreEngine = "AIcoreEngine"; | |||
const char *const kCustomOpFlag = "_custom_op_flag"; | |||
const char *const kHostCpuEngineName = "DNN_VM_HOST_CPU"; | |||
const char *const kHostCpuOpKernelLibName = "DNN_VM_HOST_CPU_OP_STORE"; | |||
} // namespace | |||
@@ -248,19 +247,6 @@ std::string DNNEngineManager::GetDNNEngineName(const ge::NodePtr &node_ptr) { | |||
return it.engine; | |||
} else { | |||
checksupport_cost_[kernel_name] += GetCurrentTimestamp() - start_time; | |||
bool is_custom_op = false; | |||
if ((ge::AttrUtils::GetBool(op_desc, kCustomOpFlag, is_custom_op)) && is_custom_op) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E13001", {"kernelname", "optype", "opname"}, | |||
{kernel_name, op_desc->GetType(), op_desc->GetName()}); | |||
GELOGE(FAILED, | |||
"[Check][Param]The custom operator registered by the user does not support " | |||
"the logic function delivered by this network, kernel_name %s, op type %s, " | |||
"op name %s", | |||
kernel_name.c_str(), op_desc->GetType().c_str(), op_desc->GetName().c_str()); | |||
std::string error_info = "The custom operator registered by the user does not support the logic function" | |||
"delivered by this network"; | |||
return ""; | |||
} | |||
unsupported_reasons.emplace(kernel_name, unsupported_reason); | |||
GELOGI("DNNEngineManager:Check support failed, kernel_name is %s, op type is %s, op name is %s", | |||
kernel_name.c_str(), op_desc->GetType().c_str(), op_desc->GetName().c_str()); | |||
@@ -283,7 +269,7 @@ std::string DNNEngineManager::GetDNNEngineName(const ge::NodePtr &node_ptr) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E13002", {"optype", "opskernel", "reason"}, {op_desc->GetType(), it.first, it.second}); | |||
GELOGE(GE_GRAPH_ASSIGN_ENGINE_FAILED, "[Check][OpSupported]Op type %s of ops kernel %s " | |||
"is unsupported, reason %s", | |||
"is unsupported, reason : %s", | |||
op_desc->GetType().c_str(), it.first.c_str(), it.second.c_str()); | |||
} | |||
@@ -209,7 +209,7 @@ static void InitOpsProtoManager() { | |||
string file_path = RealPath(path.c_str()); | |||
if (file_path.empty()) { | |||
GELOGE(FAILED, "[Check][EnvPath]ASCEND_OPP_PATH path [%s] is invalid.", path.c_str()); | |||
REPORT_INPUT_ERROR("E68016", {"ASCEND_OPP_PATH", path}); | |||
REPORT_INPUT_ERROR("E68016", {"ASCEND_OPP_PATH", path}); | |||
return; | |||
} | |||
opsproto_path = (path + "/op_proto/custom/" + ":") + (path + "/op_proto/built-in/"); | |||
@@ -804,9 +804,8 @@ Status GeExecutor::LoadDataFromFile(const std::string &path, ModelData &model_da | |||
return ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID; | |||
} | |||
GELOGI("load modelData from file: %s.", path.c_str()); | |||
std::string key_path; | |||
int32_t priority = 0; | |||
Status ret = GraphLoader::LoadDataFromFile(path, key_path, priority, model_data); | |||
Status ret = GraphLoader::LoadDataFromFile(path, priority, model_data); | |||
if (ret != SUCCESS) { | |||
if (model_data.model_data != nullptr) { | |||
delete[] static_cast<char *>(model_data.model_data); | |||
@@ -932,8 +931,7 @@ Status GeExecutor::GetMemAndWeightSize(const std::string &path, size_t &mem_size | |||
} | |||
ModelData model; | |||
std::string key; | |||
Status ret = ge::GraphLoader::LoadDataFromFile(path, key, 0, model); | |||
Status ret = ge::GraphLoader::LoadDataFromFile(path, 0, model); | |||
if ((ret != SUCCESS) || (model.model_data == nullptr)) { | |||
GELOGE(ret, "Load data from file failed. ret = %d", ret); | |||
return ret; | |||
@@ -268,12 +268,13 @@ Status GraphMemoryAssigner::ReAssignMemory(bool is_loop_graph, map<uint64_t, siz | |||
total_mem_offset, VarManager::Instance(session_id)->GetGraphMemoryMaxSize(), | |||
compute_graph_->GetGraphID(), compute_graph_->GetName().c_str()); | |||
for (auto iter : mem_type_to_offset) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19022", {"memType", "size", "item", "maxsize"}, | |||
{std::to_string(iter.first), std::to_string(iter.second), "featuremap", | |||
std::to_string(VarManager::Instance(session_id)->GetGraphMemoryMaxSize())}); | |||
GEEVENT("[IMAS]AfterAssignMemory : %s memoffset[%zu], memtype[%ld]", compute_graph_->GetName().c_str(), | |||
iter.second, iter.first); | |||
} | |||
REPORT_INPUT_ERROR( | |||
"E19022", std::vector<std::string>({"size", "item", "maxsize"}), | |||
std::vector<std::string>({std::to_string(total_mem_offset), "featuremap", | |||
std::to_string(VarManager::Instance(session_id)->GetGraphMemoryMaxSize())})); | |||
return ge::FAILED; | |||
} | |||
return SUCCESS; | |||
@@ -1838,17 +1839,17 @@ bool GraphMemoryAssigner::CheckContinuousMemType(vector<int64_t> mem_type_list) | |||
int64_t mem_type_tmp = mem_type_list[0]; | |||
for (auto mem_type : mem_type_list) { | |||
if (mem_type != mem_type_tmp) { | |||
std::string error = "The memory is continuous, but the type of the input memory is inconsistent. They are " + | |||
FmtToStr(mem_type_tmp) + " and " + FmtToStr(mem_type); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10043", {"reason"}, {error}); | |||
REPORT_INNER_ERROR( | |||
"E19999", | |||
"The memory is continuous, but the type of the input memory is inconsistent. They are %s and %s", | |||
FmtToStr(mem_type_tmp).c_str(), FmtToStr(mem_type).c_str()); | |||
GELOGW("The memory is continuous, but the type of the input memory is inconsistent. They are [%ld] and [%ld].", | |||
mem_type_tmp, mem_type); | |||
return false; | |||
} | |||
} | |||
if (memory_offset_.find(mem_type_tmp) == memory_offset_.end()) { | |||
std::string error = "Memory offset map does not have memory type" + FmtToStr(mem_type_tmp); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10043", {"reason"}, {error}); | |||
REPORT_INNER_ERROR("E19999", "Memory offset map does not have memory type %s", FmtToStr(mem_type_tmp).c_str()); | |||
GELOGW("Memory offset map does not have memory type[%ld].", mem_type_tmp); | |||
return false; | |||
} | |||
@@ -123,23 +123,17 @@ Status GraphLoader::GetMaxUsedMemory(uint32_t model_id, uint64_t &max_size) { | |||
return SUCCESS; | |||
} | |||
Status GraphLoader::LoadDataFromFile(const std::string &path, const std::string &key_path, int32_t priority, | |||
ModelData &model_data) { | |||
if (!CheckInputPathValid(path)) { | |||
Status GraphLoader::LoadDataFromFile(const std::string &path, int32_t priority, ModelData &model_data) { | |||
if (!CheckInputPathValid(path, "model_file")) { | |||
GELOGE(ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID, "[Check][Param] model path is invalid:%s", path.c_str()); | |||
return ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID; | |||
} | |||
GELOGI("Load model begin, model path is: %s", path.c_str()); | |||
if (!key_path.empty() && !CheckInputPathValid(key_path)) { | |||
REPORT_INNER_ERROR("E19999", "Param key_path:%s empty or invalid", key_path.c_str()); | |||
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "[Check][Param] decrypt_key path is invalid:%s", key_path.c_str()); | |||
return ACL_ERROR_GE_PARAM_INVALID; | |||
} | |||
Status ret = ModelParserBase::LoadFromFile(path.c_str(), key_path.c_str(), priority, model_data); | |||
Status ret = ModelParserBase::LoadFromFile(path.c_str(), priority, model_data); | |||
if (ret != SUCCESS) { | |||
GELOGE(ret, "[Call][LoadFromFile] failed. ret = %u, path:%s, key path:%s", ret, path.c_str(), key_path.c_str()); | |||
GELOGE(ret, "[Call][LoadFromFile] failed. ret = %u, path:%s", ret, path.c_str()); | |||
if (model_data.model_data != nullptr) { | |||
delete[] static_cast<char *>(model_data.model_data); | |||
model_data.model_data = nullptr; | |||
@@ -48,8 +48,7 @@ class GraphLoader { | |||
static Status GetMemoryInfo(int64_t &free); | |||
static Status LoadDataFromFile(const std::string &path, const std::string &key_path, int32_t priority, | |||
ModelData &model_data); | |||
static Status LoadDataFromFile(const std::string &path, int32_t priority, ModelData &model_data); | |||
static Status LoadModelFromData(uint32_t &model_id, const ModelData &model_data, void *dev_ptr, size_t mem_size, | |||
void *weight_ptr, size_t weight_size); | |||
@@ -3436,37 +3436,39 @@ void DavinciModel::SetZeroCopyAddr(const OpDescPtr &op_desc, const std::vector<v | |||
/// @param [in] is_dynamic: dynamic batch input flag. | |||
/// @return true if success | |||
/// | |||
bool DavinciModel::CheckInputAndModelSize(const int64_t &input_size, const int64_t &op_size, bool is_dynamic) { | |||
bool DavinciModel::CheckUserAndModelSize(const int64_t &size, const int64_t &op_size, | |||
bool is_input, bool is_dynamic) { | |||
const std::string input_or_output = is_input ? "input" : "output"; | |||
if (is_dynamic) { // dynamic is max size. | |||
GELOGI("No need to check input and model size."); | |||
GELOGI("No need to check user %s and model size.", input_or_output.c_str()); | |||
return true; | |||
} | |||
if (input_size > op_size) { | |||
if (size > op_size) { | |||
GELOGW( | |||
"Input size [%ld] is bigger than om size need [%ld], " | |||
"User %s size [%ld] is bigger than om size need [%ld], " | |||
"MAY cause inference result ERROR, please check model input", | |||
input_size, op_size); | |||
input_or_output.c_str(), size, op_size); | |||
} | |||
if (is_dynamic_aipp_) { | |||
GELOGI("This is dynamic aipp model, no need to judge smaller input size"); | |||
GELOGI("This is dynamic aipp model, no need to judge smaller user size"); | |||
return true; | |||
} | |||
// Judge overflow first | |||
if (input_size > (INT64_MAX - kDataMemAlignSizeCompare)) { | |||
GELOGI("The Input size [%ld] is smaller than model size [%ld] and is in the range of 64 bytes", input_size, | |||
op_size); | |||
if (size > (INT64_MAX - kDataMemAlignSizeCompare)) { | |||
GELOGI("The user %s size [%ld] is smaller than model size [%ld] and is in the range of 64 bytes", | |||
input_or_output.c_str(), size, op_size); | |||
return true; | |||
} | |||
// The input and model input size can not be exactly equal because user input is not definite. | |||
if ((input_size + kDataMemAlignSizeCompare) < op_size) { | |||
REPORT_INNER_ERROR("E19999", "input size:%ld from user add align:%u > input_op_size:%ld in model, model_id:%u, " | |||
if ((size + kDataMemAlignSizeCompare) < op_size) { | |||
REPORT_INNER_ERROR("E19999", "%s size:%ld from user add align:%u < input_op_size:%ld in model, model_id:%u, " | |||
"check invalid", | |||
input_size, kDataMemAlignSizeCompare, op_size, model_id_); | |||
input_or_output.c_str(), size, kDataMemAlignSizeCompare, op_size, model_id_); | |||
GELOGE(ACL_ERROR_GE_PARAM_INVALID, | |||
"[Check][Param] input size:%ld from user add align:%u > input_op_size:%ld in model, model_id:%u", | |||
input_size, kDataMemAlignSizeCompare, op_size, model_id_); | |||
"[Check][Param] %s size:%ld from user add align:%u < input_op_size:%ld in model, model_id:%u", | |||
input_or_output.c_str(), size, kDataMemAlignSizeCompare, op_size, model_id_); | |||
return false; | |||
} | |||
return true; | |||
@@ -3544,7 +3546,7 @@ Status DavinciModel::UpdateIoTaskArgs(const std::map<uint32_t, ZeroCopyOffset> & | |||
return ACL_ERROR_GE_PARAM_INVALID; | |||
} | |||
if (!CheckInputAndModelSize(buffer.length, data.second.GetDataSize(), is_dynamic)) { | |||
if (!CheckUserAndModelSize(buffer.length, data.second.GetDataSize(), is_input, is_dynamic)) { | |||
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "[Call][CheckInputAndModelSize] failed, op[%s]", | |||
data.second.GetOpName().c_str()); | |||
return ACL_ERROR_GE_PARAM_INVALID; | |||
@@ -611,7 +611,7 @@ class DavinciModel { | |||
/// @param [in] is_dynamic: dynamic batch input flag. | |||
/// @return true if success | |||
/// | |||
bool CheckInputAndModelSize(const int64_t &input_size, const int64_t &op_size, bool is_dynamic); | |||
bool CheckUserAndModelSize(const int64_t &size, const int64_t &op_size, bool is_input, bool is_dynamic); | |||
/// | |||
/// @ingroup ge | |||
@@ -220,8 +220,8 @@ Status MultiBatchClonePass::CheckAndParseDynamicData() { | |||
GELOGE(PARAM_INVALID, "[Check][DynamicImageSizeShape] of %s failed.", data_name.c_str()); | |||
return PARAM_INVALID); | |||
} else if (!GetLocalOmgContext().dynamic_dims.empty()) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "reason"}, | |||
{"--input_shape", "all dynamic data must be set in --input_shape"}); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"}, | |||
{"--dynamic_dims", data_name, "all dynamic node must be set in --input_shape, please check"}); | |||
GELOGE(INTERNAL_ERROR, "[Check][Param] data:%s shape:%s must be set int --input_shape", | |||
node->GetName().c_str(), data_shape.ToString().c_str()); | |||
return INTERNAL_ERROR; | |||
@@ -195,9 +195,8 @@ NodePtr CreateTransNode(const std::string &name, const std::string &node_type, c | |||
auto index = TransOpUtil::GetTransOpDataIndex(node_type); | |||
if (index < 0) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E19025", {"situation", "reason"}, | |||
{"The trans node type[" + node_type + "]", "it must be " + TransOpUtil::TransopMapToString()}); | |||
REPORT_INNER_ERROR("E19999", "The trans node type %s does not exists, it must be %s", | |||
node_type.c_str(), TransOpUtil::TransopMapToString().c_str()); | |||
GELOGE(INTERNAL_ERROR, "[Check][Param] The trans node type %s does not exists", node_type.c_str()); | |||
return nullptr; | |||
} | |||
@@ -421,8 +420,8 @@ Status RecoverTransRoadForVar(const NodePtr &var, const VarTransRoad &road) { | |||
auto trans_name = var->GetName() + "_trans_" + std::to_string(index++); | |||
auto ret = RecoverOneTransNodeForVar(trans_name, *iter, last_node, last_node); | |||
if (ret != SUCCESS) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E15001", {"variable", "index", "type"}, {var->GetName(), std::to_string(index), iter->node_type}); | |||
REPORT_CALL_ERROR("E19999", "Failed to recover trans node for variable %s, index %d, type %s", | |||
var->GetName().c_str(), index, iter->node_type.c_str()); | |||
GELOGE(INTERNAL_ERROR, "[Recover][TransNode] for variable %s, index %d, type %s", var->GetName().c_str(), | |||
index, iter->node_type.c_str()); | |||
return INTERNAL_ERROR; | |||
@@ -467,8 +466,8 @@ Status RecoverTransRoadForVarRef(const std::set<NodePtr> &nodes, const VarTransR | |||
auto trans_name = var->GetName() + "_trans_" + std::to_string(index++); | |||
auto ret = RecoverOneTransNodeForVarRef(trans_name, *iter, last_node, last_node); | |||
if (ret != SUCCESS) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E15001", {"variable", "index", "type"}, {var->GetName(), std::to_string(index), iter->node_type}); | |||
REPORT_CALL_ERROR("E19999", "Failed to recover trans node for variable %s, index %d, type %s", | |||
var->GetName().c_str(), index, iter->node_type.c_str()); | |||
GELOGE(INTERNAL_ERROR, "[Recover][TransNode] for variable %s failed, index %d, type %s", | |||
var->GetName().c_str(), index, iter->node_type.c_str()); | |||
return INTERNAL_ERROR; | |||
@@ -643,8 +642,8 @@ Status CheckIfDynamicBatchScene(NodePtr &data_node, bool &is_dynamic_batch, Node | |||
std::string related_node_name; | |||
if (AttrUtils::GetStr(data_node->GetOpDesc(), kMbatchSwitchnName, related_node_name)) { | |||
if (related_node_name.empty()) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E15002", {"opname", "value", "reason"}, {data_node->GetName(), "flag", "but the value is empty"}); | |||
REPORT_INNER_ERROR("E19999", "The data node %s has switchn node flag, but the value is empty", | |||
data_node->GetName().c_str()); | |||
GELOGE(INTERNAL_ERROR, "[Check][Param] The data node %s has switchn node flag, but the value is empty", | |||
data_node->GetName().c_str()); | |||
return INTERNAL_ERROR; | |||
@@ -660,9 +659,8 @@ Status CheckIfDynamicBatchScene(NodePtr &data_node, bool &is_dynamic_batch, Node | |||
} | |||
if (mbatch_node == nullptr) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E15002", {"opname", "value", "reason"}, | |||
{data_node->GetName(), related_node_name, "but can not find it on the graph"}); | |||
REPORT_INNER_ERROR("E19999", "The data node %s has switchn node %s, but can not find it on the graph", | |||
data_node->GetName().c_str(), related_node_name.c_str()); | |||
GELOGE(INTERNAL_ERROR, "[Check][Param] The data node %s has switchn node %s, but can not find it on the graph", | |||
data_node->GetName().c_str(), related_node_name.c_str()); | |||
return INTERNAL_ERROR; | |||
@@ -836,10 +834,10 @@ Status ProcessInputNC1HWC0DynShape(NodePtr &node_ptr, bool &is_dynamic_batch, No | |||
ge::GeShape old_shape = input->GetShape(); | |||
bool support = ((old_format == FORMAT_NC1HWC0) || (old_format == FORMAT_NCHW) || (old_format == FORMAT_NHWC)); | |||
if (!support) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E19014", {"opname", "value", "reason"}, | |||
{op_desc->GetName(), "format[" + TypeUtils::FormatToSerialString(old_format) + "]", | |||
"only support FORMAT_NC1HWC0,FORMAT_NCHW,FORMAT_NHWC"}); | |||
REPORT_INNER_ERROR("E19999", | |||
"The format:%s of op:%s(%s) is unsupported, only support FORMAT_NC1HWC0,FORMAT_NCHW,FORMAT_NHWC", | |||
TypeUtils::FormatToSerialString(old_format).c_str(), | |||
op_desc->GetName().c_str(), op_desc->GetType().c_str()); | |||
GELOGE(INTERNAL_ERROR, "[Check][Param] The format [%s] is unsupported, op:%s", | |||
TypeUtils::FormatToSerialString(old_format).c_str(), op_desc->GetName().c_str()); | |||
return FAILED; | |||
@@ -1086,10 +1084,9 @@ Status ProcessNetoutputNodeDynShape(NodePtr &node) { | |||
// check if is_output_adjust_hw_layout is set | |||
if (NeedUpdateFormatByOutputTypeParm(op_desc, index)) { | |||
if ((old_format != FORMAT_NCHW) && (old_format != FORMAT_NHWC) && (old_format != FORMAT_NC1HWC0)) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E19014", {"opname", "value", "reason"}, | |||
{op_desc->GetName(), "format[" + TypeUtils::FormatToSerialString(old_format) + "]", | |||
"only support FORMAT_NC1HWC0,FORMAT_NCHW,FORMAT_NHWC"}); | |||
REPORT_INNER_ERROR("E19999", "Format:%s of op:%s(%s) is not one of NCHW, NHWC, NC1HWC0.", | |||
TypeUtils::FormatToSerialString(old_format).c_str(), | |||
op_desc->GetName().c_str(), op_desc->GetType().c_str()); | |||
GELOGE(INTERNAL_ERROR, "[Check][Param] Format is not one of NCHW, NHWC, NC1HWC0."); | |||
return FAILED; | |||
} | |||
@@ -1329,9 +1326,9 @@ Status GraphPrepare::CheckRefInputNode(const NodePtr &node, const std::string &i | |||
} | |||
bool is_acceptable = (acceptable_types.find(input_type) != acceptable_types.end()); | |||
if (!is_acceptable) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E15005", {"opname", "optype", "opname1", "optype1"}, | |||
{op_desc->GetName(), node->GetType(), input_op_desc->GetName(), input_op_desc->GetType()}); | |||
REPORT_INNER_ERROR("E19999", "The ref input of ref node %s[%s] must be ref node or variable, but %s[%s]isn't.", | |||
node->GetName().c_str(), node->GetType().c_str(), input_op_desc->GetName().c_str(), | |||
input_op_desc->GetType().c_str()); | |||
GELOGE(PARAM_INVALID, "[Check][Param] The ref input of ref node %s[%s] must be ref node or variable, " | |||
"but %s[%s]isn't.", node->GetName().c_str(), node->GetType().c_str(), input_op_desc->GetName().c_str(), | |||
input_op_desc->GetType().c_str()); | |||
@@ -1406,8 +1403,8 @@ Status GraphPrepare::AdjustDataOpOutput(const NodePtr &node) { | |||
int64_t tensor_size = 0; | |||
graphStatus graph_status = TensorUtils::GetTensorMemorySizeInBytes(output, tensor_size); | |||
if (graph_status != GRAPH_SUCCESS) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E19012", {"function", "reason"}, {"GetTensorMemorySizeInBytes", "opname is " + node->GetName()}); | |||
REPORT_CALL_ERROR("E19999", "GetTensorMemorySize by ouput index:0 of op:%s(%s) failed", | |||
op_desc_ptr->GetName().c_str(), op_desc_ptr->GetType().c_str()); | |||
GELOGE(graph_status, "[Call][GetTensorMemorySizeInBytes] failed, op:%s", node->GetName().c_str()); | |||
return FAILED; | |||
} | |||
@@ -1430,10 +1427,10 @@ Status GraphPrepare::CheckInternalFormat(const NodePtr &input_node, const GeTens | |||
if (need_check_internal_format) { | |||
bool is_internal = TypeUtils::IsInternalFormat(format) || TypeUtils::IsInternalFormat(origin_format); | |||
if (is_internal) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19025", {"situation", "reason"}, {"Input format[" + | |||
TypeUtils::FormatToSerialString(format) + "] or origin_format[" + | |||
TypeUtils::FormatToSerialString(origin_format) + "]", | |||
"it is not support"}); | |||
std::string reason = "Input format[" + TypeUtils::FormatToSerialString(format) + "] or origin_format[" + | |||
TypeUtils::FormatToSerialString(origin_format) + "] of op:" + input_node->GetName() + | |||
" is not support"; | |||
REPORT_INPUT_ERROR("E19025", std::vector<std::string>({"reason"}), std::vector<std::string>({reason})); | |||
GELOGE(PARAM_INVALID, "[Check][Param] Input format %s or origin_format %s is not support.", | |||
TypeUtils::FormatToSerialString(format).c_str(), TypeUtils::FormatToSerialString(origin_format).c_str()); | |||
return FAILED; | |||
@@ -1461,9 +1458,9 @@ Status GraphPrepare::UpdateInput(const std::vector<GeTensor> &user_input, | |||
} | |||
if ((index < 0) || (static_cast<size_t>(index) >= user_input.size())) { | |||
std::string situation = "data op index[" + std::to_string(index) + "]"; | |||
std::string reason = "it must less than user_input size[" + std::to_string(user_input.size()) + "]"; | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19025", {"situation", "reason"}, {situation, reason}); | |||
std::string reason = "exist data op:" + input_node->GetName() + " index " + std::to_string(index) + | |||
" bigger than input tensor size[" + std::to_string(user_input.size()) + "], check invalid"; | |||
REPORT_INPUT_ERROR("E19025", std::vector<std::string>({"reason"}), std::vector<std::string>({reason})); | |||
GELOGE(PARAM_INVALID, "[Check][Param] user_input size = %zu, graph data op index = %ld.", | |||
user_input.size(), index); | |||
return FAILED; | |||
@@ -1484,8 +1481,9 @@ Status GraphPrepare::UpdateInput(const std::vector<GeTensor> &user_input, | |||
uint32_t length = 1; | |||
bool type_ret = TypeUtils::GetDataTypeLength(data_type, length); | |||
if (!type_ret) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19025", {"situation", "reason"}, | |||
{"Input datatype[" + TypeUtils::DataTypeToSerialString(data_type) + "]", "it is not support"}); | |||
std::string reason = "Input datatype[" + TypeUtils::DataTypeToSerialString(data_type) + "] of index:" + | |||
std::to_string(index) + " input tensor is not support"; | |||
REPORT_INPUT_ERROR("E19025", std::vector<std::string>({"reason"}), std::vector<std::string>({reason})); | |||
GELOGE(PARAM_INVALID, "[Check][Param] Input datatype %s is not support.", | |||
TypeUtils::DataTypeToSerialString(data_type).c_str()); | |||
return FAILED; | |||
@@ -1501,10 +1499,9 @@ Status GraphPrepare::UpdateInput(const std::vector<GeTensor> &user_input, | |||
return FAILED); | |||
bool size_check = (size != 0 && shape_size != size); | |||
if (size_check) { | |||
std::string situation = "input data size[" + std::to_string(size) + | |||
"] and shape_size[" + std::to_string(size) + "]"; | |||
std::string reason = "because size != 0 and shape_size != size"; | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19025", {"situation", "reason"}, {situation, reason}); | |||
std::string reason = "input tensor[index:" + std::to_string(index) + "]'s data size[" + std::to_string(size) + | |||
"] != shape_size[" + std::to_string(size) + "], check invalid"; | |||
REPORT_INPUT_ERROR("E19025", std::vector<std::string>({"reason"}), std::vector<std::string>({reason})); | |||
GELOGE(PARAM_INVALID, "[Check][Param] input data size = %ld, shape_size = %ld.", size, shape_size); | |||
return FAILED; | |||
} | |||
@@ -1884,8 +1881,8 @@ Status GraphPrepare::VerifyConstOp(const NodePtr &node) { | |||
uint32_t length = 1; | |||
bool type_ret = TypeUtils::GetDataTypeLength(data_type, length); | |||
if (!type_ret) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19025", {"situation", "reason"}, | |||
{"Input datatype[" + TypeUtils::DataTypeToSerialString(data_type) + "]", "it is not support"}); | |||
REPORT_INNER_ERROR("E19999", "const node:%s's input datatype:%s it is not support", | |||
node->GetName().c_str(), TypeUtils::DataTypeToSerialString(data_type).c_str()); | |||
GELOGE(PARAM_INVALID, "[Check][Param] Input datatype %s is not support.", | |||
TypeUtils::DataTypeToSerialString(data_type).c_str()); | |||
return FAILED; | |||
@@ -1897,19 +1894,22 @@ Status GraphPrepare::VerifyConstOp(const NodePtr &node) { | |||
if (ge_tensor_desc.GetShape().GetDims().size() == 0) { | |||
// shape = [], means it's a sclar tensor. | |||
GE_CHK_BOOL_EXEC(data_size / length == 1, | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10043", {"reason"}, {"Const is invalid scalar tensor."}); | |||
REPORT_INNER_ERROR("E19999", "Const Node:%s is invalid, data size:%zu not equal to tensor size:%u", | |||
node->GetName().c_str(), data_size, length); | |||
return PARAM_INVALID, "[Check][Param] Const is invalid scalar tensor."); | |||
} else { | |||
// shape = [x, y, 0,...], means it's a vector tensor that value is []. | |||
GE_CHK_BOOL_EXEC(data_size == 0, | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10043", {"reason"}, {"Const is invalid vector scalar."}); | |||
REPORT_INNER_ERROR("E19999", "Const Node:%s is invalid, data size:%zu not equal to tensor size:0", | |||
node->GetName().c_str(), data_size); | |||
return PARAM_INVALID, "[Check][Param] Const is invalid vector scalar."); | |||
} | |||
} else { | |||
GE_CHK_BOOL_EXEC(data_size == static_cast<size_t>(shape_size * length) && data_size != 0, | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E10043", {"reason"}, {"Const input data size is not equal with tensor desc shape"}); | |||
return PARAM_INVALID, "[Check][Param] Const input data size is not equal with tensor desc shape"); | |||
GE_CHK_BOOL_EXEC( | |||
data_size == static_cast<size_t>(shape_size * length) && data_size != 0, | |||
REPORT_INNER_ERROR("E19999", "Const Node:%s is invalid, data size:%zu not equal to tensor size:%ld", | |||
node->GetName().c_str(), data_size, shape_size * length); | |||
return PARAM_INVALID, "[Check][Param] Const input data size is not equal with tensor desc shape"); | |||
} | |||
return SUCCESS; | |||
} | |||
@@ -1952,9 +1952,9 @@ Status GraphPrepare::CheckUserInput(const std::vector<GeTensor> &user_input) { | |||
return GE_GRAPH_INIT_FAILED; | |||
} | |||
if ((index < 0) || (static_cast<size_t>(index) >= user_input.size())) { | |||
std::string situation = "data op index[" + std::to_string(index) + "]"; | |||
std::string reason = "it must less than user_input size[" + std::to_string(user_input.size()) + "]"; | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19025", {"situation", "reason"}, {situation, reason}); | |||
std::string reason = "exist data op:" + input_node->GetName() + " index " + std::to_string(index) + | |||
" bigger than input tensor size[" + std::to_string(user_input.size()) + "], check invalid"; | |||
REPORT_INPUT_ERROR("E19025", std::vector<std::string>({"reason"}), std::vector<std::string>({reason})); | |||
GELOGE(GE_GRAPH_INIT_FAILED, "[Check][Param] user_input size:%zu must larger than data op index:%ld.", | |||
user_input.size(), index); | |||
return GE_GRAPH_INIT_FAILED; | |||
@@ -1967,10 +1967,10 @@ Status GraphPrepare::CheckUserInput(const std::vector<GeTensor> &user_input) { | |||
for (size_t i = 0; i < desc.GetShape().GetDimNum(); ++i) { | |||
int64_t dim = desc.GetShape().GetDim(i); | |||
if (dim < UNKNOWN_DIM_NUM) { | |||
std::string situation = "data dim[" + std::to_string(i) + "][" + std::to_string(dim) + "]" ; | |||
std::string reason = "it need >= -2"; | |||
std::string reason = "data dim[" + std::to_string(i) + "][" + std::to_string(dim) + "] of index:" + | |||
std::to_string(index) + " input tensor it need >= -2"; | |||
REPORT_INPUT_ERROR( | |||
"E19025", std::vector<std::string>({"situation", "reason"}), std::vector<std::string>({situation, reason})); | |||
"E19025", std::vector<std::string>({"reason"}), std::vector<std::string>({reason})); | |||
GELOGE(GE_GRAPH_INIT_FAILED, "[Check][InputDim]data dim %zu is not supported, need >= -2, real:%ld.", i, dim); | |||
return GE_GRAPH_INIT_FAILED; | |||
} | |||
@@ -114,8 +114,9 @@ Status GetDataDimN(const ge::NodePtr &data_node, ge::Format format, int64_t &bat | |||
std::vector<std::string>({ | |||
data_node->GetName() + " format", | |||
TypeUtils::FormatToSerialString(format), | |||
"only format " + TypeUtils::FormatToSerialString(FORMAT_NCHW) + " and " | |||
+ TypeUtils::FormatToSerialString(FORMAT_NHWC) + " supported"})); | |||
"only format " + TypeUtils::FormatToSerialString(FORMAT_NCHW) + " and "+ | |||
TypeUtils::FormatToSerialString(FORMAT_NHWC) + | |||
" supported which dynamic aipp is linked"})); | |||
GELOGE(PARAM_INVALID, "[Check][Param] Not support data format:%s, node:%s", | |||
TypeUtils::FormatToSerialString(format).c_str(), data_node->GetName().c_str()); | |||
return PARAM_INVALID; | |||
@@ -475,7 +476,7 @@ Status AippOp::ConvertRelatedInputNameToRank() { | |||
string error_msg = "Top name " + related_input_name + "convert rank failed, Please" | |||
" ensure top name in aipp config is the top name of data node."; | |||
GELOGE(PARAM_INVALID, "[Check][InputParam]%s", error_msg.c_str()); | |||
REPORT_INPUT_ERROR("E19021", std::vector<std::string>({"reason"}), std::vector<std::string>({error_msg})); | |||
REPORT_INPUT_ERROR("E10052", std::vector<std::string>({"reason"}), std::vector<std::string>({error_msg})); | |||
return PARAM_INVALID; | |||
} | |||
@@ -126,14 +126,14 @@ Status InsertNewOpUtil::CheckInputNamePositionNotRepeat() { | |||
string error_msg = "Can not both set related_input_name and related_input_rank!" | |||
" Please ensure param is the same with the first aipp config(related_input_name)."; | |||
GELOGE(PARAM_INVALID, "[Check][InputParam]%s", error_msg.c_str()); | |||
REPORT_INPUT_ERROR("E19021", std::vector<std::string>({"reason"}), std::vector<std::string>({error_msg})); | |||
REPORT_INPUT_ERROR("E10052", std::vector<std::string>({"reason"}), std::vector<std::string>({error_msg})); | |||
return PARAM_INVALID; | |||
} | |||
if (item->related_input_name() == another_item->related_input_name()) { | |||
string error_msg = "Can not insert aipp to the same postion! Please ensure related_input_name" | |||
" param is different in different aipp config."; | |||
GELOGE(PARAM_INVALID, "[Check][InputParam]%s", error_msg.c_str()); | |||
REPORT_INPUT_ERROR("E19021", std::vector<std::string>({"reason"}), std::vector<std::string>({error_msg})); | |||
REPORT_INPUT_ERROR("E10052", std::vector<std::string>({"reason"}), std::vector<std::string>({error_msg})); | |||
return PARAM_INVALID; | |||
} | |||
} | |||
@@ -154,14 +154,14 @@ Status InsertNewOpUtil::CheckInputRankPositionNoRepeat() { | |||
string error_msg = "Can not both set related_input_rank and related_input_name!" | |||
" Please ensure param is the same with the first aipp config(related_input_rank)."; | |||
GELOGE(PARAM_INVALID, "[Check][InputParam]%s", error_msg.c_str()); | |||
REPORT_INPUT_ERROR("E19021", std::vector<std::string>({"reason"}), std::vector<std::string>({error_msg})); | |||
REPORT_INPUT_ERROR("E10052", std::vector<std::string>({"reason"}), std::vector<std::string>({error_msg})); | |||
return PARAM_INVALID; | |||
} | |||
if (item->related_input_rank() == another_item->related_input_rank()) { | |||
string error_msg = "Can not insert aipp to the same postion! Please ensure related_input_rank" | |||
" param is different in different aipp config."; | |||
GELOGE(PARAM_INVALID, "[Check][InputParam]%s", error_msg.c_str()); | |||
REPORT_INPUT_ERROR("E19021", std::vector<std::string>({"reason"}), std::vector<std::string>({error_msg})); | |||
REPORT_INPUT_ERROR("E10052", std::vector<std::string>({"reason"}), std::vector<std::string>({error_msg})); | |||
return PARAM_INVALID; | |||
} | |||
} | |||
@@ -764,8 +764,8 @@ Status MultiBatchGraphCopyer::CheckAndParseDynamicData(){ | |||
data_name.c_str()); return PARAM_INVALID); | |||
} else if (dynamic_type_ == DynamicType::kDynamicDims) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10001", | |||
{"parameter", "reason"}, | |||
{"--input_shape", | |||
{"parameter", "value" "reason"}, | |||
{"--dynamic_dims", data_name, | |||
"all dynamic data must be set in --input_shape"}); | |||
GELOGE(INTERNAL_ERROR, "[Check][Param] data:%s shape:%s must be set int --input_shape", | |||
node->GetName().c_str(), data_shape.ToString().c_str()); | |||
@@ -1205,8 +1205,8 @@ Status MultiBatchGraphCopyer::CheckCopyResult(const std::vector<NodePtr> &start_ | |||
} | |||
auto dims = NodeUtils::GetOutputDesc(*node, kDataOutIndex).GetShape().GetDims(); | |||
if (!IsAllDimsPositive(dims)) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E15004", {"opname", "shape"}, | |||
{node->GetName(), formats::ShapeToString(dims)}); | |||
REPORT_CALL_ERROR("E19999", "Failed to copy multi batch graph, the node %s still has unknown shape %s", | |||
node->GetName().c_str(), formats::ShapeToString(dims).c_str()); | |||
GELOGE(INTERNAL_ERROR, "[Check][Param] Failed to copy multi batch graph, the node %s still has unknown shape %s", | |||
node->GetName().c_str(), formats::ShapeToString(dims).c_str()); | |||
return INTERNAL_ERROR; | |||
@@ -550,10 +550,8 @@ Status CalcShape(const std::vector<int64_t> &batch_shape, GeShape &data_shape) { | |||
for (size_t i = 0; i < data_shape.GetDimNum(); ++i) { | |||
if (data_shape.GetDim(i) < 0) { | |||
if (batch_shape_index >= batch_shape.size()) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E19012", {"function", "reason"}, | |||
{"CalcShape", "the batch shape count " + std::to_string(batch_shape.size()) + | |||
" does not match the data shape " + data_shape.ToString()}); | |||
REPORT_INNER_ERROR("E19999", "the batch shape count %zu, does not match the data shape %s", | |||
batch_shape.size(), data_shape.ToString().c_str()); | |||
GELOGE(PARAM_INVALID, "[Check][Param] Failed to calc tensor shape, the batch shape count %zu, " | |||
"does not match the data shape %s", batch_shape.size(), data_shape.ToString().c_str()); | |||
return PARAM_INVALID; | |||
@@ -563,9 +561,8 @@ Status CalcShape(const std::vector<int64_t> &batch_shape, GeShape &data_shape) { | |||
} | |||
GELOGI("CalcShape size of batch_shape is %zu, batch_shape_index is %zu.", batch_shape.size(), batch_shape_index); | |||
if (batch_shape_index != batch_shape.size()) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E19012", {"function", "reason"}, {"CalcShape", "the batch shape count " + std::to_string(batch_shape.size()) + | |||
" does not match the data shape " + data_shape.ToString()}); | |||
REPORT_INNER_ERROR("E19999", "the batch shape count %zu, does not match the data shape %s", | |||
batch_shape.size(), data_shape.ToString().c_str()); | |||
GELOGE(PARAM_INVALID, "[Check][Param] Failed to calc tensor shape, the batch shape count %zu, " | |||
"does not match the data shape %s", batch_shape.size(), data_shape.ToString().c_str()); | |||
return PARAM_INVALID; | |||
@@ -27,7 +27,7 @@ namespace { | |||
const size_t kMaxOpsNum = 10; | |||
} // namespace | |||
void KeepDtypeReportError(const std::vector<std::string> &invalid_list) { | |||
void KeepDtypeReportError(const std::vector<std::string> &invalid_list, const std::string &cfg_path) { | |||
std::stringstream err_msg; | |||
size_t list_size = invalid_list.size(); | |||
err_msg << "config file contains " << list_size; | |||
@@ -48,8 +48,9 @@ void KeepDtypeReportError(const std::vector<std::string> &invalid_list) { | |||
} | |||
} | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E10042", {"parameter", "reason"}, {"keep_dtype", err_msg.str().c_str()}); | |||
REPORT_INPUT_ERROR( | |||
"E10003", std::vector<std::string>({"parameter", "value", "reason"}), | |||
std::vector<std::string>({"keep_dtype", cfg_path, err_msg.str()})); | |||
GELOGE(FAILED, "%s", err_msg.str().c_str()); | |||
} | |||
@@ -95,7 +96,7 @@ graphStatus KeepDtypeFunc(ComputeGraphPtr &graph, const std::string &cfg_path) { | |||
ifs.close(); | |||
if (!invalid_list.empty()) { | |||
KeepDtypeReportError(invalid_list); | |||
KeepDtypeReportError(invalid_list, cfg_path); | |||
return GRAPH_PARAM_INVALID; | |||
} | |||
@@ -890,8 +890,7 @@ static std::string AttrTypeToSerialString(aclgrphAttrType attr_type) { | |||
if (it != kAttrTypeToStringMap.end()) { | |||
return it->second; | |||
} else { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19012", {"function", "reason"}, | |||
{"AttrTypeToSerialString", "attr_type[" + std::to_string(attr_type) + "] is not support"}); | |||
REPORT_INNER_ERROR("E19999", "attr_type:%u is not support", attr_type); | |||
GELOGE(GRAPH_FAILED, "[Check][AclgrphAttrType] attr_type not support %u", attr_type); | |||
return "UNDEFINED"; | |||
} | |||
@@ -186,7 +186,8 @@ bool CheckDynamicBatchSizeInputShapeValid(map<string, vector<int64_t>> shape_map | |||
for (char c : dynamic_batch_size) { | |||
if (!isdigit(c) && (c != ',') && (c != ' ')) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E10033", {"value", "reason"}, {dynamic_batch_size, kDynamicBatchSizeError}); | |||
"E10003", {"parameter", "value", "reason"}, | |||
{"dynamic_batch_size", dynamic_batch_size, kDynamicBatchSizeError}); | |||
GELOGE(ge::PARAM_INVALID, "[Check][DynamicBatchSizeInputShape] --dynamic_batch_size:%s is invalid. reason: %s", | |||
dynamic_batch_size.c_str(), kDynamicBatchSizeError); | |||
return false; | |||
@@ -203,7 +204,8 @@ bool CheckDynamicImagesizeInputShapeValid(map<string, vector<int64_t>> shape_map | |||
if (!input_format.empty() && !ge::TypeUtils::IsFormatValid(input_format.c_str())) { | |||
GELOGE(ge::PARAM_INVALID, | |||
"[Check][DynamicImagesizeInputShape] input_format [%s] invalid, can not support now.", input_format.c_str()); | |||
REPORT_INPUT_ERROR("E10414", std::vector<std::string>({"input_format"}), std::vector<std::string>({input_format})); | |||
REPORT_INPUT_ERROR("E10003", std::vector<std::string>({"parameter","value","reason"}), | |||
std::vector<std::string>({"input_format", input_format, "this format is not support"})); | |||
return false; | |||
} | |||
int32_t size = 0; | |||
@@ -242,8 +244,8 @@ bool CheckDynamicImagesizeInputShapeValid(map<string, vector<int64_t>> shape_map | |||
bool is_char_valid = isdigit(c) || (c == ',') || (c == ' ') || (c == ';'); | |||
if (!is_char_valid) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E10001", {"parameter", "value", "reason"}, | |||
{"dynamic_image_size", dynamic_image_size.c_str(), kDynamicImageSizeError}); | |||
"E10003", {"parameter", "value", "reason"}, | |||
{"dynamic_image_size", dynamic_image_size, kDynamicImageSizeError}); | |||
GELOGE(ge::PARAM_INVALID, "[Check][DynamicImageSizeInputShape] --dynamic_image_size:%s is invalid. reason: %s", | |||
dynamic_image_size.c_str(), kDynamicImageSizeError); | |||
return false; | |||
@@ -256,7 +258,8 @@ bool CheckDynamicImagesizeInputShapeValid(map<string, vector<int64_t>> shape_map | |||
for (auto str : split_set) { | |||
split_dim = StringUtils::Split(str, ','); | |||
if (split_dim.size() != static_cast<size_t>(kDynamicImageSizeNum)) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10020"); | |||
REPORT_INPUT_ERROR("E10020", std::vector<std::string>({"dynamic_image_size"}), | |||
std::vector<std::string>({dynamic_image_size})); | |||
GELOGE(ge::PARAM_INVALID, | |||
"[Check][DynamicImagesizeInputShape] invalid value:%s number of dimensions of each group must be %ld.", | |||
dynamic_image_size.c_str(), kDynamicImageSizeNum); | |||
@@ -320,8 +323,9 @@ bool CheckAndParseDynamicDims(int32_t dynamic_dim_num, std::string &dynamic_dims | |||
// Different parameter sets are split by ';' | |||
vector<string> split_set = StringUtils::Split(dynamic_dims, ';'); | |||
if (split_set.size() > kMaxDynamicDimNum) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E10042", {"parameter", "reason"}, {"dynamic_dims", "dynamic_dims's num of parameter set can not exceed 100"}); | |||
REPORT_INPUT_ERROR( | |||
"E10036", std::vector<std::string>({"shapesize", "maxshapesize"}), | |||
std::vector<std::string>({std::to_string(split_set.size()), std::to_string(kMaxDynamicDimNum + 1)})); | |||
GELOGE(ge::PARAM_INVALID, | |||
"[CheckAndParse][DynamicDims]dynamic_dims's num of parameter set can not exceed %zu.", kMaxDynamicDimNum); | |||
return false; | |||
@@ -329,9 +333,10 @@ bool CheckAndParseDynamicDims(int32_t dynamic_dim_num, std::string &dynamic_dims | |||
for (auto split_dim : split_set) { | |||
vector<string> one_set = StringUtils::Split(split_dim, ','); | |||
if (one_set.size() != static_cast<size_t>(dynamic_dim_num)) { | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E10042", {"parameter", "reason"}, | |||
{"dynamic_dims", "Each gear setting needs to be consistent with the number of -1 in the inputshape"}); | |||
REPORT_INPUT_ERROR( | |||
"E10003", std::vector<std::string>({"parameter", "value", "reason"}), | |||
std::vector<std::string>({"dynamic_dims", dynamic_dims, | |||
"Each gear setting needs to be consistent with the number of -1 in the inputshape"})); | |||
GELOGE(ge::PARAM_INVALID, "[CheckAndParse][DynamicDims] --dynamic_dims:%s invalid. " | |||
"reason: Each gear setting needs to be consistent with the number of -1 in the inputshape.", | |||
dynamic_dims.c_str()); | |||
@@ -496,8 +501,7 @@ Status CheckDynamicInputParamValid(string &dynamic_batch_size, string &dynamic_i | |||
int32_t param_size = static_cast<int32_t>(!dynamic_batch_size.empty()) + | |||
static_cast<int32_t>(!dynamic_image_size.empty()) + static_cast<int32_t>(!dynamic_dims.empty()); | |||
if (param_size > 1) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10009", {"parameter0", "parameter1", "parameter2"}, | |||
{"dynamic_batch_size", "dynamic_image_size", "dynamic_dims"}); | |||
REPORT_INPUT_ERROR("E10009", std::vector<std::string>(), std::vector<std::string>()); | |||
GELOGE(ge::PARAM_INVALID, | |||
"[Parse][Parameter]dynamic_batch_size, dynamic_image_size and dynamic_dims can only be set one"); | |||
return ge::PARAM_INVALID; | |||
@@ -608,17 +612,17 @@ bool ParseInputShape(const string &input_shape, map<string, vector<int64_t>> &sh | |||
} 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()); | |||
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()); | |||
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()); | |||
GELOGW("Input parameter[--input_shape]'s value[%s] cause unkown execption!", shape_value_str.c_str()); | |||
return false; | |||
} | |||
int64_t result = left_result; | |||
@@ -627,7 +631,7 @@ bool ParseInputShape(const string &input_shape, map<string, vector<int64_t>> &sh | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10011", {"shape", "result"}, | |||
{shape, std::to_string(result)}); | |||
GELOGW( | |||
"Input parameter[--input_shape]’s shape value[%s] is invalid, " | |||
"Input parameter[--input_shape]'s shape value[%s] is invalid, " | |||
"expect positive integer, but value is %ld.", | |||
shape.c_str(), result); | |||
return false; | |||
@@ -725,13 +729,10 @@ int CheckLogParamValidAndSetLogLevel(const std::string log) { | |||
} else { | |||
GELOGE(ge::PARAM_INVALID, | |||
"[Check][LogParam]log:%s invalid, only support debug, info, warning, error, null", log.c_str()); | |||
REPORT_INPUT_ERROR("E10417", std::vector<std::string>({"loglevel"}), std::vector<std::string>({log})); | |||
return ret; | |||
} | |||
if (ret != 0) { | |||
GELOGE(ge::PARAM_INVALID, "[Set][LogLevel] fail, level:%s.", log.c_str()); | |||
REPORT_INPUT_ERROR("E10417", std::vector<std::string>({"loglevel"}), std::vector<std::string>({log})); | |||
} | |||
return ret; | |||
} | |||
@@ -747,7 +748,8 @@ Status CheckInsertOpConfParamValid(const std::string insert_op_conf) { | |||
Status CheckDisableReuseMemoryParamValid(const std::string disable_reuse_memory) { | |||
if ((disable_reuse_memory != "") && (disable_reuse_memory != "0") && (disable_reuse_memory != "1")) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10006", {"parameter"}, {"disable_reuse_memory"}); | |||
REPORT_INPUT_ERROR("E10006", std::vector<std::string>({"parameter", "value"}), | |||
std::vector<std::string>({"disable_reuse_memory", disable_reuse_memory})); | |||
GELOGE(ge::PARAM_INVALID, "[Check][DisableReuseMemory]disable_reuse_memory must be 1 or 0."); | |||
return ge::PARAM_INVALID; | |||
} | |||
@@ -67,7 +67,7 @@ static bool is_dynamic_input = false; | |||
const char *const kModeSupport = "only support 0(model to framework model), " | |||
"1(framework model to json), 3(only pre-check), " | |||
"5(pbtxt to json), 6(display model info)"; | |||
const char *const kModelToJsonSupport = "only support 0(Caffe) 3(TensorFlow) 5(Onnx)"; | |||
const char *const kModelToJsonSupport = "only support 0(Caffe) 3(TensorFlow) 5(Onnx) when model set 1"; | |||
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"; | |||
const char *const kONNXFormatSupport = "only support NCHW, ND, NCDHW in ONNX model"; | |||
@@ -102,14 +102,6 @@ DEFINE_int32(mode, 0, | |||
"Optional; run mode, 0(default): model => framework model; 1: " | |||
"framework model => json; 3: only pre-check; 5: txt => json."); | |||
#if !defined(__ANDROID__) && !defined(ANDROID) | |||
DEFINE_int32(encrypt_mode, -1, "Optional; the encrypt flag. 0: encrypt; -1(default): not encrypt"); | |||
DEFINE_string(encrypt_key, "", "Optional; the encrypt_key file."); | |||
DEFINE_string(certificate, "", "Optional; the certificate file."); | |||
DEFINE_string(hardware_key, "", "Optional; the ISV key file."); | |||
DEFINE_string(private_key, "", "Optional; the private key file."); | |||
#endif | |||
DEFINE_string(out_nodes, "", | |||
"Optional; output nodes designated by users." | |||
"Format: \"node_name1:0;node_name1:1;node_name2:0\""); | |||
@@ -405,29 +397,6 @@ class GFlagUtils { | |||
"dynamic dims function does not support aipp"}); | |||
ret = ge::FAILED, "[Check][Param]dynamic dims function does not support aipp"); | |||
#if !defined(__ANDROID__) && !defined(ANDROID) | |||
GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(!CheckEncryptModeValid(FLAGS_encrypt_mode), ret = ge::FAILED, | |||
"[Check][EncryptMode]value %d not valid!!", FLAGS_encrypt_mode); | |||
if (FLAGS_encrypt_mode == 0) { // Encryption mode | |||
GELOGI("ge will run with encrypt!"); | |||
GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(!ge::CheckInputPathValid(FLAGS_encrypt_key), ret = ge::FAILED, | |||
"[Check][InputPath]encrypt_key file not found!!"); | |||
GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(!ge::CheckInputPathValid(FLAGS_certificate), ret = ge::FAILED, | |||
"[Check][InputPath]certificate file not found!!"); | |||
GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(!ge::CheckInputPathValid(FLAGS_hardware_key), ret = ge::FAILED, | |||
"[Check][InputPath]hardware_key file not found!!"); | |||
GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(!ge::CheckInputPathValid(FLAGS_private_key), ret = ge::FAILED, | |||
"[Check][InputPath]private_key file not found!!"); | |||
} else { // No encryption | |||
GELOGI("ge will run without encrypt!"); | |||
} | |||
#endif | |||
/** | |||
* Check the validity of the I / O file path | |||
*/ | |||
@@ -486,7 +455,8 @@ class GFlagUtils { | |||
ret = ge::FAILED, "[Check][EnableSingleStream]failed!"); | |||
GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((FLAGS_display_model_info != "0") && (FLAGS_display_model_info != "1"), | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10006", {"parameter"}, {"display_model_info"}); | |||
REPORT_INPUT_ERROR("E10006", std::vector<std::string>({"parameter", "value"}), | |||
std::vector<std::string>({"display_model_info", FLAGS_display_model_info})); | |||
ret = ge::FAILED, "[Check][Parameter]Input parameter[--display_model_info]'s value must be 1 or 0."); | |||
return ret; | |||
@@ -917,7 +887,8 @@ static Status ConvertModelToJson(int fwk_type, const string &model_file, const s | |||
} | |||
if (FLAGS_dump_mode != "0" && FLAGS_dump_mode != "1") { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10006", {"parameter"}, {"dump_mode"}); | |||
REPORT_INPUT_ERROR("E10006", std::vector<std::string>({"parameter", "value"}), | |||
std::vector<std::string>({"dump_mode", FLAGS_dump_mode})); | |||
GELOGE(ge::FAILED, "[Convert][ModelToJson] Input parameter[--dump_mode]'s value must be 1 or 0."); | |||
ret = ge::FAILED; | |||
} | |||
@@ -982,7 +953,8 @@ domi::Status GenerateModel(std::map<string, string> &options, std::string output | |||
ge::Model load_model = ge::Model("loadmodel", "version2"); | |||
auto ret1 = load_model.LoadFromFile(FLAGS_model); | |||
if (ret1 != ge::GRAPH_SUCCESS) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10041", {"parameter"}, {FLAGS_model}); | |||
REPORT_INPUT_ERROR("E10041", std::vector<std::string>({"file"}), std::vector<std::string>({FLAGS_model})); | |||
REPORT_CALL_ERROR("E19999", "load from model file:%s failed", FLAGS_model.c_str()); | |||
DOMI_LOGE("Load model from %s failed, please check model file or " | |||
"input parameter[--framework] is correct", FLAGS_model.c_str()); | |||
(void)ge_generator.Finalize(); | |||
@@ -1186,11 +1158,6 @@ domi::Status GenerateOmModel() { | |||
options.insert(std::pair<string, string>(string(ge::FRAMEWORK_TYPE), to_string(FLAGS_framework))); | |||
options.insert(std::pair<string, string>(string(ge::STREAM_NUM), to_string(f_stream_num))); | |||
options.insert(std::pair<string, string>(string(ge::CALIBRATION_CONF_FILE), FLAGS_cal_conf)); | |||
options.insert(std::pair<string, string>(string(ge::ENCRYPT_MODE), to_string(FLAGS_encrypt_mode))); | |||
options.insert(std::pair<string, string>(string(ge::EK_FILE), FLAGS_encrypt_key)); | |||
options.insert(std::pair<string, string>(string(ge::CERT_FILE), FLAGS_certificate)); | |||
options.insert(std::pair<string, string>(string(ge::HW_KEY_FILE), FLAGS_hardware_key)); | |||
options.insert(std::pair<string, string>(string(ge::PRIVATE_KEY_FILE), FLAGS_private_key)); | |||
options.insert(std::pair<string, string>(string(ge::OUTPUT_NODE_NAME), FLAGS_out_nodes)); | |||
options.insert(std::pair<string, string>(string(ge::INSERT_OP_FILE), FLAGS_insert_op_conf)); | |||
options.insert(std::pair<string, string>(string(ge::PRECISION_MODE), FLAGS_precision_mode)); | |||
@@ -329,7 +329,7 @@ Status SingleOpParser::ReadJsonFile(const std::string &file, Json &json_obj) { | |||
ifs >> json_obj; | |||
} catch (const std::exception &e) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10025", {"realpath", "errmsg"}, {real_path, e.what()}); | |||
GELOGE(PARAM_INVALID, | |||
GELOGE(PARAM_INVALID, | |||
"[Parse][JsonFile] fail for file[%s] provided in input parameter[--singleop], exception = %s.", | |||
real_path.c_str(), e.what()); | |||
return PARAM_INVALID; | |||
@@ -349,16 +349,16 @@ bool SingleOpParser::Validate(const SingleOpDesc &op_desc) { | |||
int index = 0; | |||
for (auto &tensor_desc : op_desc.input_desc) { | |||
if (!tensor_desc.GetValidFlag()) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10027", {"input", "type", "index"}, | |||
{"intput", "datatype or format", std::to_string(index)}); | |||
GELOGE(PARAM_INVALID, | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10027", {"op_name", "input", "type", "index"}, | |||
{op_desc.op, "input", "tensor", std::to_string(index)}); | |||
GELOGE(PARAM_INVALID, | |||
"[Check][Param] fail for Input's dataType or format is invalid when the index is %d", index); | |||
return false; | |||
} | |||
if ((tensor_desc.type == DT_UNDEFINED && tensor_desc.format != FORMAT_RESERVED) || | |||
(tensor_desc.type != DT_UNDEFINED && tensor_desc.format == FORMAT_RESERVED)){ | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10027", {"input", "type", "index"}, | |||
{"intput", "datatype or format", std::to_string(index)}); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10027", {"op_name", "input", "type", "index"}, | |||
{op_desc.op, "input", "datatype or format", std::to_string(index)}); | |||
GELOGE(PARAM_INVALID, "[Check][Param]Input's dataType or format is invalid when the index is %d", index); | |||
return false; | |||
} | |||
@@ -368,21 +368,21 @@ bool SingleOpParser::Validate(const SingleOpDesc &op_desc) { | |||
index = 0; | |||
for (auto &tensor_desc : op_desc.output_desc) { | |||
if (!tensor_desc.GetValidFlag()) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10027", {"input", "type", "index"}, | |||
{"output", "datatype", std::to_string(index)}); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10027", {"op_name", "input", "type", "index"}, | |||
{op_desc.op, "output", "tensor", std::to_string(index)}); | |||
GELOGE(PARAM_INVALID, "[Check][Param]fail for Output's dataType is invalid when the index is %d", index); | |||
return false; | |||
} | |||
if (tensor_desc.type == DT_UNDEFINED) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10027", {"input", "type", "index"}, | |||
{"output", "datatype", std::to_string(index)}); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10027", {"op_name", "input", "type", "index"}, | |||
{op_desc.op, "output", "datatype", std::to_string(index)}); | |||
GELOGE(PARAM_INVALID, "[Check][Param]Output's dataType is invalid when the index is %d", index); | |||
return false; | |||
} | |||
if (tensor_desc.format == FORMAT_RESERVED) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10027", {"input", "type", "index"}, | |||
{"output", "format", std::to_string(index)}); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10027", {"op_name", "input", "type", "index"}, | |||
{op_desc.op, "output", "format", std::to_string(index)}); | |||
GELOGE(PARAM_INVALID, "[Check][Param]Output's format is invalid when the index is %d", index); | |||
return false; | |||
} | |||
@@ -391,13 +391,13 @@ bool SingleOpParser::Validate(const SingleOpDesc &op_desc) { | |||
for (auto &attr : op_desc.attrs) { | |||
if (attr.name.empty()) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10029"); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10029", {"op_name"}, {op_desc.op}); | |||
GELOGE(PARAM_INVALID, "[Parse][Attr]attr name is empty"); | |||
return false; | |||
} | |||
if (attr.value.IsEmpty()) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10030", {"attrname"}, {attr.name}); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10030", {"op_name", "attrname"}, {op_desc.op, attr.name}); | |||
GELOGE(PARAM_INVALID, "[Parse][Attr] fail for vale of attr name:\"%s\" is empty. ", attr.name.c_str()); | |||
return false; | |||
} | |||
@@ -498,7 +498,7 @@ Status SingleOpParser::VerifyOpInputOutputSizeByIr(const OpDesc ¤t_op_desc | |||
string reason = "is smaller than the ir needed input size " + std::to_string(ir_opdesc_inputs_num); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19014", {"opname", "value", "reason"}, | |||
{current_op_desc.GetName(), "input size " + std::to_string(current_opdesc_inputs_num), reason}); | |||
GELOGE(PARAM_INVALID, | |||
GELOGE(PARAM_INVALID, | |||
"[Verify][OpInputOutputSize]This op:%s input size %zu is smaller than the ir needed input size %zu", | |||
current_op_desc.GetName().c_str(), current_opdesc_inputs_num, ir_opdesc_inputs_num); | |||
return PARAM_INVALID; | |||
@@ -509,7 +509,7 @@ Status SingleOpParser::VerifyOpInputOutputSizeByIr(const OpDesc ¤t_op_desc | |||
string reason = "is smaller than the ir needed output size " + std::to_string(ir_opdesc_outputs_num); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19014", {"opname", "value", "reason"}, | |||
{current_op_desc.GetName(), "output size " + std::to_string(current_opdesc_outputs_num), reason}); | |||
GELOGE(PARAM_INVALID, | |||
GELOGE(PARAM_INVALID, | |||
"[Verify][OpInputOutputSize]This op:%s output size %zu is smaller than the ir needed output size %zu", | |||
current_op_desc.GetName().c_str(), current_opdesc_outputs_num, ir_opdesc_outputs_num); | |||
return PARAM_INVALID; | |||
@@ -530,7 +530,7 @@ Status SingleOpParser::SetShapeRange(const std::string &op_name, | |||
{op_name, | |||
"shape", | |||
"has unknown rank but dim size is not one"}); | |||
GELOGE(PARAM_INVALID, "[Set][ShapeRange]Invalid tensor shape:%s.", | |||
GELOGE(PARAM_INVALID, "[Set][ShapeRange]Invalid tensor shape:%s.", | |||
ge_tensor_desc.MutableShape().ToString().c_str()); | |||
return PARAM_INVALID; | |||
} | |||
@@ -572,7 +572,7 @@ Status SingleOpParser::SetShapeRange(const std::string &op_name, | |||
{op_name, | |||
"shape range " + std::to_string(range_index), | |||
reason}); | |||
GELOGE(PARAM_INVALID, "[Set][ShapeRange]Invalid shape range entry. index = %zu, size = %zu", | |||
GELOGE(PARAM_INVALID, "[Set][ShapeRange]Invalid shape range entry. index = %zu, size = %zu", | |||
range_index, range.size()); | |||
return PARAM_INVALID; | |||
} | |||
@@ -628,7 +628,7 @@ Status SingleOpParser::ParseSingleOpList(const std::string &file, std::vector<Si | |||
} | |||
if (!Validate(single_op_desc)) { | |||
GELOGE(PARAM_INVALID, | |||
GELOGE(PARAM_INVALID, | |||
"[Check][OpDesc]Validate the index[%d] of op failed when read json file[%s].", index, file.c_str()); | |||
return PARAM_INVALID; | |||
} | |||
@@ -645,8 +645,8 @@ Status SingleOpParser::ParseSingleOpList(const std::string &file, std::vector<Si | |||
index += 1; | |||
} | |||
} catch (const nlohmann::json::exception &e) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10032", {"index", "jsonfile", "exception"}, | |||
{std::to_string(index), file, e.what()}); | |||
REPORT_INNER_ERROR("E19999", "parse singleop file:%s failed, catch exception:%s, current index:%d", | |||
file.c_str(), e.what(), index); | |||
GELOGE(PARAM_INVALID, "[Parse][OpList] the index:%d of op failed when read json file:%s, exception:%s", | |||
index, file.c_str(), e.what()); | |||
return PARAM_INVALID; | |||
@@ -627,7 +627,7 @@ Status ParseOutNodes(const string &out_nodes) { | |||
// 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"}); | |||
{"--out_nodes", out_nodes, "index is not positive integer"}); | |||
GELOGE(PARAM_INVALID, "[Parse][Param]This str must be digit string, while the actual input is %s", | |||
out_nodes.c_str()); | |||
return PARAM_INVALID; | |||
@@ -939,7 +939,7 @@ FMK_FUNC_HOST_VISIBILITY Status ConvertOm(const char *model_file, const char *js | |||
int32_t priority = 0; | |||
// Load model from file | |||
Status ret = ModelParserBase::LoadFromFile(model_file, "", priority, model); | |||
Status ret = ModelParserBase::LoadFromFile(model_file, priority, model); | |||
if (ret != SUCCESS) { | |||
REPORT_CALL_ERROR("E19999", "LoadFromFile failed, file:%s", model_file); | |||
GELOGE(ret, "[Invoke][LoadFromFile] failed."); | |||
@@ -955,7 +955,7 @@ FMK_FUNC_HOST_VISIBILITY Status ConvertOm(const char *model_file, const char *js | |||
OmFileLoadHelper omFileLoadHelper; | |||
ge::graphStatus status = omFileLoadHelper.Init(model_data, model_len); | |||
if (status != ge::GRAPH_SUCCESS) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"Om file init failed"}); | |||
REPORT_CALL_ERROR("E19999", "Om file:%s init failed", model_file); | |||
GELOGE(ge::FAILED, "[Invoke][Init]Om file init failed."); | |||
if (model.model_data != nullptr) { | |||
delete[] reinterpret_cast<char *>(model.model_data); | |||
@@ -967,7 +967,7 @@ FMK_FUNC_HOST_VISIBILITY Status ConvertOm(const char *model_file, const char *js | |||
ModelPartition ir_part; | |||
status = omFileLoadHelper.GetModelPartition(MODEL_DEF, ir_part); | |||
if (status != ge::GRAPH_SUCCESS) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"Get model part failed"}); | |||
REPORT_CALL_ERROR("E19999", "Get model part of om file:%s failed", model_file); | |||
GELOGE(ge::FAILED, "[Get][ModelPartition] failed."); | |||
if (model.model_data != nullptr) { | |||
delete[] reinterpret_cast<char *>(model.model_data); | |||
@@ -993,12 +993,12 @@ FMK_FUNC_HOST_VISIBILITY Status ConvertOm(const char *model_file, const char *js | |||
} | |||
} else { | |||
ret = INTERNAL_ERROR; | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"ReadProtoFromArray failed"}); | |||
REPORT_CALL_ERROR("E19999", "ReadProtoFromArray failed for om file:%s", model_file); | |||
GELOGE(ret, "[Read][Proto]From Array failed."); | |||
} | |||
} else { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E10003", | |||
{"parameter", "value", "reason"}, {"om", model_file, "invalid om file"}); | |||
{"parameter", "value", "reason"}, {"om", model_file, "invalid om file, can't be parsed"}); | |||
GELOGE(ACL_ERROR_GE_PARAM_INVALID, | |||
"[Parse][ModelContent] failed because of invalid om file. Please check --om param."); | |||
} | |||
@@ -1009,8 +1009,8 @@ FMK_FUNC_HOST_VISIBILITY Status ConvertOm(const char *model_file, const char *js | |||
} | |||
return ret; | |||
} catch (const std::exception &e) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, | |||
{"Convert om model to json failed, exception message[" + std::string(e.what()) + "]"}); | |||
REPORT_INNER_ERROR("E19999", "Convert om model to json failed, exception message:%s, model_file:%s", | |||
std::string(e.what()).c_str(), model_file); | |||
GELOGE(FAILED, "[Save][Model]Convert om model to json failed, exception message : %s.", e.what()); | |||
return FAILED; | |||
} | |||
@@ -1021,7 +1021,7 @@ FMK_FUNC_HOST_VISIBILITY Status ConvertPbtxtToJson(const char *model_file, const | |||
// Mode 2 does not need to verify the priority, and a default value of 0 is passed | |||
int32_t priority = 0; | |||
// Load model from file | |||
Status ret = ModelParserBase::LoadFromFile(model_file, "", priority, model); | |||
Status ret = ModelParserBase::LoadFromFile(model_file, priority, model); | |||
auto free_model_data = [](void **ptr) -> void { | |||
if (ptr != nullptr && *ptr != nullptr) { | |||
delete[] reinterpret_cast<char *>(*ptr); | |||
@@ -1042,7 +1042,7 @@ FMK_FUNC_HOST_VISIBILITY Status ConvertPbtxtToJson(const char *model_file, const | |||
if (!flag) { | |||
free_model_data(&model.model_data); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"ParseFromString failed"}); | |||
REPORT_CALL_ERROR("E19999", "ParseFromString failed for model_file:%s", model_file); | |||
GELOGE(FAILED, "[Invoke][ParseFromString] failed."); | |||
return FAILED; | |||
} | |||
@@ -1060,13 +1060,13 @@ FMK_FUNC_HOST_VISIBILITY Status ConvertPbtxtToJson(const char *model_file, const | |||
return SUCCESS; | |||
} catch (google::protobuf::FatalException &e) { | |||
free_model_data(&model.model_data); | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"ParseFromString failed, exception message[" | |||
+ std::string(e.what()) + "]"}); | |||
REPORT_INNER_ERROR("E19999", "ParseFromString failed, exception message:%s, model_file:%s", | |||
std::string(e.what()).c_str(), model_file); | |||
GELOGE(FAILED, "[Invoke][ParseFromString] failed. exception message : %s", e.what()); | |||
return FAILED; | |||
} catch (const std::exception &e) { | |||
ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, | |||
{"Convert pbtxt to json failed, exception message[" + std::string(e.what()) + "]"}); | |||
REPORT_INNER_ERROR("E19999", "ParseFromString failed, exception message:%s, model_file:%s", | |||
std::string(e.what()).c_str(), model_file); | |||
GELOGE(FAILED, "[Save][pbtxt]Convert pbtxt to json failed, exception message : %s.", e.what()); | |||
return FAILED; | |||
} | |||
@@ -1086,7 +1086,7 @@ FMK_FUNC_HOST_VISIBILITY Status ConvertFwkModelToJson(const domi::FrameworkType | |||
ErrorManager::GetInstance().ATCReportErrMessage( | |||
"E10001", {"parameter", "value", "reason"}, | |||
{"--framework", std::to_string(framework), "only support 0(Caffe) 3(TensorFlow) 5(Onnx)"}); | |||
{"--framework", std::to_string(framework), "only support 0(Caffe) 3(TensorFlow) 5(Onnx) when model set 1"}); | |||
GELOGE(PARAM_INVALID, "[Check][Param]Input parameter[--framework] is mandatory " | |||
"and it's value must be: 0(Caffe) 3(TensorFlow) or 5(Onnx)."); | |||
return PARAM_INVALID; | |||
@@ -37,7 +37,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status SingleOpManager::GetOpFr | |||
GELOGI("GetOpFromModel in. model name = %s, model id = %lu", model_name.c_str(), model_id); | |||
if (single_op == nullptr) { | |||
GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "[Check][Param:single_op] is null."); | |||
REPORT_INPUT_ERROR("E10412", std::vector<std::string>({"inputparam"}), std::vector<std::string>({"single_op"})); | |||
REPORT_INNER_ERROR("E10412", "input param single_op is nullptr, check invalid"); | |||
return ACL_ERROR_GE_INTERNAL_ERROR; | |||
} | |||
@@ -156,7 +156,7 @@ Status SingleOpManager::GetResourceId(rtStream_t stream, uintptr_t &resource_id) | |||
auto rt_err = rtCtxGetCurrent(&rt_cur_ctx); | |||
if (rt_err != RT_ERROR_NONE) { | |||
GELOGE(rt_err, "[Get][CurrentContext] failed, runtime result is %d", static_cast<int>(rt_err)); | |||
REPORT_CALL_ERROR("E19999", | |||
REPORT_CALL_ERROR("E19999", | |||
"GetResourceId failed because rtCtxGetCurrent result is %d", static_cast<int>(rt_err)); | |||
return RT_ERROR_TO_GE_STATUS(rt_err); | |||
} | |||
@@ -232,16 +232,6 @@ using google::protobuf::Message; | |||
/// | |||
const int32_t DOMI_MAX_PATH_LEN = 256; | |||
/// | |||
/// @ingroup domi_common | |||
/// @brief proto file in bianary format | |||
/// @param [in] file path of proto file | |||
/// @param [out] proto memory for storing the proto file | |||
/// @return true success | |||
/// @return false fail | |||
/// | |||
GE_FUNC_VISIBILITY bool ReadProtoFromBinaryFile(const char *file, Message *proto); | |||
/// | |||
/// @ingroup domi_common | |||
/// @brief Reads the proto structure from an array. | |||