From 68729e734963b36f1349a47fc7ad9045192b9c47 Mon Sep 17 00:00:00 2001 From: zhangxiaokun Date: Mon, 19 Jul 2021 22:04:56 +0800 Subject: [PATCH] Detach MemManager from VarManager --- ge/client/ge_api.cc | 13 +++ ge/common/profiling/profiling_manager.cc | 55 +++++++--- ge/common/profiling/profiling_manager.h | 18 +++- ge/executor/ge_executor.cc | 64 +++++++----- ge/graph/execute/model_executor.cc | 20 +--- ge/graph/manager/graph_var_manager.cc | 1 + ge/hybrid/hybrid_davinci_model_stub.cc | 115 --------------------- ge/init/gelib.cc | 23 +---- ge/init/gelib.h | 6 -- inc/framework/executor/ge_executor.h | 17 +++ tests/ut/ge/CMakeLists.txt | 31 +----- .../ge/profiling/ge_profiling_manager_unittest.cc | 15 ++- 12 files changed, 144 insertions(+), 234 deletions(-) delete mode 100644 ge/hybrid/hybrid_davinci_model_stub.cc diff --git a/ge/client/ge_api.cc b/ge/client/ge_api.cc index 38df3d8a..da1f8635 100644 --- a/ge/client/ge_api.cc +++ b/ge/client/ge_api.cc @@ -19,6 +19,7 @@ #include #include "framework/common/debug/log.h" #include "framework/common/debug/ge_log.h" +#include "framework/executor/ge_executor.h" #include "common/ge/datatype_util.h" #include "proto/ge_api.pb.h" #include "graph/model_serialize.h" @@ -161,6 +162,17 @@ Status GEInitializeImpl(const std::map &options) { return ret; } + ErrorManager::GetInstance().SetStage(error_message::kInitialize, error_message::kOther); + GELOGI("GeExecutor initial."); + GE_TIMESTAMP_START(GeExecutorInitialize); + ret = GeExecutor::Initialize(options); + if (ret != SUCCESS) { + GELOGE(ret, "[Init][GeExecutor] GeExecutor initialize failed."); + REPORT_CALL_ERROR("E19999", "GeExecutor initialize failed."); + return ret; + } + GE_TIMESTAMP_END(GeExecutorInitialize, "GeExecutor::Initialize"); + // 7.check return status, return if (!g_ge_initialized) { // Initialize success, first time calling initialize @@ -213,6 +225,7 @@ Status GEFinalize() { ErrorManager::GetInstance().GenWorkStreamIdDefault(); GELOGT(TRACE_INIT, "GEFinalize start"); + (void)GeExecutor::FinalizeEx(); GELOGI("SessionManager finalization."); if (g_session_manager != nullptr) { (void)g_session_manager->Finalize(); // always success. diff --git a/ge/common/profiling/profiling_manager.cc b/ge/common/profiling/profiling_manager.cc index e8f41cc4..be305b3c 100644 --- a/ge/common/profiling/profiling_manager.cc +++ b/ge/common/profiling/profiling_manager.cc @@ -82,14 +82,14 @@ ProfilingManager &ProfilingManager::Instance() { return profiling_manager; } -ge::Status ProfilingManager::Init(const Options &options) { +ge::Status ProfilingManager::Init(const string &mode, const string &options, const string &job_id) { #ifdef DAVINCI_SUPPORT_PROFILING vector().swap(device_id_); subscribe_count_ = 0; - GELOGI("ProfilingManager::Init job_id:%s", options.job_id.c_str()); + GELOGI("ProfilingManager::Init job_id:%s", job_id.c_str()); struct MsprofGeOptions prof_conf = {{ 0 }}; - Status ret = InitFromOptions(options, prof_conf); + Status ret = InitFromOptions(mode, options, job_id, prof_conf); if (ret != SUCCESS) { GELOGE(ret, "[Init][Profiling]Failed, error_code %u", ret); REPORT_CALL_ERROR("E19999", "Init profiling failed, error_code %u", ret); @@ -121,25 +121,52 @@ ge::Status ProfilingManager::Init(const Options &options) { return SUCCESS; } -ge::Status ProfilingManager::InitFromOptions(const Options &options, MsprofGeOptions &prof_conf) { +void ProfilingManager::Initialize(const map &options) { + GetContext().Init(); + + auto it = options.find(OPTION_EXEC_JOB_ID); + string job_id = (it != options.end()) ? it->second : ""; + + it = options.find(OPTION_EXEC_SESSION_ID); + string session_id = (it != options.end()) ? it->second : ""; + + it = options.find(OPTION_EXEC_PROFILING_MODE); + string profiling_mode = (it != options.end()) ? it->second : ""; + + it = options.find(OPTION_EXEC_PROFILING_OPTIONS); + string profiling_options = (it != options.end()) ? it->second : ""; + + GELOGI("Init Profiling. session Id: %s", session_id.c_str()); + (void)Init(profiling_mode, profiling_options, job_id); +} + +void ProfilingManager::Finalize() { + if (ProfilingOn()) { + StopProfiling(); + PluginUnInit(); + } +} + +ge::Status ProfilingManager::InitFromOptions(const string &profiling_mode, const string &profiling_options, + const string &job_id, MsprofGeOptions &prof_conf) { #ifdef DAVINCI_SUPPORT_PROFILING // enable profiling by env char env_profiling_mode[MMPA_MAX_PATH] = { 0x00 }; is_execute_profiling_ = false; - if (options.profiling_mode == "1" && !options.profiling_options.empty()) { + if (profiling_mode == "1" && !profiling_options.empty()) { // enable profiling by ge option - if (strncpy_s(prof_conf.options, MSPROF_OPTIONS_DEF_LEN_MAX, options.profiling_options.c_str(), + if (strncpy_s(prof_conf.options, MSPROF_OPTIONS_DEF_LEN_MAX, profiling_options.c_str(), MSPROF_OPTIONS_DEF_LEN_MAX - 1) != EOK) { GELOGE(INTERNAL_ERROR, "[copy][ProfilingOptions]Failed, options %s", - options.profiling_options.c_str()); + profiling_options.c_str()); REPORT_CALL_ERROR("E19999", "Copy profiling_options %s failed", - options.profiling_options.c_str()); + profiling_options.c_str()); return INTERNAL_ERROR; } is_execute_profiling_ = true; - GELOGI("The profiling in options is %s, %s. origin option: %s", options.profiling_mode.c_str(), prof_conf.options, - options.profiling_options.c_str()); + GELOGI("The profiling in options is %s, %s. origin option: %s", profiling_mode.c_str(), prof_conf.options, + profiling_options.c_str()); } else { (void)mmGetEnv("PROFILING_MODE", env_profiling_mode, MMPA_MAX_PATH); (void)mmGetEnv("PROFILING_OPTIONS", prof_conf.options, MSPROF_OPTIONS_DEF_LEN_MAX); @@ -166,13 +193,13 @@ ge::Status ProfilingManager::InitFromOptions(const Options &options, MsprofGeOpt return ge::PARAM_INVALID; } - if (strncpy_s(prof_conf.jobId, MSPROF_OPTIONS_DEF_LEN_MAX, options.job_id.c_str(), MSPROF_OPTIONS_DEF_LEN_MAX - 1) != + if (strncpy_s(prof_conf.jobId, MSPROF_OPTIONS_DEF_LEN_MAX, job_id.c_str(), MSPROF_OPTIONS_DEF_LEN_MAX - 1) != EOK) { - GELOGE(INTERNAL_ERROR, "[Copy][JobId]Failed, original job_id %s", options.job_id.c_str()); - REPORT_CALL_ERROR("E19999", "Copy job_id %s failed", options.job_id.c_str()); + GELOGE(INTERNAL_ERROR, "[Copy][JobId]Failed, original job_id %s", job_id.c_str()); + REPORT_CALL_ERROR("E19999", "Copy job_id %s failed", job_id.c_str()); return INTERNAL_ERROR; } - GELOGI("Job id: %s, original job id: %s.", prof_conf.jobId, options.job_id.c_str()); + GELOGI("Job id: %s, original job id: %s.", prof_conf.jobId, job_id.c_str()); #endif return ge::SUCCESS; } diff --git a/ge/common/profiling/profiling_manager.h b/ge/common/profiling/profiling_manager.h index 86371d51..b9affa13 100755 --- a/ge/common/profiling/profiling_manager.h +++ b/ge/common/profiling/profiling_manager.h @@ -78,14 +78,17 @@ class ProfilingManager { ProfilingManager(); virtual ~ProfilingManager(); static ProfilingManager &Instance(); - Status Init(const Options &options); + + void Initialize(const map &options); + void Finalize(); + Status ProfInit(uint64_t module); Status ProfFinalize(); Status ProfStartProfiling(uint64_t module, const std::map &config_para); Status ProfStopProfiling(uint64_t module, const std::map &config_para); Status ProfModelSubscribe(uint64_t module, void *model); Status ProfModelUnsubscribe(void *model); - void StopProfiling(); + bool ProfilingTrainingTraceOn() const { return is_training_trace_; } // report model load profiling data flag, data contain task desc info, step info, model load fusion op info bool ProfilingModelLoadOn() const { return is_load_profiling_; } @@ -97,8 +100,7 @@ class ProfilingManager { void ProfilingTaskDescInfo(uint32_t model_id, const std::vector &task_desc_info, const int32_t &device_id); void ProfilingOpInputOutInfo(const TaskDescInfo &task, Json &task_json); - Status PluginInit(); - void PluginUnInit() const; + Status CallMsprofReport(ReporterData &reporter_data) const; struct MsprofCallback &GetMsprofCallback() { return prof_cb_; } void SetMsprofCtrlCallback(MsprofCtrlCallback func) { prof_cb_.msprofCtrlCallback = func; } @@ -118,13 +120,19 @@ class ProfilingManager { Status GetModelIdFromGraph(uint32_t graph_id, uint32_t &model_id); private: - Status InitFromOptions(const Options &options, MsprofGeOptions &prof_conf); + Status Init(const string &mode, const string &options, const string &job_id); + Status InitFromOptions(const string &mode, const string &options, const string &job_id, MsprofGeOptions &prof_conf); Status ParseOptions(const std::string &options); Status ProfParseParam(const std::map &config_para, int32_t &device_num, vector &device_list); Status ProfParseDeviceId(const std::map &config_para, vector &device_list); uint64_t GetProfilingModule(); + + void StopProfiling(); + Status PluginInit(); + void PluginUnInit() const; + void UpdateDeviceIdModuleMap(string prof_type, uint64_t module, const vector &device_list); void UpdateSubscribeDeviceModuleMap(std::string prof_type, uint32_t device_id, uint64_t module); void GetOpInputInfo(const OpDescPtr &op, TaskDescInfo &task_desc_info) const; diff --git a/ge/executor/ge_executor.cc b/ge/executor/ge_executor.cc index 76cde2b9..565b9e28 100755 --- a/ge/executor/ge_executor.cc +++ b/ge/executor/ge_executor.cc @@ -28,6 +28,7 @@ #include "graph/load/model_manager/model_manager.h" #include "graph/manager/graph_mem_manager.h" #include "graph/manager/graph_var_manager.h" +#include "graph/manager/host_mem_manager.h" #include "single_op/single_op_manager.h" #include "graph/load/model_manager/davinci_model.h" #include "opskernel_manager/ops_kernel_builder_manager.h" @@ -244,13 +245,13 @@ static void InitOpsProtoManager() { GeExecutor::GeExecutor() {} -Status GeExecutor::Initialize() { - GELOGI("Init GeExecutor begin."); +Status GeExecutor::Initialize(const std::map &options) { if (isInit_) { GELOGW("Already initialized, no need to be initialized again."); return ge::SUCCESS; } + GELOGI("Init GeExecutor begin."); OpTilingManager::GetInstance().LoadSo(); Status init_hostcpu_engine_status = HostCpuEngine::GetInstance().Initialize(); @@ -261,46 +262,61 @@ Status GeExecutor::Initialize() { InitOpsProtoManager(); - std::vector mem_type(1, RT_MEMORY_HBM); - mem_type.push_back(RT_MEMORY_P2P_DDR); - auto ret = MemManager::Instance().Initialize(mem_type); - if (ret != SUCCESS) { - GELOGE(ret, "[Initialize][MemManager] failed."); - return ret; + GE_CHK_STATUS_RET(HostMemManager::Instance().Initialize()); + + const std::vector mem_type({1, RT_MEMORY_HBM, RT_MEMORY_P2P_DDR}); + Status status = MemManager::Instance().Initialize(mem_type); + if (status != SUCCESS) { + GELOGE(status, "[Init][MemManager] MemoryAllocatorManager initialize failed."); + REPORT_CALL_ERROR("E19999", "MemManager initialize failed."); + return status; } GE_CHK_STATUS_RET(OpsKernelBuilderManager::Instance().Initialize({}, false), "[Initialize][OpsKernelBuilderManager] failed."); - // Start profiling - Options profiling_options; - profiling_options.device_id = 0; - // job id need to be set, the value is meaningless; - profiling_options.job_id = "1"; - ProfilingManager::Instance().Init(profiling_options); + const auto &model_manager = ModelManager::GetInstance(); + GE_CHECK_NOTNULL(model_manager); + status = model_manager->EnableExceptionDump(options); + if (status != SUCCESS) { + GELOGW("[Init][ModelManager] Enable exception dump failed."); + } + + ProfilingManager::Instance().Initialize(options); isInit_ = true; GELOGI("Init GeExecutor over."); - return ge::SUCCESS; + return SUCCESS; } -Status GeExecutor::Finalize() { - GELOGI("Uninit GeExecutor begin."); +Status GeExecutor::FinalizeEx() { if (isInit_ == false) { GELOGW("GeExecutor has not been initialized."); return ge::SUCCESS; } - (void) OpsKernelBuilderManager::Instance().Finalize(); + GELOGI("Uninit GeExecutor begin."); + (void)OpsKernelBuilderManager::Instance().Finalize(); - // Stop profiling - if (ProfilingManager::Instance().ProfilingOn()) { - ProfilingManager::Instance().StopProfiling(); - ProfilingManager::Instance().PluginUnInit(); - } + HostMemManager::Instance().Finalize(); + + ProfilingManager::Instance().Finalize(); GELOGI("Uninit GeExecutor over."); - return ge::SUCCESS; + return SUCCESS; +} + +Status GeExecutor::Initialize() { + // job id need to be set, the value is meaningless; + const std::map options({ + {OPTION_EXEC_JOB_ID, "1"}, {OPTION_EXEC_PROFILING_MODE, ""}, {OPTION_EXEC_PROFILING_OPTIONS, ""} + }); + + return GeExecutor::Initialize(options); +} + +Status GeExecutor::Finalize() { + return GeExecutor::FinalizeEx(); } Status GeExecutor::SetDynamicBatchSize(uint32_t model_id, void *dynamic_input_addr, uint64_t length, diff --git a/ge/graph/execute/model_executor.cc b/ge/graph/execute/model_executor.cc index bd0049dc..5cd6dc6d 100644 --- a/ge/graph/execute/model_executor.cc +++ b/ge/graph/execute/model_executor.cc @@ -55,26 +55,9 @@ Status ModelExecutor::Initialize(const map &options, uint64_t se return MEMALLOC_FAILED; } - const auto model_manager = ModelManager::GetInstance(); - GE_CHECK_NOTNULL(model_manager); - Status status = model_manager->EnableExceptionDump(options); - if (status != SUCCESS) { - return status; - } - - GE_CHK_STATUS_RET(HostMemManager::Instance().Initialize()); - - const std::vector mem_type({RT_MEMORY_HBM, RT_MEMORY_P2P_DDR}); - status = MemManager::Instance().Initialize(mem_type); - if (status != SUCCESS) { - GELOGE(status, "[Init][MemManager] MemoryAllocatorManager initialize failed."); - REPORT_CALL_ERROR("E19999", "MemManager initialize failed."); - return status; - } - size_t total_mem_size = 0; GE_CHK_STATUS_RET_NOLOG(GetTotalMemorySize(total_mem_size)); - status = VarManager::Instance(session_id)->SetMemoryMallocSize(options, total_mem_size); + Status status = VarManager::Instance(session_id)->SetMemoryMallocSize(options, total_mem_size); if (status != SUCCESS) { GELOGE(status, "[Set][MemoryMallocSize] failed."); REPORT_CALL_ERROR("E19999", "VarManager SetMemoryMallocSize failed, InnerSession:%lu.", session_id_); @@ -112,7 +95,6 @@ Status ModelExecutor::Finalize() { GELOGI("VarManager free var memory."); (void)VarManager::Instance(session_id_)->FreeVarMemory(); MemManager::Instance().FreeSessionMemory(session_id_); - HostMemManager::Instance().Finalize(); ModelManager::GetInstance()->DestroyAicpuSession(session_id_); return SUCCESS; diff --git a/ge/graph/manager/graph_var_manager.cc b/ge/graph/manager/graph_var_manager.cc index b8ed5444..558eb4ab 100755 --- a/ge/graph/manager/graph_var_manager.cc +++ b/ge/graph/manager/graph_var_manager.cc @@ -623,6 +623,7 @@ rtMemType_t VarManager::GetVarMemType(const int64_t &offset) { void VarManager::SetMemManager(MemoryManager *mem_manager) { // Better use shared_ptr instead, reconsitution later. GELOGI("Set MemManager to VarManager."); + std::lock_guard lock(mutex_); mem_manager_ = mem_manager; } diff --git a/ge/hybrid/hybrid_davinci_model_stub.cc b/ge/hybrid/hybrid_davinci_model_stub.cc deleted file mode 100644 index b8a2f242..00000000 --- a/ge/hybrid/hybrid_davinci_model_stub.cc +++ /dev/null @@ -1,115 +0,0 @@ -/** - * 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. - */ - -#include "hybrid/hybrid_davinci_model.h" - -namespace ge { -namespace hybrid { -HybridDavinciModel::~HybridDavinciModel() {} - -std::unique_ptr HybridDavinciModel::Create(const GeRootModelPtr &ge_root_model) { - return std::unique_ptr(new (std::nothrow)HybridDavinciModel()); -} - -Status HybridDavinciModel::Init() { - return UNSUPPORTED; -} - -Status HybridDavinciModel::Execute(const std::vector &inputs, - const std::vector &input_desc, - std::vector &outputs, - std::vector &output_desc, - rtStream_t stream) { - return UNSUPPORTED; -} - -Status HybridDavinciModel::Execute(const vector &inputs, vector &outputs) { - return UNSUPPORTED; -} - -Status HybridDavinciModel::ModelRunStart() { - return UNSUPPORTED; -} - -Status HybridDavinciModel::ModelRunStop() { - return UNSUPPORTED; -} - -Status HybridDavinciModel::EnqueueData(const shared_ptr &data) { - return UNSUPPORTED; -} - -void HybridDavinciModel::SetListener(const shared_ptr &listener) { -} - -void HybridDavinciModel::SetModelId(uint32_t model_id) { -} - -void HybridDavinciModel::SetDeviceId(uint32_t device_id) { -} - -void HybridDavinciModel::SetOmName(const string &om_name) { -} - -uint64_t HybridDavinciModel::GetSessionId() { - return 0; -} - -uint32_t HybridDavinciModel::GetDataInputerSize() { - return 0; -} - -uint32_t HybridDavinciModel::GetDeviceId() const { - return 0; -} - -Status HybridDavinciModel::GetDynamicBatchInfo(std::vector> &batch_info, int32_t &dynamic_type) { - return UNSUPPORTED; -} - -void HybridDavinciModel::GetUserDesignateShapeOrder(std::vector &user_input_shape_order) { -} - -void HybridDavinciModel::GetModelAttr(std::vector &dynamic_output_shape_info) { -} - -Status HybridDavinciModel::GetInputOutputDescInfo(vector &input_desc, - vector &output_desc, - std::vector &input_formats, - std::vector &output_formats) { - return UNSUPPORTED; -} - -void HybridDavinciModel::SetModelDescVersion(bool is_new_model_desc) { -} - -bool HybridDavinciModel::GetRunningFlag() const { - return false; -} - -Status HybridDavinciModel::SetRunAsyncListenerCallback(const RunAsyncCallback &callback) { - return UNSUPPORTED; -} - -bool HybridDavinciModel::GetOpDescInfo(uint32_t stream_id, uint32_t task_id, OpDescInfo &op_desc_info) const { - return true; -} -Status HybridDavinciModel::GetOpAttr(const std::string &op_name, const std::string &attr_name, - std::string &attr_value) const { - return UNSUPPORTED; -} -} // namespace hybrid -} // namespace ge \ No newline at end of file diff --git a/ge/init/gelib.cc b/ge/init/gelib.cc index 710e81af..8a562e04 100644 --- a/ge/init/gelib.cc +++ b/ge/init/gelib.cc @@ -192,7 +192,7 @@ Status GELib::SystemInitialize(const map &options) { InitOptions(options); // In train and infer, profiling is always needed. - InitProfiling(this->options_); + ProfilingManager::Instance().Initialize(options); // 1.`is_train_mode_` means case: train // 2.`(!is_train_mode_) && (options_.device_id != kDefaultDeviceIdForInfer)` means case: online infer // these two case with logical device id @@ -204,16 +204,6 @@ Status GELib::SystemInitialize(const map &options) { return status; } -void GELib::InitProfiling(Options &options) { - GELOGI("Init Profiling. session Id: %ld, device id:%d ", options.session_id, options.device_id); - std::lock_guard lock(status_mutex_); - GetContext().Init(); - // Profiling init - if (ProfilingManager::Instance().Init(options) != SUCCESS) { - GELOGW("Profiling init failed."); - } -} - void GELib::SetDefaultPrecisionMode(map &new_options) { auto iter = new_options.find(PRECISION_MODE); if (iter != new_options.end()) { @@ -433,7 +423,7 @@ Status GELib::Finalize() { Analyzer::GetInstance()->Finalize(); // Shut down profiling - ShutDownProfiling(); + ProfilingManager::Instance().Finalize(); if (is_train_mode_ || (options_.device_id != kDefaultDeviceIdForInfer)) { GELOGI("System ShutDown."); @@ -463,15 +453,6 @@ Status GELib::Finalize() { return SUCCESS; } -void GELib::ShutDownProfiling() { - std::lock_guard lock(status_mutex_); - - if (ProfilingManager::Instance().ProfilingOn()) { - ProfilingManager::Instance().StopProfiling(); - ProfilingManager::Instance().PluginUnInit(); - } -} - // Get Singleton Instance std::shared_ptr GELib::GetInstance() { return instancePtr_; } diff --git a/ge/init/gelib.h b/ge/init/gelib.h index 226dd4c8..48c887ed 100644 --- a/ge/init/gelib.h +++ b/ge/init/gelib.h @@ -61,12 +61,6 @@ class GE_FUNC_VISIBILITY GELib { // get Initial flag bool InitFlag() const { return init_flag_; } - // get TrainMode flag - bool IsTrainMode() { return is_train_mode_; } - - void InitProfiling(Options &options); - void ShutDownProfiling(); - Status InitSystemWithoutOptions(); Status InitSystemWithOptions(Options &options); Status SystemShutdownWithOptions(const Options &options); diff --git a/inc/framework/executor/ge_executor.h b/inc/framework/executor/ge_executor.h index fcca561c..48a85cc5 100644 --- a/inc/framework/executor/ge_executor.h +++ b/inc/framework/executor/ge_executor.h @@ -50,9 +50,26 @@ class GE_FUNC_VISIBILITY GeExecutor { public: GeExecutor(); ~GeExecutor() = default; + ge::Status Initialize(); ge::Status Finalize(); + /// + /// @ingroup ge + /// @brief Initialize global execute environment. + /// @param [in] options: environment variables. + /// @return init result + /// + static Status Initialize(const std::map &options); + + /// + /// @ingroup ge + /// @brief Finalize global execute environment. + /// @param [in] model_id: model id allocate from manager + /// @return execute result + /// + static Status FinalizeEx(); + ge::Status UnloadModel(uint32_t modelId); // Get input and output descriptor diff --git a/tests/ut/ge/CMakeLists.txt b/tests/ut/ge/CMakeLists.txt index 4d47b5bb..94140033 100755 --- a/tests/ut/ge/CMakeLists.txt +++ b/tests/ut/ge/CMakeLists.txt @@ -249,12 +249,7 @@ set(GRAPH_DAVINCI_MODEL_SRC_FILES "${GE_CODE_DIR}/ge/hybrid/node_executor/aicpu/aicpu_ext_info.cc" ) -set(GRAPH_EXECUTE_COMMON_SRC_FILES - "${GE_CODE_DIR}/ge/hybrid/hybrid_davinci_model_stub.cc" -) - set(GRAPH_BUILD_COMMON_SRC_FILES - "${GE_CODE_DIR}/ge/graph/manager/graph_manager.cc" "${GE_CODE_DIR}/ge/client/ge_api.cc" "${GE_CODE_DIR}/ge/session/inner_session.cc" "${GE_CODE_DIR}/ge/session/session_manager.cc" @@ -263,6 +258,7 @@ set(GRAPH_BUILD_COMMON_SRC_FILES "${GE_CODE_DIR}/ge/plugin/engine/dnnengines.cc" "${GE_CODE_DIR}/ge/plugin/engine/engine_manage.cc" "${GE_CODE_DIR}/ge/graph/manager/graph_context.cc" + "${GE_CODE_DIR}/ge/graph/manager/graph_manager.cc" ) set(GRAPH_PASS_COMMON_SRC_FILES @@ -856,25 +852,6 @@ target_link_libraries(ge_davinci_model PRIVATE json ) -# build graph execute common -add_library(ge_execute_common STATIC ${GRAPH_EXECUTE_COMMON_SRC_FILES} ${PROTO_HDRS}) - -target_compile_definitions(ge_execute_common PRIVATE - google=ascend_private -) - -target_compile_options(ge_execute_common PRIVATE - -g --coverage -fprofile-arcs -ftest-coverage - -Werror=format -) - -target_link_libraries(ge_execute_common PRIVATE - $ - c_sec - json - ascend_protobuf -) - # build graph build common add_library(ge_build_common STATIC ${GRAPH_BUILD_COMMON_SRC_FILES} ${PROTO_HDRS}) @@ -953,7 +930,7 @@ target_compile_definitions(ut_libge_multiparts_utest PRIVATE target_link_libraries(ut_libge_multiparts_utest $ -Wl,--whole-archive - ge_davinci_model ge_build_common ge_prepare_common ge_execute_common ge_pass_common ge_ut_common_format ge_ut_common + ge_davinci_model ge_build_common ge_prepare_common ge_single_op ge_pass_common ge_ut_common_format ge_ut_common -Wl,--no-whole-archive gtest gtest_main gmock gmock_main ${COMMON_SHARED_LIBRARIES} -lrt -ldl -lgcov ) @@ -975,7 +952,7 @@ target_compile_options(ut_libge_others_utest PRIVATE target_link_libraries(ut_libge_others_utest $ -Wl,--whole-archive - ge_davinci_model ge_build_common ge_prepare_common ge_pass_common ge_execute_common ge_ut_common ge_ut_common_format + ge_davinci_model ge_build_common ge_prepare_common ge_pass_common ge_single_op ge_ut_common ge_ut_common_format -Wl,--no-whole-archive gtest gtest_main gmock gmock_main ${COMMON_SHARED_LIBRARIES} -lrt -ldl -lgcov ) @@ -995,7 +972,7 @@ target_compile_options(ut_libge_kernel_utest PRIVATE target_link_libraries(ut_libge_kernel_utest $ -Wl,--whole-archive - ge_davinci_model ge_build_common ge_prepare_common ge_pass_common ge_execute_common ge_ut_common ge_ut_common_format + ge_davinci_model ge_build_common ge_prepare_common ge_pass_common ge_single_op ge_ut_common ge_ut_common_format -Wl,--no-whole-archive gtest gtest_main gmock gmock_main ${COMMON_SHARED_LIBRARIES} -lrt -ldl -lgcov ) diff --git a/tests/ut/ge/profiling/ge_profiling_manager_unittest.cc b/tests/ut/ge/profiling/ge_profiling_manager_unittest.cc index 35879df8..a90ff89e 100644 --- a/tests/ut/ge/profiling/ge_profiling_manager_unittest.cc +++ b/tests/ut/ge/profiling/ge_profiling_manager_unittest.cc @@ -31,8 +31,6 @@ #include "graph/manager/graph_manager.h" #include "graph/ops_stub.h" #include "inc/framework/omg/omg_inner_types.h" -#undef protected -#undef private using namespace ge; using namespace std; @@ -76,10 +74,21 @@ TEST_F(UtestGeProfilinganager, init_success) { struct MsprofGeOptions prof_conf = {{ 0 }}; - Status ret = ProfilingManager::Instance().InitFromOptions(options, prof_conf); + Status ret = ProfilingManager::Instance().InitFromOptions(options.profiling_mode, options.profiling_options, options.job_id, prof_conf); EXPECT_EQ(ret, ge::SUCCESS); } +TEST_F(UtestGeProfilinganager, initialize) { + setenv("PROFILING_MODE", "true", true); + + const std::map options({ + {OPTION_EXEC_JOB_ID, "0"}, {OPTION_EXEC_PROFILING_MODE, "1"}, {OPTION_EXEC_PROFILING_OPTIONS, R"({"result_path":"/data/profiling","training_trace":"on","task_trace":"on","aicpu_trace":"on","fp_point":"Data_0","bp_point":"addn","ai_core_metrics":"ResourceConflictRatio"})"} + }); + + ProfilingManager::Instance().Initialize(options); + EXPECT_FALSE(ProfilingManager::Instance().is_execute_profiling_); +} + TEST_F(UtestGeProfilinganager, ParseOptions) { setenv("PROFILING_MODE", "true", true); Options options;