diff --git a/ge/common/helper/model_helper.cc b/ge/common/helper/model_helper.cc index 561fcc40..82449ff3 100644 --- a/ge/common/helper/model_helper.cc +++ b/ge/common/helper/model_helper.cc @@ -17,6 +17,7 @@ #include "framework/common/helper/model_helper.h" #include "common/model_parser/model_parser.h" +#include "framework/omg/model_tool.h" #include "framework/omg/version.h" #include "graph/debug/ge_attr_define.h" #include "graph/utils/graph_utils.h" @@ -873,4 +874,96 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::GetModelNam GE_CHK_BOOL_EXEC_WARN(!model_name.empty(), return FAILED, "Get model_name failed, check params --output"); return SUCCESS; } + +Status ModelTool::GetModelInfoFromOm(const char *model_file, ge::proto::ModelDef &model_def, uint32_t &modeldef_size) { + GE_CHECK_NOTNULL(model_file); + ge::ModelData model; + int32_t priority = 0; + + Status ret = ModelParserBase::LoadFromFile(model_file, "", priority, model); + if (ret != SUCCESS) { + GELOGE(ret, "LoadFromFile failed."); + return ret; + } + std::function callback = [&]() { + if (model.model_data != nullptr) { + delete[] reinterpret_cast(model.model_data); + model.model_data = nullptr; + } + }; + + uint8_t *model_data = nullptr; + uint32_t model_len = 0; + ret = ModelParserBase::ParseModelContent(model, model_data, model_len); + if (ret != SUCCESS) { + ErrorManager::GetInstance().ATCReportErrMessage("E10003", + {"parameter", "value", "reason"}, {"om", model_file, "invalid om file"}); + GELOGE(ACL_ERROR_GE_PARAM_INVALID, + "ParseModelContent failed because of invalid om file. Please check --om param."); + return ret; + } + + OmFileLoadHelper omFileLoadHelper; + ret = omFileLoadHelper.Init(model_data, model_len); + if (ret != ge::GRAPH_SUCCESS) { + ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"Om file init failed"}); + GELOGE(ge::FAILED, "Om file init failed."); + return ret; + } + + ModelPartition ir_part; + ret = omFileLoadHelper.GetModelPartition(MODEL_DEF, ir_part); + if (ret != ge::GRAPH_SUCCESS) { + ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"Get model part failed"}); + GELOGE(ge::FAILED, "Get model part failed."); + return ret; + } + + bool flag = ReadProtoFromArray(ir_part.data, ir_part.size, &model_def); + if (!flag) { + ret = INTERNAL_ERROR; + ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"ReadProtoFromArray failed"}); + GELOGE(ret, "ReadProtoFromArray failed."); + return ret; + } + modeldef_size = ir_part.size; + return ret; +} + +Status ModelTool::GetModelInfoFromPbtxt(const char *model_file, ge::proto::ModelDef &model_def) { + GE_CHECK_NOTNULL(model_file); + ge::ModelData model; + int32_t priority = 0; + + Status ret = ModelParserBase::LoadFromFile(model_file, "", priority, model); + auto free_model_data = [](void **ptr) -> void { + if (ptr != nullptr && *ptr != nullptr) { + delete[] reinterpret_cast(*ptr); + *ptr = nullptr; + } + }; + if (ret != SUCCESS) { + free_model_data(&model.model_data); + GELOGE(ret, "LoadFromFile failed."); + return ret; + } + + try { + bool flag = google::protobuf::TextFormat::ParseFromString(reinterpret_cast(model.model_data), &model_def); + if (!flag) { + free_model_data(&model.model_data); + ErrorManager::GetInstance().ATCReportErrMessage("E19021", {"reason"}, {"ParseFromString failed"}); + GELOGE(FAILED, "ParseFromString failed."); + return FAILED; + } + free_model_data(&model.model_data); + 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()) + "]"}); + GELOGE(FAILED, "ParseFromString failed. exception message : %s", e.what()); + return FAILED; + } +} } // namespace ge diff --git a/ge/graph/optimize/common/params.h b/ge/graph/optimize/common/params.h index c174a4d1..d5b66b8f 100644 --- a/ge/graph/optimize/common/params.h +++ b/ge/graph/optimize/common/params.h @@ -55,7 +55,7 @@ class Params : public Singleton { Params() : target_("MINI") {} string target_; - uint8_t target_8bit_ = 0; + uint8_t target_8bit_ = TARGET_TYPE_MINI_8BIT; }; } // namespace ge diff --git a/ge/init/gelib.cc b/ge/init/gelib.cc old mode 100755 new mode 100644 index faa06962..a0014018 --- a/ge/init/gelib.cc +++ b/ge/init/gelib.cc @@ -31,6 +31,7 @@ #include "framework/common/debug/ge_log.h" #include "framework/common/debug/log.h" #include "framework/common/util.h" +#include "framework/omg/ge_init.h" #include "analyzer/analyzer.h" #include "ge/ge_api_types.h" #include "ge_local_engine/engine/host_cpu_engine.h" @@ -531,4 +532,21 @@ void GELib::RollbackInit() { HostMemManager::Instance().Finalize(); VarManagerPool::Instance().Destory(); } + +Status GEInit::Initialize(const map &options) { + Status ret = SUCCESS; + std::shared_ptr instance_ptr = ge::GELib::GetInstance(); + if (instance_ptr == nullptr || !instance_ptr->InitFlag()) { + ret = GELib::Initialize(options); + } + return ret; +} + +Status GEInit::Finalize() { + return GELib::GetInstance()->Finalize(); +} + +string GEInit::GetPath() { + return GELib::GetPath(); +} } // namespace ge diff --git a/inc/framework/omg/ge_init.h b/inc/framework/omg/ge_init.h new file mode 100644 index 00000000..42fd8979 --- /dev/null +++ b/inc/framework/omg/ge_init.h @@ -0,0 +1,36 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INC_FRAMEWORK_OMG_GE_INIT_H_ +#define INC_FRAMEWORK_OMG_GE_INIT_H_ +#include +#include +#include "common/ge_inner_error_codes.h" + +namespace ge { +class GE_FUNC_VISIBILITY GEInit { + public: + // GE Environment Initialize, return Status: SUCCESS,FAILED + static Status Initialize(const std::map &options); + + static std::string GetPath(); + + // GE Environment Finalize, return Status: SUCCESS,FAILED + static Status Finalize(); +}; +} // namespace ge + +#endif // INC_FRAMEWORK_OMG_GE_INIT_H_ diff --git a/inc/framework/omg/model_tool.h b/inc/framework/omg/model_tool.h new file mode 100644 index 00000000..8c425823 --- /dev/null +++ b/inc/framework/omg/model_tool.h @@ -0,0 +1,35 @@ +/** + * Copyright 2019-2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INC_FRAMEWORK_OMG_MODEL_TOOL_H_ +#define INC_FRAMEWORK_OMG_MODEL_TOOL_H_ + +#include +#include + +#include "framework/common/debug/ge_log.h" +#include "proto/ge_ir.pb.h" + +namespace ge { +class GE_FUNC_VISIBILITY ModelTool { + public: + static Status GetModelInfoFromOm(const char *model_file, ge::proto::ModelDef &model_def, uint32_t &modeldef_size); + + static Status GetModelInfoFromPbtxt(const char *model_file, ge::proto::ModelDef &model_def); +}; +} // namespace ge + +#endif // INC_FRAMEWORK_OMG_MODEL_TOOL_H_