m53297601
/
graphengine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

update geloge and report errormessage

Browse Source
pull/1299/head
liudingyan 4 years ago
parent 0664647c5a
commit 74944af874
9 changed files with 294 additions and 199 deletions
Show Stats Download Patch File Download Diff File

4
ge/host_cpu_engine/engine/host_cpu_engine.cc
Unescape View File

@ -18,6 +18,7 @@
#include <map> #include <map>
#include <memory> #include <memory>
#include <string> #include <string>
#include <securec.h>
#include "framework/common/debug/ge_log.h" #include "framework/common/debug/ge_log.h"
#include "common/ge/ge_util.h" #include "common/ge/ge_util.h"
#include "host_cpu_engine/common/constant/constant.h" #include "host_cpu_engine/common/constant/constant.h"
@ -34,7 +35,8 @@ Status HostCpuEngine::Initialize(const std::map<string, string> &options) {
if (ops_kernel_store_ == nullptr) { if (ops_kernel_store_ == nullptr) {
ops_kernel_store_ = MakeShared<HostCpuOpsKernelInfoStore>(); ops_kernel_store_ = MakeShared<HostCpuOpsKernelInfoStore>();
if (ops_kernel_store_ == nullptr) { if (ops_kernel_store_ == nullptr) {
GELOGE(FAILED, "Make HostCpuOpsKernelInfoStore failed."); GELOGE(FAILED, "[Create][HostCpuEngine]Make HostCpuOpsKernelInfoStore failed.");
REPORT_INNER_ERROR("E19999", "HostCpuEngine::Initialize failed for new HostCpuEngine.");
return FAILED; return FAILED;
} }
} }

24
ge/host_cpu_engine/ops_kernel_store/host_cpu_ops_kernel_builder.cc
Unescape View File

@ -21,6 +21,7 @@
#include "graph/utils/node_utils.h" #include "graph/utils/node_utils.h"
#include "graph/utils/tensor_utils.h" #include "graph/utils/tensor_utils.h"
#include "graph/utils/type_utils.h" #include "graph/utils/type_utils.h"
#include <securec.h>
#include "framework/common/debug/ge_log.h" #include "framework/common/debug/ge_log.h"
#include "host_cpu_engine/common/constant/constant.h" #include "host_cpu_engine/common/constant/constant.h"
#include "register/ops_kernel_builder_registry.h" #include "register/ops_kernel_builder_registry.h"
@ -39,7 +40,8 @@ Status HostCpuOpsKernelBuilder::Initialize(const map<std::string, std::string> &
Status HostCpuOpsKernelBuilder::CalcOpRunningParam(Node &ge_node) { Status HostCpuOpsKernelBuilder::CalcOpRunningParam(Node &ge_node) {
OpDescPtr op_desc = ge_node.GetOpDesc(); OpDescPtr op_desc = ge_node.GetOpDesc();
if (op_desc == nullptr) { if (op_desc == nullptr) {
GELOGE(FAILED, "CalcOpRunningParam failed, as op desc is null"); GELOGE(FAILED, "[Get][OpDesc]CalcOpRunningParam failed, as op desc is null");
REPORT_INNER_ERROR("E19999", "GetOpDesc failed.");
return FAILED; return FAILED;
} }
@ -73,9 +75,14 @@ Status HostCpuOpsKernelBuilder::CalcOpRunningParam(Node &ge_node) {
GeShape output_shape = output_tensor.GetShape(); GeShape output_shape = output_tensor.GetShape();
if ((TensorUtils::CalcTensorMemSize(output_shape, format, data_type, output_mem_size) != GRAPH_SUCCESS) || if ((TensorUtils::CalcTensorMemSize(output_shape, format, data_type, output_mem_size) != GRAPH_SUCCESS) ||
(output_mem_size < 0)) { (output_mem_size < 0)) {
GELOGE(FAILED, "Calc op[%s:%s] out[%zu] mem size failed, mem_size=%ld, format=%s, data_type=%s.", GELOGE(FAILED,
name.c_str(), type.c_str(), i, output_mem_size, TypeUtils::FormatToSerialString(format).c_str(), "[Calc][TensorMemSize] fail for op[%s:%s] out[%zu] mem size, mem_size=%ld, format=%s, data_type=%s.",
TypeUtils::DataTypeToSerialString(data_type).c_str()); name.c_str(), type.c_str(), i, output_mem_size, TypeUtils::FormatToSerialString(format).c_str(),
TypeUtils::DataTypeToSerialString(data_type).c_str());
REPORT_CALL_ERROR("E19999",
"CalcTensorMemSize failed for op[%s:%s] out[%zu] mem size, mem_size=%ld, format=%s, data_type=%s.",
name.c_str(), type.c_str(), i, output_mem_size, TypeUtils::FormatToSerialString(format).c_str(),
TypeUtils::DataTypeToSerialString(data_type).c_str());
return FAILED; return FAILED;
} }
GELOGI("Calc op[%s:%s] out[%zu] mem size is %ld, format=%s, data_type=%s.", GELOGI("Calc op[%s:%s] out[%zu] mem size is %ld, format=%s, data_type=%s.",
@ -84,8 +91,13 @@ Status HostCpuOpsKernelBuilder::CalcOpRunningParam(Node &ge_node) {
TensorUtils::SetSize(output_tensor, output_mem_size); TensorUtils::SetSize(output_tensor, output_mem_size);
if (op_desc->UpdateOutputDesc(static_cast<uint32_t>(i), output_tensor) != GRAPH_SUCCESS) { if (op_desc->UpdateOutputDesc(static_cast<uint32_t>(i), output_tensor) != GRAPH_SUCCESS) {
GELOGE(FAILED, "Update op[%s:%s] out[%zu] desc failed, format=%s, data_type=%s.", name.c_str(), type.c_str(), i, GELOGE(FAILED,
TypeUtils::FormatToSerialString(format).c_str(), TypeUtils::DataTypeToSerialString(data_type).c_str()); "[Update][OutputDesc] fail for op[%s:%s] out[%zu] desc , format=%s, data_type=%s.",
name.c_str(), type.c_str(), i,
TypeUtils::FormatToSerialString(format).c_str(), TypeUtils::DataTypeToSerialString(data_type).c_str());
REPORT_CALL_ERROR("E19999", "UpdateOutputDesc failed for op[%s:%s] out[%zu] desc , format=%s, data_type=%s.",
name.c_str(), type.c_str(), i,
TypeUtils::FormatToSerialString(format).c_str(), TypeUtils::DataTypeToSerialString(data_type).c_str());
return FAILED; return FAILED;
} }
} }

56
ge/init/gelib.cc
Unescape View File

@ -68,7 +68,8 @@ Status GELib::Initialize(const map<string, string> &options) {
// Multiple initializations are not allowed // Multiple initializations are not allowed
instancePtr_ = MakeShared<GELib>(); instancePtr_ = MakeShared<GELib>();
if (instancePtr_ == nullptr) { if (instancePtr_ == nullptr) {
GELOGE(GE_CLI_INIT_FAILED, "GeLib initialize failed, malloc shared_ptr failed."); GELOGE(GE_CLI_INIT_FAILED, "[Create][GELib]GeLib initialize failed, malloc shared_ptr failed.");
REPORT_INNER_ERROR("E19999", "GELib Init failed for new GeLib failed.");
return GE_CLI_INIT_FAILED; return GE_CLI_INIT_FAILED;
} }
@ -76,13 +77,15 @@ Status GELib::Initialize(const map<string, string> &options) {
map<string, string> new_options; map<string, string> new_options;
Status ret = instancePtr_->SetRTSocVersion(options, new_options); Status ret = instancePtr_->SetRTSocVersion(options, new_options);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ret, "GeLib initial failed."); GELOGE(ret, "[Set][RTSocVersion]GeLib initial: SetRTSocVersion failed.");
REPORT_CALL_ERROR("E19999", "SetRTSocVersion failed.");
return ret; return ret;
} }
ret = instancePtr_->SetAiCoreNum(new_options); ret = instancePtr_->SetAiCoreNum(new_options);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ret, "GeLib initial: SetAiCoreNum failed."); GELOGE(ret, "[Set][AiCoreNum]GeLib initial: SetAiCoreNum failed.");
REPORT_CALL_ERROR("E19999", "SetAiCoreNum failed.");
return ret; return ret;
} }
@ -97,7 +100,8 @@ Status GELib::Initialize(const map<string, string> &options) {
GE_TIMESTAMP_START(Init); GE_TIMESTAMP_START(Init);
ret = instancePtr_->InnerInitialize(new_options); ret = instancePtr_->InnerInitialize(new_options);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ret, "GeLib initial failed."); GELOGE(ret, "[Init][GeLib]GeLib initial failed.");
REPORT_CALL_ERROR("E19999", "GELib::InnerInitialize failed.");
instancePtr_ = nullptr; instancePtr_ = nullptr;
return ret; return ret;
} }
@ -118,7 +122,7 @@ Status GELib::InnerInitialize(const map<string, string> &options) {
Status initSystemStatus = SystemInitialize(options); Status initSystemStatus = SystemInitialize(options);
GE_TIMESTAMP_END(SystemInitialize, "InnerInitialize::SystemInitialize"); GE_TIMESTAMP_END(SystemInitialize, "InnerInitialize::SystemInitialize");
if (initSystemStatus != SUCCESS) { if (initSystemStatus != SUCCESS) {
GELOGE(initSystemStatus, "GE system initial failed."); GELOGE(initSystemStatus, "[Init][GESystem]GE system initial failed.");
RollbackInit(); RollbackInit();
return initSystemStatus; return initSystemStatus;
} }
@ -129,7 +133,8 @@ Status GELib::InnerInitialize(const map<string, string> &options) {
Status initEmStatus = engineManager_.Initialize(options); Status initEmStatus = engineManager_.Initialize(options);
GE_TIMESTAMP_END(EngineInitialize, "InnerInitialize::EngineInitialize"); GE_TIMESTAMP_END(EngineInitialize, "InnerInitialize::EngineInitialize");
if (initEmStatus != SUCCESS) { if (initEmStatus != SUCCESS) {
GELOGE(initEmStatus, "GE engine manager initial failed."); GELOGE(initEmStatus, "[Init][EngineManager]GE engine manager initial failed.");
REPORT_CALL_ERROR("E19999", "EngineManager initialize failed.");
RollbackInit(); RollbackInit();
return initEmStatus; return initEmStatus;
} }
@ -140,7 +145,8 @@ Status GELib::InnerInitialize(const map<string, string> &options) {
Status initOpsStatus = opsManager_.Initialize(options); Status initOpsStatus = opsManager_.Initialize(options);
GE_TIMESTAMP_END(OpsManagerInitialize, "InnerInitialize::OpsManagerInitialize"); GE_TIMESTAMP_END(OpsManagerInitialize, "InnerInitialize::OpsManagerInitialize");
if (initOpsStatus != SUCCESS) { if (initOpsStatus != SUCCESS) {
GELOGE(initOpsStatus, "GE ops manager initial failed."); GELOGE(initOpsStatus, "[Init][OpsManager]GE ops manager initial failed.");
REPORT_CALL_ERROR("E19999", "OpsManager initialize failed.");
RollbackInit(); RollbackInit();
return initOpsStatus; return initOpsStatus;
} }
@ -151,7 +157,8 @@ Status GELib::InnerInitialize(const map<string, string> &options) {
Status initOpsBuilderStatus = OpsKernelBuilderManager::Instance().Initialize(options); Status initOpsBuilderStatus = OpsKernelBuilderManager::Instance().Initialize(options);
GE_TIMESTAMP_END(OpsKernelBuilderManagerInitialize, "InnerInitialize::OpsKernelBuilderManager"); GE_TIMESTAMP_END(OpsKernelBuilderManagerInitialize, "InnerInitialize::OpsKernelBuilderManager");
if (initOpsBuilderStatus != SUCCESS) { if (initOpsBuilderStatus != SUCCESS) {
GELOGE(initOpsBuilderStatus, "GE ops builder manager initial failed."); GELOGE(initOpsBuilderStatus, "[Init][OpsKernelBuilderManager]GE ops builder manager initial failed.");
REPORT_CALL_ERROR("E19999", "OpsBuilderManager initialize failed.");
RollbackInit(); RollbackInit();
return initOpsBuilderStatus; return initOpsBuilderStatus;
} }
@ -162,7 +169,8 @@ Status GELib::InnerInitialize(const map<string, string> &options) {
Status initSmStatus = sessionManager_.Initialize(options); Status initSmStatus = sessionManager_.Initialize(options);
GE_TIMESTAMP_END(SessionManagerInitialize, "InnerInitialize::SessionManagerInitialize"); GE_TIMESTAMP_END(SessionManagerInitialize, "InnerInitialize::SessionManagerInitialize");
if (initSmStatus != SUCCESS) { if (initSmStatus != SUCCESS) {
GELOGE(initSmStatus, "GE session manager initial failed."); GELOGE(initSmStatus, "[Init][SessionManager] GE session manager initial failed.");
REPORT_CALL_ERROR("E19999", "SessionManager initialize failed.");
RollbackInit(); RollbackInit();
return initSmStatus; return initSmStatus;
} }
@ -172,7 +180,8 @@ Status GELib::InnerInitialize(const map<string, string> &options) {
Status initHostCpuEngineStatus = HostCpuEngine::GetInstance().Initialize(); Status initHostCpuEngineStatus = HostCpuEngine::GetInstance().Initialize();
GE_TIMESTAMP_END(HostCpuEngineInitialize, "InnerInitialize::HostCpuEngineInitialize"); GE_TIMESTAMP_END(HostCpuEngineInitialize, "InnerInitialize::HostCpuEngineInitialize");
if (initHostCpuEngineStatus != SUCCESS) { if (initHostCpuEngineStatus != SUCCESS) {
GELOGE(initHostCpuEngineStatus, "Failed to initialize HostCpuEngine"); GELOGE(initHostCpuEngineStatus, "[Init][HostCpuEngine]Failed to initialize HostCpuEngine.");
REPORT_CALL_ERROR("E19999", "HostCpuEngine initialize failed.");
RollbackInit(); RollbackInit();
return initHostCpuEngineStatus; return initHostCpuEngineStatus;
} }
@ -180,7 +189,8 @@ Status GELib::InnerInitialize(const map<string, string> &options) {
GELOGI("Start to init Analyzer!"); GELOGI("Start to init Analyzer!");
Status init_analyzer_status = ge::Analyzer::GetInstance()->Initialize(); Status init_analyzer_status = ge::Analyzer::GetInstance()->Initialize();
if (init_analyzer_status != SUCCESS) { if (init_analyzer_status != SUCCESS) {
GELOGE(init_analyzer_status, "Failed to initialize HostCpuEngine"); GELOGE(init_analyzer_status, "[Init][Analyzer]Failed to initialize Analyzer.");
REPORT_CALL_ERROR("E19999", "ge::Analyzer initialize failed.");
RollbackInit(); RollbackInit();
return init_analyzer_status; return init_analyzer_status;
} }
@ -205,7 +215,8 @@ Status GELib::SystemInitialize(const map<string, string> &options) {
auto model_manager = ModelManager::GetInstance(); auto model_manager = ModelManager::GetInstance();
GE_CHECK_NOTNULL(model_manager); GE_CHECK_NOTNULL(model_manager);
GE_IF_BOOL_EXEC(model_manager->EnableExceptionDump(options) != SUCCESS, GE_IF_BOOL_EXEC(model_manager->EnableExceptionDump(options) != SUCCESS,
GELOGE(FAILED, "Enable exception dump failed"); REPORT_CALL_ERROR("E19999", "ModelManager EnableExceptionDump failed.");
GELOGE(FAILED, "[Enable][ExceptionDump] failed.");
return FAILED); return FAILED);
// 1.`is_train_mode_` means case: train // 1.`is_train_mode_` means case: train
// 2.`(!is_train_mode_) && (options_.device_id != kDefaultDeviceIdForInfer)` means case: online infer // 2.`(!is_train_mode_) && (options_.device_id != kDefaultDeviceIdForInfer)` means case: online infer
@ -259,7 +270,10 @@ Status GELib::SetRTSocVersion(const map<string, string> &options, map<string, st
GELOGI("SOC_VERSION is not exist in options"); GELOGI("SOC_VERSION is not exist in options");
char version[kSocVersionLen] = {0}; char version[kSocVersionLen] = {0};
rtError_t rt_ret = rtGetSocVersion(version, kSocVersionLen); rtError_t rt_ret = rtGetSocVersion(version, kSocVersionLen);
GE_IF_BOOL_EXEC(rt_ret != RT_ERROR_NONE, GELOGE(rt_ret, "rtGetSocVersion failed"); return FAILED;) GE_IF_BOOL_EXEC(rt_ret != RT_ERROR_NONE,
REPORT_CALL_ERROR("E19999", "rtGetSocVersion failed.");
GELOGE(rt_ret, "[Get][SocVersion]rtGetSocVersion failed");
return FAILED;)
GELOGI("Succeeded in getting SOC_VERSION[%s] from runtime.", version); GELOGI("Succeeded in getting SOC_VERSION[%s] from runtime.", version);
new_options.insert(std::make_pair(ge::SOC_VERSION, version)); new_options.insert(std::make_pair(ge::SOC_VERSION, version));
} }
@ -280,7 +294,8 @@ Status GELib::SetAiCoreNum(map<string, string> &options) {
options.emplace(std::make_pair(AICORE_NUM, std::to_string(aicore_num))); options.emplace(std::make_pair(AICORE_NUM, std::to_string(aicore_num)));
return SUCCESS; return SUCCESS;
} }
GELOGE(FAILED, "rtGetAiCoreCount failed."); GELOGE(FAILED, "[Get][AiCoreCount]rtGetAiCoreCount failed.");
REPORT_CALL_ERROR("E19999", "rtGetAiCoreCount failed.");
return FAILED; return FAILED;
} }
@ -355,7 +370,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status GELib::InitSystemWithOpt
mem_type.push_back(RT_MEMORY_P2P_DDR); mem_type.push_back(RT_MEMORY_P2P_DDR);
Status initMmStatus = MemManager::Instance().Initialize(mem_type); Status initMmStatus = MemManager::Instance().Initialize(mem_type);
if (initMmStatus != SUCCESS) { if (initMmStatus != SUCCESS) {
GELOGE(initMmStatus, "[Initialize] MemoryAllocatorManager initialize failed."); GELOGE(initMmStatus, "[Init][MemManager] MemoryAllocatorManager initialize failed.");
REPORT_CALL_ERROR("E19999", "MemManager initialize failed.");
return initMmStatus; return initMmStatus;
} }
@ -363,7 +379,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status GELib::InitSystemWithOpt
// Update CSA file // Update CSA file
CsaInteract::GetInstance().Init(options.device_id, GetContext().TraceId()); CsaInteract::GetInstance().Init(options.device_id, GetContext().TraceId());
Status ret = CsaInteract::GetInstance().WriteJobState(JOBSTATE_RUNNING, JOBSUBSTATE_ENV_INIT); Status ret = CsaInteract::GetInstance().WriteJobState(JOBSTATE_RUNNING, JOBSUBSTATE_ENV_INIT);
GE_LOGE_IF(ret != SUCCESS, "write job state failed, ret:%u", ret); GE_LOGE_IF(ret != SUCCESS, "[Write][JobState] failed, ret:%u ", ret);
// set device id // set device id
GELOGI("set logical device id:%u", options.device_id); GELOGI("set logical device id:%u", options.device_id);
@ -394,7 +410,7 @@ Status GELib::SystemShutdownWithOptions(const Options &options) {
// Update CSA file // Update CSA file
Status ret = CsaInteract::GetInstance().WriteJobState(JOBSTATE_SUCCEED); Status ret = CsaInteract::GetInstance().WriteJobState(JOBSTATE_SUCCEED);
GE_LOGE_IF(ret != SUCCESS, "write job state failed, ret:%u", ret); GE_LOGE_IF(ret != SUCCESS, "[Write][JobState] failed, ret:%u ", ret);
is_system_inited = false; is_system_inited = false;
is_shutdown = true; is_shutdown = true;
@ -410,7 +426,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status GELib::InitSystemWithout
mem_type.push_back(RT_MEMORY_P2P_DDR); mem_type.push_back(RT_MEMORY_P2P_DDR);
Status initMmStatus = MemManager::Instance().Initialize(mem_type); Status initMmStatus = MemManager::Instance().Initialize(mem_type);
if (initMmStatus != SUCCESS) { if (initMmStatus != SUCCESS) {
GELOGE(initMmStatus, "[Initialize] MemoryAllocatorManager initialize failed."); GELOGE(initMmStatus, "[Init][MemoryManager] initialize failed.");
REPORT_CALL_ERROR("E19999", "MemManager initialize failed.");
return initMmStatus; return initMmStatus;
} }
GE_CHK_STATUS_RET(HostMemManager::Instance().Initialize()); GE_CHK_STATUS_RET(HostMemManager::Instance().Initialize());
@ -506,7 +523,8 @@ Status GELib::Finalize() {
instancePtr_ = nullptr; instancePtr_ = nullptr;
init_flag_ = false; init_flag_ = false;
if (final_state != SUCCESS) { if (final_state != SUCCESS) {
GELOGE(FAILED, "finalization failed."); GELOGE(FAILED, "[Check][State]finalization failed.");
REPORT_INNER_ERROR("E19999", "GELib::Finalize failed.");
return final_state; return final_state;
} }
GELOGI("finalization success."); GELOGI("finalization success.");

152
ge/ir_build/atc_ir_common.cc
View File

File diff suppressed because it is too large Load Diff

80
ge/ir_build/ge_ir_build.cc
View File

File diff suppressed because it is too large Load Diff

29
ge/omm/csa_interact.cc
Unescape View File

@ -78,7 +78,8 @@ void CsaInteract::Init(int32_t dev_index, int64_t job_id) {
Status CsaInteract::WriteJobState(JobState job_state, JobSubState job_sub_state, uint32_t module_ret_errcode, Status CsaInteract::WriteJobState(JobState job_state, JobSubState job_sub_state, uint32_t module_ret_errcode,
ErrorModule error_module) { ErrorModule error_module) {
if (!is_init_) { if (!is_init_) {
GELOGE(INTERNAL_ERROR, "CsaInteract has not init, can't WriteJobState"); GELOGE(INTERNAL_ERROR, "[Init][CsaInteract] obj has not init, can't WriteJobState");
REPORT_INNER_ERROR("E19999", "WriteJobState failed before init. ");
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
if ((curr_state_ == JOBSTATE_FAILED) || (curr_state_ == JOBSTATE_KILLED)) { if ((curr_state_ == JOBSTATE_FAILED) || (curr_state_ == JOBSTATE_KILLED)) {
@ -107,7 +108,10 @@ Status CsaInteract::WriteJobState(JobState job_state, JobSubState job_sub_state,
content = content_json.dump(); content = content_json.dump();
} catch (const nlohmann::json::exception &e) { } catch (const nlohmann::json::exception &e) {
GELOGE(INTERNAL_ERROR, "build jobstate content json string failed, exception:%s job_state:%u", e.what(), job_state); GELOGE(INTERNAL_ERROR, "[Create][JsonObject] exception:%s job_state:%u job_sub_state:%u.",
e.what(), job_state,job_sub_state);
REPORT_INNER_ERROR("E19999", "Create json object failed. exception:%s job_state:%u job_sub_state:%u.",
e.what(), job_state,job_sub_state);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -168,7 +172,8 @@ void CsaInteract::WriteInternalErrorCode() {
/// ///
Status CsaInteract::WriteHcomDetection(const std::string &content) { Status CsaInteract::WriteHcomDetection(const std::string &content) {
if (!is_init_) { if (!is_init_) {
GELOGE(INTERNAL_ERROR, "CsaInteract has not init, can't WriteJobState"); GELOGE(INTERNAL_ERROR, "[Init][CsaInteract] obj has not init, can't WriteJobState");
REPORT_INNER_ERROR("E19999", "WriteHcomDetection failed before init.");
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -192,28 +197,33 @@ Status CsaInteract::WriteFile(const std::string &file_name, const std::string &c
int32_t fd = mmOpen2(file_name.c_str(), flags, M_IRUSR | M_IWUSR | M_UMASK_GRPREAD); int32_t fd = mmOpen2(file_name.c_str(), flags, M_IRUSR | M_IWUSR | M_UMASK_GRPREAD);
if (fd == EN_ERROR) { if (fd == EN_ERROR) {
if (MakePath(file_name) != SUCCESS) { if (MakePath(file_name) != SUCCESS) {
GELOGE(INTERNAL_ERROR, "csainteract create file path fail, errno is %d", errno); GELOGE(INTERNAL_ERROR, "[Create][File Path] errno is %d", errno);
REPORT_CALL_ERROR("E19999", "MakePath failed. errno is %d", errno);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
fd = mmOpen2(file_name.c_str(), flags, M_IRUSR | M_IWUSR | M_UMASK_GRPREAD); fd = mmOpen2(file_name.c_str(), flags, M_IRUSR | M_IWUSR | M_UMASK_GRPREAD);
if (fd == EN_ERROR) { if (fd == EN_ERROR) {
GELOGE(INTERNAL_ERROR, "open file fail, errno is %d", errno); GELOGE(INTERNAL_ERROR, "[Open][File] errno is %d file_name: %s", errno, file_name.c_str());
REPORT_CALL_ERROR("E19999", "mmOpen2 failed. errno is %d file_name: %s", errno, file_name.c_str());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
} }
mmSsize_t ret = mmWrite(fd, reinterpret_cast<void *>(const_cast<char *>(content.c_str())), content.length()); mmSsize_t ret = mmWrite(fd, reinterpret_cast<void *>(const_cast<char *>(content.c_str())), content.length());
if (ret == EN_ERROR) { if (ret == EN_ERROR) {
GELOGE(INTERNAL_ERROR, "write file fail, errno is %d", errno); GELOGE(INTERNAL_ERROR, "[Write][File] errno is %d", errno);
REPORT_CALL_ERROR("E19999", "mmWrite failed. errno is %d", errno);
ret = mmClose(fd); ret = mmClose(fd);
if (ret == EN_ERROR) { if (ret == EN_ERROR) {
GELOGE(INTERNAL_ERROR, "close file fail, error is %d", errno); GELOGE(INTERNAL_ERROR, "[Close][File] error is %d", errno);
REPORT_CALL_ERROR("E19999", "mmClose failed. error is %d", errno);
} }
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
ret = mmClose(fd); ret = mmClose(fd);
if (ret == EN_ERROR) { if (ret == EN_ERROR) {
GELOGE(INTERNAL_ERROR, "close file fail, error is %d", errno); GELOGE(INTERNAL_ERROR, "[Close][File] error is %d", errno);
REPORT_CALL_ERROR("E19999", "mmClose failed. error is %d", errno);
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -242,7 +252,8 @@ Status CsaInteract::MakePath(const std::string &file_name) {
std::string pre_path = file_path.substr(0, found + 1); std::string pre_path = file_path.substr(0, found + 1);
if (mmAccess(pre_path.c_str()) != EN_OK) { if (mmAccess(pre_path.c_str()) != EN_OK) {
if (mmMkdir(pre_path.c_str(), M_IRWXU) != EN_OK) { if (mmMkdir(pre_path.c_str(), M_IRWXU) != EN_OK) {
GELOGE(INTERNAL_ERROR, "csainteract mkdir fail, errno is %d", errno); GELOGE(INTERNAL_ERROR, "[Create][FileDir] fail, errno is %d, pre_path:%s", errno, pre_path.c_str());
REPORT_CALL_ERROR("E19999", "mmMkdir failed. errno is %d pre_path:%s", errno, pre_path.c_str());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
} }

34
ge/opskernel_manager/ops_kernel_builder_manager.cc
Unescape View File

@ -50,7 +50,8 @@ Status OpsKernelBuilderManager::Initialize(const map<std::string, std::string> &
GE_CHK_STATUS_RET_NOLOG(GetLibPaths(options, lib_paths)); GE_CHK_STATUS_RET_NOLOG(GetLibPaths(options, lib_paths));
plugin_manager_.reset(new (std::nothrow)PluginManager()); plugin_manager_.reset(new (std::nothrow)PluginManager());
GE_CHECK_NOTNULL(plugin_manager_); GE_CHECK_NOTNULL(plugin_manager_);
GE_CHK_STATUS_RET(plugin_manager_->LoadSo(lib_paths), "Failed to load libs"); GE_CHK_STATUS_RET(plugin_manager_->LoadSo(lib_paths),
"[Load][Libs]Failed, lib_paths=%s.", lib_paths.c_str());
} }
auto &kernel_builders = OpsKernelBuilderRegistry::GetInstance().GetAll(); auto &kernel_builders = OpsKernelBuilderRegistry::GetInstance().GetAll();
@ -61,8 +62,7 @@ Status OpsKernelBuilderManager::Initialize(const map<std::string, std::string> &
GELOGI("Initialize ops kernel util for %s", kernel_lib_name.c_str()); GELOGI("Initialize ops kernel util for %s", kernel_lib_name.c_str());
GE_CHECK_NOTNULL(it.second); GE_CHECK_NOTNULL(it.second);
GE_CHK_STATUS_RET(it.second->Initialize(options), GE_CHK_STATUS_RET(it.second->Initialize(options),
"Failed to invoke Initialize, kernel lib name = %s", "[Invoke][Initialize]failed, kernel lib name = %s", kernel_lib_name.c_str());
kernel_lib_name.c_str());
ops_kernel_builders_.emplace(kernel_lib_name, it.second); ops_kernel_builders_.emplace(kernel_lib_name, it.second);
} }
@ -100,7 +100,8 @@ OpsKernelBuilderPtr OpsKernelBuilderManager::GetOpsKernelBuilder(const string &n
return nullptr; return nullptr;
} }
Status OpsKernelBuilderManager::GetLibPaths(const std::map<std::string, std::string> &options, std::string &lib_paths) { Status OpsKernelBuilderManager::GetLibPaths(const std::map<std::string,
std::string> &options, std::string &lib_paths) {
GELOGD("Start to execute GetLibPaths"); GELOGD("Start to execute GetLibPaths");
std::string path_base = PluginManager::GetPath(); std::string path_base = PluginManager::GetPath();
std::string so_path = "plugin/opskernel/"; std::string so_path = "plugin/opskernel/";
@ -128,18 +129,17 @@ Status OpsKernelBuilderManager::CalcOpRunningParam(Node &node) const {
const std::string &lib_name = op_desc->GetOpKernelLibName(); const std::string &lib_name = op_desc->GetOpKernelLibName();
auto it = ops_kernel_builders_.find(lib_name); auto it = ops_kernel_builders_.find(lib_name);
if (it == ops_kernel_builders_.end()) { if (it == ops_kernel_builders_.end()) {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR,"[Find][LibName] fail for libName = %s, node = %s.",
"Failed to get OpKernelStore. libName = %s, node = %s", lib_name.c_str(), op_desc->GetName().c_str());
lib_name.c_str(), REPORT_INNER_ERROR("E19999",
op_desc->GetName().c_str()); "find LibName for CalcOpRunningParam failed, libName = %s, node = %s not exist.",
lib_name.c_str(), op_desc->GetName().c_str());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
GELOGD("To invoke CalcOpRunningParam, node = %s, lib name = %s", op_desc->GetName().c_str(), lib_name.c_str()); GELOGD("To invoke CalcOpRunningParam, node = %s, lib name = %s", op_desc->GetName().c_str(), lib_name.c_str());
GE_CHK_STATUS_RET(it->second->CalcOpRunningParam(node), GE_CHK_STATUS_RET(it->second->CalcOpRunningParam(node),
"Failed to invoke CalcOpRunningParam, libName = %s, node = %s", "[Invoke][CalcOpRunningParam]failed, libName = %s, node = %s", lib_name.c_str(), op_desc->GetName().c_str());
lib_name.c_str(),
op_desc->GetName().c_str());
GELOGD("Done invoking CalcOpRunningParam successfully"); GELOGD("Done invoking CalcOpRunningParam successfully");
return SUCCESS; return SUCCESS;
} }
@ -152,20 +152,16 @@ Status OpsKernelBuilderManager::GenerateTask(const Node &node,
const std::string &lib_name = op_desc->GetOpKernelLibName(); const std::string &lib_name = op_desc->GetOpKernelLibName();
auto it = ops_kernel_builders_.find(lib_name); auto it = ops_kernel_builders_.find(lib_name);
if (it == ops_kernel_builders_.end()) { if (it == ops_kernel_builders_.end()) {
GELOGE(INTERNAL_ERROR, GELOGE(INTERNAL_ERROR, "[Find][LibName]fail for libName = %s, node:%s", lib_name.c_str(), op_desc->GetName().c_str());
"Failed to get OpKernelStore. libName = %s, node = %s", REPORT_INNER_ERROR("E19999", "find LibName for GenerateTask failed, libName = %s, node = %s not exist",
lib_name.c_str(), lib_name.c_str(), op_desc->GetName().c_str());
op_desc->GetName().c_str());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
GELOGD("To invoke GenerateTask, node = %s, lib name = %s", op_desc->GetName().c_str(), lib_name.c_str()); GELOGD("To invoke GenerateTask, node = %s, lib name = %s", op_desc->GetName().c_str(), lib_name.c_str());
GE_CHK_STATUS_RET(it->second->GenerateTask(node, context, tasks), GE_CHK_STATUS_RET(it->second->GenerateTask(node, context, tasks),
"Failed to invoke GenerateTask, libName = %s, node = %s", "[Invoke][GenerateTask]failed, libName = %s, node = %s", lib_name.c_str(), op_desc->GetName().c_str());
lib_name.c_str(),
op_desc->GetName().c_str());
GELOGD("Done invoking GenerateTask successfully"); GELOGD("Done invoking GenerateTask successfully");
return SUCCESS; return SUCCESS;
} }
} // namespace ge } // namespace ge

77
ge/opskernel_manager/ops_kernel_manager.cc
Unescape View File

@ -56,7 +56,8 @@ Status OpsKernelManager::Initialize(const map<string, string> &options_const) {
std::map<string, string> options(options_const); std::map<string, string> options(options_const);
Status ret = InitPluginOptions(options); Status ret = InitPluginOptions(options);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ret, "[OpsKernelManager] [Initialize] parse pluginFlag from ge options failed."); GELOGE(ret, "[Init][PluginOptions] parse pluginFlag from ge options failed.");
REPORT_CALL_ERROR("E19999", "InitPluginOptions failed.");
return ret; return ret;
} }
@ -85,7 +86,8 @@ Status OpsKernelManager::Initialize(const map<string, string> &options_const) {
initialize_ = options; initialize_ = options;
Status rst0 = plugin_manager_.InvokeAll<map<string, string> &, Status>(kInitialize, initialize_); Status rst0 = plugin_manager_.InvokeAll<map<string, string> &, Status>(kInitialize, initialize_);
if (rst0 == FAILED) { if (rst0 == FAILED) {
GELOGE(GE_OPS_GET_NO_VALID_SO, "There is invalid so about OpsKernelInfoStore."); GELOGE(GE_OPS_GET_NO_VALID_SO, "[Invoke][OpsKernelInfo]PluginManager InvokeAll failed.");
REPORT_INNER_ERROR("E19999", "PluginManager InvokeAll failed.")
return GE_OPS_GET_NO_VALID_SO; return GE_OPS_GET_NO_VALID_SO;
} }
Status rst1 = Status rst1 =
@ -114,18 +116,21 @@ Status OpsKernelManager::Initialize(const map<string, string> &options_const) {
} }
ret = InitGraphOptimizerPriority(); ret = InitGraphOptimizerPriority();
if ((ret != SUCCESS)) { if ((ret != SUCCESS)) {
GELOGE(ret, "Init graph optimizer priority failed."); GELOGE(ret, "[Init][GraphOptimizerPriority] failed.");
REPORT_CALL_ERROR("E19999", "InitGraphOptimizerPriority failed.");
return ret; return ret;
} }
init_flag_ = true; init_flag_ = true;
return SUCCESS; return SUCCESS;
} else { } else {
GELOGE(ret, "Failed to find any valid so file."); GELOGE(ret, "[Check][SoFile] not find any valid so file.");
REPORT_INNER_ERROR("E19999", "OpsKernelManager::Initialize failed for not find any valid so file.");
return ret; return ret;
} }
} }
void OpsKernelManager::GetExternalEnginePath(std::string &extern_engine_path, const std::map<string, string>& options) { void OpsKernelManager::GetExternalEnginePath(std::string &extern_engine_path,
const std::map<string, string>& options) {
GELOGI("Enter get external engine so path schedule"); GELOGI("Enter get external engine so path schedule");
const char *path_env = std::getenv("ASCEND_ENGINE_PATH"); const char *path_env = std::getenv("ASCEND_ENGINE_PATH");
if (path_env != nullptr) { if (path_env != nullptr) {
@ -175,21 +180,35 @@ Status OpsKernelManager::ParsePluginOptions(const map<string, string> &options,
} else if (flag == 1) { } else if (flag == 1) {
enable_flag = true; enable_flag = true;
} else { } else {
GELOGE(GE_GRAPH_OPTIONS_INVALID, "option_key:%s, its value %s is invalid, it must be 0 or 1.", GELOGE(GE_GRAPH_OPTIONS_INVALID,
plugin_name.c_str(), iter->second.c_str()); "[Parse][PluginOptions]option_key:%s, its value %s is invalid, it must be 0 or 1.",
plugin_name.c_str(), iter->second.c_str());
REPORT_INNER_ERROR("E19999", "ParsePluginOptions failed, option_key:%s, "
"its value %s is invalid, it must be 0 or 1.", plugin_name.c_str(), iter->second.c_str());
return GE_GRAPH_OPTIONS_INVALID; return GE_GRAPH_OPTIONS_INVALID;
} }
} catch (std::invalid_argument &) { } catch (std::invalid_argument &) {
GELOGE(GE_GRAPH_OPTIONS_INVALID, "option_key:ge.feFlag, its value %s is invalid_argument, it must be 0 or 1.", GELOGE(GE_GRAPH_OPTIONS_INVALID,
iter->second.c_str()); "[Parse][PluginOptions] failed, option_key:ge.feFlag, its value %s is invalid_argument, it must be 0 or 1.",
iter->second.c_str());
REPORT_INNER_ERROR("E19999",
"ParsePluginOptions failed, option_key:ge.feFlag, its value %s is invalid_argument, it must be 0 or 1.",
iter->second.c_str());
return GE_GRAPH_OPTIONS_INVALID; return GE_GRAPH_OPTIONS_INVALID;
} catch (std::out_of_range &) { } catch (std::out_of_range &) {
GELOGE(GE_GRAPH_OPTIONS_INVALID, "option_key:ge.feFlag, its value %s is out of range, it must be 0 or 1.", GELOGE(GE_GRAPH_OPTIONS_INVALID,
iter->second.c_str()); "[Parse][PluginOptions]failed, option_key:ge.feFlag, its value %s is out of range, it must be 0 or 1.",
iter->second.c_str());
REPORT_INNER_ERROR("E19999",
"ParsePluginOptions failed, option_key:ge.feFlag, its value %s is out of range, it must be 0 or 1.",
iter->second.c_str());
return GE_GRAPH_OPTIONS_INVALID; return GE_GRAPH_OPTIONS_INVALID;
} catch (...) { } catch (...) {
GELOGE(GE_GRAPH_OPTIONS_INVALID, "option_key:%s, its value %s is invalid, it must be 0 or 1.", GELOGE(GE_GRAPH_OPTIONS_INVALID,
plugin_name.c_str(), iter->second.c_str()); "[Parse][PluginOptions]option_key:%s, its value %s is invalid, it must be 0 or 1.",
plugin_name.c_str(), iter->second.c_str());
REPORT_INNER_ERROR("E19999", "ParsePluginOptions failed, option_key:%s, "
"its value %s is invalid, it must be 0 or 1.", plugin_name.c_str(), iter->second.c_str());
return GE_GRAPH_OPTIONS_INVALID; return GE_GRAPH_OPTIONS_INVALID;
} }
} else { } else {
@ -203,13 +222,15 @@ Status OpsKernelManager::ParsePluginOptions(const map<string, string> &options,
Status OpsKernelManager::CheckPluginPtr() const { Status OpsKernelManager::CheckPluginPtr() const {
for (auto iter = ops_kernel_store_.begin(); iter != ops_kernel_store_.end(); ++iter) { for (auto iter = ops_kernel_store_.begin(); iter != ops_kernel_store_.end(); ++iter) {
if (iter->second == nullptr) { if (iter->second == nullptr) {
GELOGE(INTERNAL_ERROR, "CheckPluginPtr OpsKernelInfoStorePtr is null"); GELOGE(INTERNAL_ERROR, "[Check][PluginPtr] OpsKernelInfoStorePtr key=%s is null", iter->first.c_str());
REPORT_INNER_ERROR("E19999", "CheckPluginPtr OpsKernelInfoStorePtr key=%s is null", iter->first.c_str());
return FAILED; return FAILED;
} }
} }
for (auto iter1 = graph_optimizers_.begin(); iter1 != graph_optimizers_.end(); ++iter1) { for (auto iter1 = graph_optimizers_.begin(); iter1 != graph_optimizers_.end(); ++iter1) {
if (iter1->second == nullptr) { if (iter1->second == nullptr) {
GELOGE(INTERNAL_ERROR, "CheckPluginPtr GraphOptimizerPtr is null"); GELOGE(INTERNAL_ERROR, "[Check][PluginPtr] GraphOptimizerPtr key=%s is null", iter1->first.c_str());
REPORT_INNER_ERROR("E19999", "GraphOptimizerPtr key=%s is null", iter1->first.c_str());
return FAILED; return FAILED;
} }
} }
@ -222,7 +243,9 @@ Status OpsKernelManager::InitOpKernelInfoStores(const map<string, string> &optio
GELOGI("OpKernelInfoStore name: %s.", (it.first).c_str()); GELOGI("OpKernelInfoStore name: %s.", (it.first).c_str());
Status ret = it.second->Initialize(options); Status ret = it.second->Initialize(options);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(GE_OPS_KERNEL_STORE_INIT_FAILED, "OpKernelInfoStore: %s initialize failed.", (it.first).c_str()); GELOGE(GE_OPS_KERNEL_STORE_INIT_FAILED,
"[Init][OpKernelLib]OpKernelInfoStore: %s initialize failed.", (it.first).c_str());
REPORT_CALL_ERROR("E19999", "OpKernelInfoStore: %s initialize failed.", (it.first).c_str());
return GE_OPS_KERNEL_STORE_INIT_FAILED; return GE_OPS_KERNEL_STORE_INIT_FAILED;
} }
} }
@ -247,7 +270,8 @@ void OpsKernelManager::InitOpsKernelInfo() {
} }
std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance(); std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
if (instance_ptr == nullptr) { if (instance_ptr == nullptr) {
GELOGE(GE_CLI_GE_NOT_INITIALIZED, "InitOpsKernelInfo failed."); GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[Get][GELib]malloc instance_ptr failed.");
REPORT_INNER_ERROR("E19999", "InitOpsKernelInfo failed for new GELib.");
return; return;
} }
// sort opinfo of ops_kernel_info_ // sort opinfo of ops_kernel_info_
@ -291,7 +315,8 @@ Status OpsKernelManager::InitGraphOptimzers(const map<string, string> &options)
GE_CHK_STATUS_RET(it.second->GetAttributes(attrs)) GE_CHK_STATUS_RET(it.second->GetAttributes(attrs))
std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance(); std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
if (instance_ptr == nullptr) { if (instance_ptr == nullptr) {
GELOGE(GE_CLI_GE_NOT_INITIALIZED, "InitGraphOptimzers failed."); GELOGE(GE_CLI_GE_NOT_INITIALIZED, "[Get][GELib]malloc instance_ptr failed.");
REPORT_INNER_ERROR("E19999", "InitGraphOptimzers failed for new GELib.");
return GE_CLI_GE_NOT_INITIALIZED; return GE_CLI_GE_NOT_INITIALIZED;
} }
if (!instance_ptr->DNNEngineManagerObj().IsEngineRegistered(attrs.engineName)) { if (!instance_ptr->DNNEngineManagerObj().IsEngineRegistered(attrs.engineName)) {
@ -300,7 +325,9 @@ Status OpsKernelManager::InitGraphOptimzers(const map<string, string> &options)
} }
Status ret = it.second->Initialize(options); Status ret = it.second->Initialize(options);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(GE_OPS_GRAPH_OPTIMIZER_INIT_FAILED, "GraphOptimzer: %s initialize failed.", (it.first).c_str()); GELOGE(GE_OPS_GRAPH_OPTIMIZER_INIT_FAILED,
"[Init][GraphOptimzer]GraphOptimzer: %s initialize failed.", (it.first).c_str());
REPORT_CALL_ERROR("E19999", "InitGraphOptimzers failed. %s initialize failed.", (it.first).c_str());
return GE_OPS_GRAPH_OPTIMIZER_INIT_FAILED; return GE_OPS_GRAPH_OPTIMIZER_INIT_FAILED;
} }
} }
@ -317,7 +344,8 @@ Status OpsKernelManager::Finalize() {
GELOGI("OpsKernelStore finalize, name: %s.", (iter->first).c_str()); GELOGI("OpsKernelStore finalize, name: %s.", (iter->first).c_str());
Status status = iter->second->Finalize(); Status status = iter->second->Finalize();
if (SUCCESS != status) { if (SUCCESS != status) {
GELOGE(status, "OpsKernelStore finalize failed, name: %s.", (iter->first).c_str()); GELOGE(status, "[Check][Status]OpsKernelStore finalize failed, name: %s.", (iter->first).c_str());
REPORT_CALL_ERROR("E19999", "OpsKernelStore finalize failed, name: %s.", (iter->first).c_str());
return status; return status;
} }
} }
@ -325,14 +353,16 @@ Status OpsKernelManager::Finalize() {
GELOGI("GraphOptimzers finalize, name: %s.", (iter->first).c_str()); GELOGI("GraphOptimzers finalize, name: %s.", (iter->first).c_str());
Status status = iter->second->Finalize(); Status status = iter->second->Finalize();
if (status != SUCCESS) { if (status != SUCCESS) {
GELOGE(status, "GraphOptimzers finalize failed, name: %s.", (iter->first).c_str()); GELOGE(status, "[Check][Status]GraphOptimzers finalize failed, name: %s.", (iter->first).c_str());
REPORT_CALL_ERROR("E19999", "GraphOptimzers finalize failed, name: %s.", (iter->first).c_str());
return status; return status;
} }
} }
Status ret = FinalizeOpsKernel(); Status ret = FinalizeOpsKernel();
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ret, "free ops kernel resource failed."); GELOGE(ret, "[Free][Ops Kernel Resource] failed.");
REPORT_CALL_ERROR("E19999", "FinalizeOpsKernel failed, Free Ops kernel resource failed.");
return ret; return ret;
} }
@ -443,7 +473,8 @@ Status OpsKernelManager::FinalizeOpsKernel() {
GELOGI("ge invoke ops kernal finalize."); GELOGI("ge invoke ops kernal finalize.");
Status ret = plugin_manager_.InvokeAll<Status>(kFinalize); Status ret = plugin_manager_.InvokeAll<Status>(kFinalize);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ret, "[Finalize] invoke Fe finalize failed."); GELOGE(ret, "[Finalize][Check][Status] invoke Fe finalize failed.");
REPORT_INNER_ERROR("E19999", "PluginManager InvokeAll failed.");
return ret; return ret;
} }

31
ge/plugin/engine/engine_manage.cc
Unescape View File

@ -21,6 +21,7 @@
#include <utility> #include <utility>
#include "common/ge/ge_util.h" #include "common/ge/ge_util.h"
#include "securec.h"
#include "framework/common/debug/ge_log.h" #include "framework/common/debug/ge_log.h"
#include "plugin/engine/dnnengines.h" #include "plugin/engine/dnnengines.h"
@ -29,7 +30,8 @@ std::unique_ptr<std::map<std::string, DNNEnginePtr>> EngineManager::engine_map_;
Status EngineManager::RegisterEngine(const std::string &engine_name, DNNEnginePtr engine_ptr) { Status EngineManager::RegisterEngine(const std::string &engine_name, DNNEnginePtr engine_ptr) {
if (engine_ptr == nullptr) { if (engine_ptr == nullptr) {
GELOGE(FAILED, "enginePtr is nullptr"); GELOGE(FAILED, "[Register][Engine] failed, as input engine_ptr is nullptr");
REPORT_INNER_ERROR("E19999", "RegisterEngine failed for input engine_ptr is nullptr.");
return FAILED; return FAILED;
} }
@ -64,7 +66,8 @@ void RegisterAiCoreEngine() {
DNNEngineAttribute attr_aicore = {ai_core, mem_type_aicore, COST_0, DEVICE, FORMAT_RESERVED, FORMAT_RESERVED}; DNNEngineAttribute attr_aicore = {ai_core, mem_type_aicore, COST_0, DEVICE, FORMAT_RESERVED, FORMAT_RESERVED};
DNNEnginePtr aicore_engine_ptr = MakeShared<AICoreDNNEngine>(attr_aicore); DNNEnginePtr aicore_engine_ptr = MakeShared<AICoreDNNEngine>(attr_aicore);
if (aicore_engine_ptr == nullptr) { if (aicore_engine_ptr == nullptr) {
GELOGE(ge::FAILED, "make aiCoreEnginePtr failed"); GELOGE(ge::FAILED, "[Register][AiCoreEngine] failed, as malloc shared_ptr failed.");
REPORT_INNER_ERROR("E19999", "RegisterAiCoreEngine failed for new DNNEnginePtr failed.");
return; return;
} }
if (EngineManager::RegisterEngine(ai_core, aicore_engine_ptr) != SUCCESS) { if (EngineManager::RegisterEngine(ai_core, aicore_engine_ptr) != SUCCESS) {
@ -80,7 +83,8 @@ void RegisterVectorEngine() {
DEVICE, FORMAT_RESERVED, FORMAT_RESERVED}; DEVICE, FORMAT_RESERVED, FORMAT_RESERVED};
DNNEnginePtr vectorcore_engine_ptr = MakeShared<VectorCoreDNNEngine>(attr_vector_core); DNNEnginePtr vectorcore_engine_ptr = MakeShared<VectorCoreDNNEngine>(attr_vector_core);
if (vectorcore_engine_ptr == nullptr) { if (vectorcore_engine_ptr == nullptr) {
GELOGE(ge::FAILED, "make vectorCoreEnginePtr failed"); GELOGE(ge::FAILED, "[Register][VectorEngine] failed, as malloc shared_ptr failed.");
REPORT_INNER_ERROR("E19999", "RegisterVectorEngine failed for new DNNEnginePtr failed.");
return; return;
} }
if (EngineManager::RegisterEngine(vector_core, vectorcore_engine_ptr) != SUCCESS) { if (EngineManager::RegisterEngine(vector_core, vectorcore_engine_ptr) != SUCCESS) {
@ -95,7 +99,8 @@ void RegisterAiCpuEngine() {
DNNEngineAttribute attr_aicpu = {vm_aicpu, mem_type_aicpu, COST_3, DEVICE, FORMAT_RESERVED, FORMAT_RESERVED}; DNNEngineAttribute attr_aicpu = {vm_aicpu, mem_type_aicpu, COST_3, DEVICE, FORMAT_RESERVED, FORMAT_RESERVED};
DNNEnginePtr vm_engine_ptr = MakeShared<AICpuDNNEngine>(attr_aicpu); DNNEnginePtr vm_engine_ptr = MakeShared<AICpuDNNEngine>(attr_aicpu);
if (vm_engine_ptr == nullptr) { if (vm_engine_ptr == nullptr) {
GELOGE(ge::FAILED, "make vm_engine_ptr failed"); GELOGE(ge::FAILED, "[Register][AiCpuEngine] failed, as malloc shared_ptr failed.");
REPORT_INNER_ERROR("E19999", "RegisterAiCpuEngine failed for new DNNEnginePtr failed.");
return; return;
} }
if (EngineManager::RegisterEngine(vm_aicpu, vm_engine_ptr) != SUCCESS) { if (EngineManager::RegisterEngine(vm_aicpu, vm_engine_ptr) != SUCCESS) {
@ -110,7 +115,8 @@ void RegisterAiCpuTFEngine() {
DNNEngineAttribute attr_aicpu_tf = {vm_aicpu_tf, mem_type_aicpu_tf, COST_2, DEVICE, FORMAT_RESERVED, FORMAT_RESERVED}; DNNEngineAttribute attr_aicpu_tf = {vm_aicpu_tf, mem_type_aicpu_tf, COST_2, DEVICE, FORMAT_RESERVED, FORMAT_RESERVED};
DNNEnginePtr vm_engine_ptr = MakeShared<AICpuTFDNNEngine>(attr_aicpu_tf); DNNEnginePtr vm_engine_ptr = MakeShared<AICpuTFDNNEngine>(attr_aicpu_tf);
if (vm_engine_ptr == nullptr) { if (vm_engine_ptr == nullptr) {
GELOGE(ge::FAILED, "make vm_engine_ptr failed"); GELOGE(ge::FAILED, "[Register][AiCpuTFEngine]make vm_engine_ptr failed");
REPORT_INNER_ERROR("E19999", "RegisterAiCpuTFEngine failed for new DNNEnginePtr failed.");
return; return;
} }
if (EngineManager::RegisterEngine(vm_aicpu_tf, vm_engine_ptr) != SUCCESS) { if (EngineManager::RegisterEngine(vm_aicpu_tf, vm_engine_ptr) != SUCCESS) {
@ -126,7 +132,8 @@ void RegisterGeLocalEngine() {
DNNEngineAttribute attr_ge_local = {vm_ge_local, mem_type_ge_local, COST_9, DEVICE, FORMAT_RESERVED, FORMAT_RESERVED}; DNNEngineAttribute attr_ge_local = {vm_ge_local, mem_type_ge_local, COST_9, DEVICE, FORMAT_RESERVED, FORMAT_RESERVED};
DNNEnginePtr ge_local_engine = MakeShared<GeLocalDNNEngine>(attr_ge_local); DNNEnginePtr ge_local_engine = MakeShared<GeLocalDNNEngine>(attr_ge_local);
if (ge_local_engine == nullptr) { if (ge_local_engine == nullptr) {
GELOGE(ge::FAILED, "make ge_local_engine failed"); GELOGE(ge::FAILED, "[Register][GeLocalEngine] failed, as malloc shared_ptr failed.");
REPORT_INNER_ERROR("E19999", "RegisterGeLocalEngine failed for new DNNEnginePtr failed.");
return; return;
} }
if (EngineManager::RegisterEngine(vm_ge_local, ge_local_engine) != SUCCESS) { if (EngineManager::RegisterEngine(vm_ge_local, ge_local_engine) != SUCCESS) {
@ -139,10 +146,12 @@ void RegisterHostCpuEngine() {
std::vector<std::string> mem_type_host_cpu; std::vector<std::string> mem_type_host_cpu;
mem_type_host_cpu.emplace_back(GE_ENGINE_ATTR_MEM_TYPE_HBM); mem_type_host_cpu.emplace_back(GE_ENGINE_ATTR_MEM_TYPE_HBM);
// HostCpu use minimum priority, set it as 10 // HostCpu use minimum priority, set it as 10
DNNEngineAttribute attr_host_cpu = {vm_host_cpu, mem_type_host_cpu, COST_10, HOST, FORMAT_RESERVED, FORMAT_RESERVED}; DNNEngineAttribute attr_host_cpu = {vm_host_cpu, mem_type_host_cpu, COST_10,
HOST, FORMAT_RESERVED, FORMAT_RESERVED};
DNNEnginePtr host_cpu_engine = MakeShared<HostCpuDNNEngine>(attr_host_cpu); DNNEnginePtr host_cpu_engine = MakeShared<HostCpuDNNEngine>(attr_host_cpu);
if (host_cpu_engine == nullptr) { if (host_cpu_engine == nullptr) {
GELOGE(ge::FAILED, "make host_cpu_engine failed"); GELOGE(ge::FAILED, "[Register][HostCpuEngine] failed, as malloc shared_ptr failed.");
REPORT_INNER_ERROR("E19999", "RegisterHostCpuEngine failed for new DNNEnginePtr failed.");
return; return;
} }
if (EngineManager::RegisterEngine(vm_host_cpu, host_cpu_engine) != SUCCESS) { if (EngineManager::RegisterEngine(vm_host_cpu, host_cpu_engine) != SUCCESS) {
@ -157,7 +166,8 @@ void RegisterRtsEngine() {
DNNEngineAttribute attr_rts = {vm_rts, mem_type_rts, COST_1, DEVICE, FORMAT_RESERVED, FORMAT_RESERVED}; DNNEngineAttribute attr_rts = {vm_rts, mem_type_rts, COST_1, DEVICE, FORMAT_RESERVED, FORMAT_RESERVED};
DNNEnginePtr rts_engine = MakeShared<RtsDNNEngine>(attr_rts); DNNEnginePtr rts_engine = MakeShared<RtsDNNEngine>(attr_rts);
if (rts_engine == nullptr) { if (rts_engine == nullptr) {
GELOGE(ge::FAILED, "make rts_engine failed"); GELOGE(ge::FAILED, "[Register][RtsEngine] failed, as malloc shared_ptr failed.");
REPORT_INNER_ERROR("E19999", "RegisterRtsEngine failed for new DNNEnginePtr failed.");
return; return;
} }
if (EngineManager::RegisterEngine(vm_rts, rts_engine) != SUCCESS) { if (EngineManager::RegisterEngine(vm_rts, rts_engine) != SUCCESS) {
@ -172,7 +182,8 @@ void RegisterHcclEngine() {
DNNEngineAttribute attr_hccl = {dnn_hccl, mem_type_hccl, COST_1, DEVICE, FORMAT_RESERVED, FORMAT_RESERVED}; DNNEngineAttribute attr_hccl = {dnn_hccl, mem_type_hccl, COST_1, DEVICE, FORMAT_RESERVED, FORMAT_RESERVED};
DNNEnginePtr hccl_engine = MakeShared<HcclDNNEngine>(attr_hccl); DNNEnginePtr hccl_engine = MakeShared<HcclDNNEngine>(attr_hccl);
if (hccl_engine == nullptr) { if (hccl_engine == nullptr) {
GELOGE(ge::FAILED, "make hccl_engine failed"); GELOGE(ge::FAILED, "[Register][HcclEngine] failed, as malloc shared_ptr failed.");
REPORT_INNER_ERROR("E19999", "RegisterHcclEngine failed for new DNNEnginePtr failed.");
return; return;
} }
if (EngineManager::RegisterEngine(dnn_hccl, hccl_engine) != SUCCESS) { if (EngineManager::RegisterEngine(dnn_hccl, hccl_engine) != SUCCESS) {

Write Preview
Loading…
Cancel
Save