From d4e052be471e480ff8a11a2d87fd52ff394d95e6 Mon Sep 17 00:00:00 2001 From: zhupuxu Date: Fri, 9 Jul 2021 17:49:27 +0800 Subject: [PATCH] graph id to r1.5 Signed-off-by: zhupuxu --- ge/common/profiling/ge_profiling.cc | 56 ++++++++++++--- ge/common/profiling/profiling_manager.cc | 52 +++++++++++++- ge/common/profiling/profiling_manager.h | 19 ++++++ ge/graph/execute/graph_execute.cc | 44 +++++++++++- ge/graph/execute/graph_execute.h | 5 ++ ge/graph/load/model_manager/davinci_model.cc | 13 +++- ge/graph/load/model_manager/model_manager.cc | 22 ++++-- ge/graph/manager/graph_manager.cc | 2 + ge/session/inner_session.cc | 4 ++ ge/single_op/single_op.cc | 2 +- inc/framework/common/profiling/ge_profiling.h | 2 + .../ut/ge/graph/execute/graph_execute_unittest.cc | 44 ++++++++++++ tests/ut/ge/graph/load/model_manager_unittest.cc | 30 +++++++- .../ge/profiling/ge_profiling_manager_unittest.cc | 79 ++++++++++++++++++++++ tests/ut/ge/session/inner_session_unittest.cc | 14 ++++ 15 files changed, 364 insertions(+), 24 deletions(-) diff --git a/ge/common/profiling/ge_profiling.cc b/ge/common/profiling/ge_profiling.cc index 48d12609..4d21cff9 100644 --- a/ge/common/profiling/ge_profiling.cc +++ b/ge/common/profiling/ge_profiling.cc @@ -20,9 +20,11 @@ #include "framework/common/debug/ge_log.h" #include "framework/common/debug/log.h" #include "graph/load/graph_loader.h" +#include "graph/ge_context.h" #include "init/gelib.h" #include "framework/common/ge_inner_error_codes.h" #include "model/ge_model.h" +#include "framework/omg/omg_inner_types.h" namespace { const uint32_t kDeviceListIndex = 3; @@ -35,6 +37,7 @@ const std::string kProfilingStop = "prof_stop"; const std::string kProfModelSubscribe = "prof_model_subscribe"; const std::string kProfModelUnsubscribe = "prof_model_cancel_subscribe"; const std::string kRtSetDeviceRegName = "profiling"; +const std::string kPofilingModelId = "modelId"; const std::map kProfCommandTypeMap = { {kProfCommandhandleInit, kProfilingInit}, @@ -47,6 +50,22 @@ const std::map kProfCommandTypeMap = { const uint64_t kModelId = ge::INVALID_MODEL_ID; const uint16_t kStepStart = 0; const uint16_t kStepEnd = 1; + +ge::Status NeedUnsubscribe(ProfCommandHandleType type, bool is_subscribe, + uint32_t graph_id, vector &prof_params) { + if (type == kProfCommandhandleModelUnsubscribe && is_subscribe) { + prof_params.clear(); + prof_params.emplace_back(kPofilingModelId); + uint32_t model_id = 0; + auto ret = ge::ProfilingManager::Instance().GetModelIdFromGraph(graph_id, model_id); + if (ret != ge::SUCCESS) { + GELOGE(ret, "graph_id:%u not not found", graph_id); + return ret; + } + prof_params.emplace_back(std::to_string(model_id)); + } + return ge::SUCCESS; +} } // namespace bool TransProfConfigToParam(const ProfCommandHandleData &profCommand, vector &prof_config_params) { @@ -195,6 +214,24 @@ ge::Status ProfCommandHandle(ProfCommandHandleType type, void *data, uint32_t le return ge::PARAM_INVALID; } } + auto &profiling_manager = ge::ProfilingManager::Instance(); + auto is_train = domi::GetContext().train_flag; + if (type == kProfCommandhandleModelSubscribe && is_train) { + profiling_manager.SetSubscribeInfo(prof_config_param->profSwitch, prof_config_param->modelId, true); + return ge::SUCCESS; + } + auto is_subscribe = profiling_manager.GetSubscribeInfo().is_subscribe; + // GraphId is actually stored in prof_config_param + auto graph_id = prof_config_param->modelId; + ge::Status ret = NeedUnsubscribe(type, is_subscribe, graph_id, prof_params); + if (ret != ge::SUCCESS) { + GELOGE(ret, "graph_id:%u not not found", graph_id); + REPORT_INPUT_ERROR("E10001", std::vector({"value", "parameter", "reason"}), + std::vector({std::to_string(graph_id), + "GraphToModelMap", + "graph_id does not exist!"})); + return ge::FAILED; + } ge::GraphLoader graph_loader; ge::Command command; command.cmd_params.clear(); @@ -208,7 +245,7 @@ ge::Status ProfCommandHandle(ProfCommandHandleType type, void *data, uint32_t le if (type == kProfCommandhandleStart || type == kProfCommandhandleStop) { GELOGI("Profiling device nums:%s , deviceID:[%s]", prof_params[0].c_str(), prof_params[kDeviceListIndex].c_str()); } - ge::Status ret = graph_loader.CommandHandle(command); + ret = graph_loader.CommandHandle(command); if (ret != ge::SUCCESS) { GELOGE(ret, "[Handle][Command]Handle profiling command failed, command type %s, error_code %u", iter->second.c_str(), ret); @@ -230,21 +267,14 @@ ge::Status ProfSetStepInfo(uint64_t index_id, uint16_t tag_id, rtStream_t stream REPORT_CALL_ERROR("E19999", "Get logic device id failed, ret 0x%X", rt_ret); return ge::FAILED; } + auto &profiling_manager = ge::ProfilingManager::Instance(); if (is_first_run && tag_id == kStepStart) { - GE_CHK_STATUS_RET_NOLOG(ge::ProfilingManager::Instance().ProfileStepInfo(index_id, - kModelId, - tag_id, - stream, - device_id)); + GE_CHK_STATUS_RET_NOLOG(profiling_manager.ProfileStepInfo(index_id, kModelId, tag_id, stream, device_id)); is_first_run = false; return ge::SUCCESS; } if (!is_first_run && tag_id == kStepEnd) { - GE_CHK_STATUS_RET_NOLOG(ge::ProfilingManager::Instance().ProfileStepInfo(index_id, - kModelId, - tag_id, - stream, - device_id)); + GE_CHK_STATUS_RET_NOLOG(profiling_manager.ProfileStepInfo(index_id, kModelId, tag_id, stream, device_id)); is_first_run = true; return ge::SUCCESS; } @@ -254,3 +284,7 @@ ge::Status ProfSetStepInfo(uint64_t index_id, uint16_t tag_id, rtStream_t stream "tag id must be 0 when first run, must be 1 when second run"})); return ge::FAILED; } + +ge::Status ProfGetDeviceFormGraphId(uint32_t graph_id, uint32_t &device_id) { + return ge::ProfilingManager::Instance().GetDeviceIdFromGraph(graph_id, device_id); +} diff --git a/ge/common/profiling/profiling_manager.cc b/ge/common/profiling/profiling_manager.cc index 61210de6..4d897700 100644 --- a/ge/common/profiling/profiling_manager.cc +++ b/ge/common/profiling/profiling_manager.cc @@ -66,9 +66,13 @@ const std::string kIdx = "idx"; namespace ge { ProfilingManager::ProfilingManager() - : is_load_profiling_(false), is_execute_profiling_(false), is_training_trace_(false), subscribe_count_(0) { - prof_cb_.msprofCtrlCallback = nullptr; - prof_cb_.msprofReporterCallback = nullptr; + : is_load_profiling_(false), + is_execute_profiling_(false), + is_training_trace_(false), + subscribe_count_(0), + prof_cb_({nullptr, nullptr}), + cur_iter_num_(UINT64_MAX), + subscribe_info_({false, 0, 0}) { } ProfilingManager::~ProfilingManager() {} @@ -323,6 +327,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::Profilin FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfileStepInfo( uint64_t index_id, uint64_t model_id, uint16_t tag_id, rtStream_t stream, int32_t device_id) { #ifdef DAVINCI_SUPPORT_PROFILING + cur_iter_num_ = index_id; if (!is_load_profiling_ && subscribe_count_ == 0) { GELOGD("Profiling is not turned on, no need to profile step info."); return SUCCESS; @@ -604,10 +609,13 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfFi is_load_profiling_ = false; is_training_trace_ = false; is_execute_profiling_ = false; + cur_iter_num_ = UINT64_MAX; // profiling plugin uninit PluginUnInit(); + CleanSubscribeInfo(); + int32_t dev_num = -1; rtError_t rt_ret = rtProfilerStop(PROF_MODEL_LOAD_MASK, dev_num, nullptr); if (rt_ret != RT_ERROR_NONE) { @@ -630,6 +638,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfFi } device_id_module_map_.clear(); device_id_.clear(); + device_id_map_.clear(); + model_id_map_.clear(); GELOGI("Prof finalize success."); #endif return SUCCESS; @@ -1055,4 +1065,40 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::GetFpBpP return; } +FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::GetDeviceIdFromGraph( + uint32_t graph_id, uint32_t &device_id) { + auto iter = device_id_map_.find(graph_id); + if (iter != device_id_map_.end()) { + device_id = iter->second; + return SUCCESS; + } + REPORT_CALL_ERROR("E19999", "graph_id:%u does not exist!", graph_id); + GELOGE(PARAM_INVALID, "[Check][GraphId]graph_id:%u does not exist!", graph_id); + return FAILED; +} + +FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::SetSubscribeInfo( + uint64_t prof_switch, uint32_t model_id, bool is_subscribe) { + subscribe_info_.is_subscribe = is_subscribe; + subscribe_info_.prof_switch = prof_switch; + subscribe_info_.graph_id = model_id; +} + +FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::CleanSubscribeInfo() { + subscribe_info_.is_subscribe = false; + subscribe_info_.prof_switch = 0; + subscribe_info_.graph_id = 0; +} + +FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::GetModelIdFromGraph( + uint32_t graph_id, uint32_t &model_id) { + auto iter = model_id_map_.find(graph_id); + if (iter != model_id_map_.end()) { + model_id = iter->second; + return SUCCESS; + } + REPORT_CALL_ERROR("E19999", "graph_id:%u does not exist!", graph_id); + GELOGE(PARAM_INVALID, "[Check][GraphId]graph_id:%u does not exist!", graph_id); + return FAILED; +} } // namespace ge diff --git a/ge/common/profiling/profiling_manager.h b/ge/common/profiling/profiling_manager.h index 049a4df4..c8cc415a 100755 --- a/ge/common/profiling/profiling_manager.h +++ b/ge/common/profiling/profiling_manager.h @@ -62,6 +62,12 @@ struct DeviceSubsInfo { uint32_t subscribe_count; }; +struct ProfSubscribeInfo { + bool is_subscribe; + uint64_t prof_switch; + uint32_t graph_id; +}; + struct MsprofCallback { MsprofCtrlCallback msprofCtrlCallback; MsprofReporterCallback msprofReporterCallback; @@ -101,6 +107,15 @@ class FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ProfilingManager { void GetOpInputOutputInfo(const OpDescPtr &op, TaskDescInfo &task_desc_info) const; void ReportData(const int32_t &device_id, const std::string &data, const std::string &tag_name); Status ProfileStepInfo(uint64_t index_id, uint64_t model_id, uint16_t tag_id, rtStream_t stream, int32_t device_id); + uint64_t GetCurIterNum() const { return cur_iter_num_; } + void SetGraphIdToDeviceMap(uint32_t graph_id, uint32_t device_id) { device_id_map_[graph_id] = device_id; } + Status GetDeviceIdFromGraph(uint32_t graph_id, uint32_t &device_id); + void SetSubscribeInfo(uint64_t prof_switch, uint32_t model_id, bool is_subscribe); + const ProfSubscribeInfo &GetSubscribeInfo() const { return subscribe_info_; } + void CleanSubscribeInfo(); + void SetGraphIdToModelMap(uint32_t graph_id, uint32_t model_id) { model_id_map_[graph_id] = model_id; } + Status GetModelIdFromGraph(uint32_t graph_id, uint32_t &model_id); + private: Status InitFromOptions(const Options &options, MsprofGeOptions &prof_conf); Status ParseOptions(const std::string &options); @@ -127,6 +142,10 @@ class FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ProfilingManager { std::string fp_point_; std::string bp_point_; uint32_t reporter_max_len_ = 0; + uint64_t cur_iter_num_; + std::map device_id_map_; // key: graph_id, value: device_id + std::map model_id_map_; // key: graph_id, value: model_id + ProfSubscribeInfo subscribe_info_; }; } // namespace ge #endif // GE_COMMON_PROFILING_PROFILING_MANAGER_H_ diff --git a/ge/graph/execute/graph_execute.cc b/ge/graph/execute/graph_execute.cc index 02d7d3ca..12dd89a2 100755 --- a/ge/graph/execute/graph_execute.cc +++ b/ge/graph/execute/graph_execute.cc @@ -21,6 +21,7 @@ #include "graph/load/model_manager/model_manager.h" #include "graph/load/model_manager/davinci_model.h" +#include "common/profiling/profiling_manager.h" namespace ge { using Uint32Pair = pair; @@ -376,7 +377,11 @@ Status GraphExecutor::ExecuteGraph(GraphId graph_id, const GeRootModelPtr &ge_ro GELOGE(GE_GRAPH_SYNC_MODEL_FAILED, "[SyncExecute][Model] Error! graph id:%u", graph_id); return GE_GRAPH_SYNC_MODEL_FAILED; } - + ret = ModelSubscribe(graph_id); + if (ret != SUCCESS) { + GELOGE(ret, "[Call][ModelSubscribe] failed, graph_id:%u", graph_id); + return ret; + } return SUCCESS; } @@ -787,4 +792,41 @@ Status GraphExecutor::GetOpDescInfo(uint32_t device_id, uint32_t stream_id, uint } return SUCCESS; } + +Status GraphExecutor::GetModelByID(uint32_t model_id, std::shared_ptr &davinci_model) { + auto model_manager = ge::ModelManager::GetInstance(); + GE_CHECK_NOTNULL(model_manager); + davinci_model = model_manager->GetModel(static_cast(model_id)); + if (davinci_model == nullptr) { + REPORT_INNER_ERROR("E19999", "GetModel from model_manager fail, model_id:%u", model_id); + GELOGE(ge::FAILED, "[Get][Model] failed, Model id:%d is invaild or model is not loaded.", model_id); + return ge::FAILED; + } + return ge::SUCCESS; +} + +Status GraphExecutor::ModelSubscribe(uint32_t graph_id) { + auto &profiling_manager = ProfilingManager::Instance(); + const auto &subcribe_info = profiling_manager.GetSubscribeInfo(); + if (subcribe_info.is_subscribe) { + std::shared_ptr davinci_model = nullptr; + uint32_t model_id = 0; + Status ret = profiling_manager.GetModelIdFromGraph(graph_id, model_id); + if (ret != SUCCESS) { + GELOGE(ret, "[Call][GetModelIdFromGraph] failed, graph_id:%u", graph_id); + return ret; + } + ret = GetModelByID(model_id, davinci_model); + if (ret != SUCCESS) { + GELOGE(ret, "[Call][GetModelByID] failed, model_id:%u", model_id); + return ret; + } + ret = profiling_manager.ProfModelSubscribe(subcribe_info.prof_switch, davinci_model.get()); + if (ret != SUCCESS) { + GELOGE(ret, "[Call][ProfModelSubscribe] failed"); + return ret; + } + } + return SUCCESS; +} } // namespace ge diff --git a/ge/graph/execute/graph_execute.h b/ge/graph/execute/graph_execute.h index aa791c9b..fd109790 100755 --- a/ge/graph/execute/graph_execute.h +++ b/ge/graph/execute/graph_execute.h @@ -38,6 +38,7 @@ #include "graph/model.h" #include "graph/utils/graph_utils.h" #include "graph/utils/tensor_utils.h" +#include "graph/load/model_manager/davinci_model.h" namespace ge { class GraphExecutor { @@ -150,6 +151,10 @@ class GraphExecutor { static Status SetCallback(uint32_t model_id, const GeRootModelPtr &ge_root_model, const RunAsyncCallback &callback); + Status ModelSubscribe(uint32_t graph_id); + + Status GetModelByID(uint32_t model_id, std::shared_ptr &davinci_model); + bool init_flag_; bool train_graph_flag_; diff --git a/ge/graph/load/model_manager/davinci_model.cc b/ge/graph/load/model_manager/davinci_model.cc index 2ce6c1d8..b638f62d 100755 --- a/ge/graph/load/model_manager/davinci_model.cc +++ b/ge/graph/load/model_manager/davinci_model.cc @@ -62,6 +62,7 @@ #include "graph/common/omg_util.h" #include "graph/build/memory/block_mem_assigner.h" #include "graph/manager/session_scope_mem_allocator.h" +#include "framework/omg/omg_inner_types.h" // create std::thread, catch exceptions using try/catch #define CREATE_STD_THREAD(thread_id, func, args) \ @@ -764,8 +765,16 @@ void DavinciModel::SaveSpecifyAttrValues(const OpDescPtr &op_desc) { } Status DavinciModel::ReportProfilingData() { - ProfilingManager::Instance().ReportProfilingData(model_id_, GetTaskDescInfo()); - GE_CHK_STATUS(SinkModelProfile(), "[Sink][ModelProfile] failed, model_id:%u.", model_id_); + bool is_train = domi::GetContext().train_flag; + auto model_id = model_id_; + auto &profiling_manager = ProfilingManager::Instance(); + auto graph_id = runtime_param_.graph_id; + if (is_train) { + GELOGD("Replace model_id:%u with graph_id:%u, when training.", model_id, graph_id); + model_id = graph_id; + } + profiling_manager.ReportProfilingData(model_id, GetTaskDescInfo()); + GE_CHK_STATUS(SinkModelProfile(), "[Sink][ModelProfile] failed, model_id:%u.", model_id); return SUCCESS; } diff --git a/ge/graph/load/model_manager/model_manager.cc b/ge/graph/load/model_manager/model_manager.cc index 99959cfb..1d41d5c2 100755 --- a/ge/graph/load/model_manager/model_manager.cc +++ b/ge/graph/load/model_manager/model_manager.cc @@ -368,7 +368,17 @@ Status ModelManager::LoadModelOnline(uint32_t &model_id, const shared_ptrGetRuntimeParam().graph_id; + if (subcribe_info.graph_id == graph_id) { + profiling_manager.SetGraphIdToModelMap(graph_id, model_id); + } + else { + GELOGW("graph_id:%u is not in subcribe info.", graph_id); + } + } return ret; } @@ -759,12 +769,15 @@ Status ModelManager::HandleProfModelUnsubscribeCommand(const Command &command) { if (ret != SUCCESS) { return ret; } - - if (ProfilingManager::Instance().ProfModelUnsubscribe(static_cast(davinci_model.get())) != SUCCESS) { + auto &profiling_manager = ProfilingManager::Instance(); + if (profiling_manager.ProfModelUnsubscribe(static_cast(davinci_model.get())) != SUCCESS) { GELOGE(FAILED, "[Handle][ProfModelUnsubscribe] failed."); return FAILED; } - + auto is_subscribe = profiling_manager.GetSubscribeInfo().is_subscribe; + if (is_subscribe) { + profiling_manager.CleanSubscribeInfo(); + } return SUCCESS; } @@ -1827,5 +1840,4 @@ Status ModelManager::CheckAicpuOpList(GeModelPtr ge_model) { "[Call][LaunchKernelCheckAicpuOp] failed."); return SUCCESS; } - } // namespace ge diff --git a/ge/graph/manager/graph_manager.cc b/ge/graph/manager/graph_manager.cc index 0b27fdf3..f23f9bb7 100755 --- a/ge/graph/manager/graph_manager.cc +++ b/ge/graph/manager/graph_manager.cc @@ -1853,6 +1853,8 @@ Status GraphManager::ParseTrainGraphFlag(const bool &run_flag, bool &train_flag) GELOGW("Key:ge.runFlag, its value %d is invalid, it must be 1 when GElib::is_train_mode_ flag is 1", run_flag); } } + domi::GetContext().train_flag = train_flag; + GELOGI("Is train flag: %d.", train_flag); return SUCCESS; } diff --git a/ge/session/inner_session.cc b/ge/session/inner_session.cc index f82bcc80..1181f440 100755 --- a/ge/session/inner_session.cc +++ b/ge/session/inner_session.cc @@ -36,6 +36,7 @@ #include "graph/utils/tensor_adapter.h" #include "runtime/mem.h" #include "ir_build/option_utils.h" +#include "common/profiling/profiling_manager.h" namespace ge { namespace { @@ -195,6 +196,9 @@ Status InnerSession::GetVariable(const std::string &name, Tensor &val) { Status InnerSession::AddGraph(uint32_t graph_id, const Graph &graph) { std::map options; + auto device_id = GetContext().DeviceId(); + GELOGD("Device id is %u", device_id); + ProfilingManager::Instance().SetGraphIdToDeviceMap(graph_id, device_id); return AddGraph(graph_id, graph, options); } diff --git a/ge/single_op/single_op.cc b/ge/single_op/single_op.cc index d09e8398..f6c6731e 100755 --- a/ge/single_op/single_op.cc +++ b/ge/single_op/single_op.cc @@ -58,7 +58,7 @@ Status ProfilingTaskInfo(OpTask *op_task, const string &shape_type) { tmp_task_desc_info.op_name.c_str(), tmp_task_desc_info.model_name.c_str()); tmp_task_desc_info.shape_type = shape_type; - tmp_task_desc_info.cur_iter_num = 0; + tmp_task_desc_info.cur_iter_num = ProfilingManager::Instance().GetCurIterNum(); tmp_task_desc_info.task_type = op_task->GetTaskType(); std::vector task_desc_info; diff --git a/inc/framework/common/profiling/ge_profiling.h b/inc/framework/common/profiling/ge_profiling.h index 7a238b2f..c87c082c 100644 --- a/inc/framework/common/profiling/ge_profiling.h +++ b/inc/framework/common/profiling/ge_profiling.h @@ -50,4 +50,6 @@ GE_FUNC_VISIBILITY ge::Status ProfCommandHandle(ProfCommandHandleType type, void /// GE_FUNC_VISIBILITY ge::Status ProfSetStepInfo(uint64_t index_id, uint16_t tag_id, rtStream_t stream); +GE_FUNC_VISIBILITY ge::Status ProfGetDeviceFormGraphId(uint32_t graph_id, uint32_t &device_id); + #endif // INC_FRAMEWORK_COMMON_GE_PROFILING_H_ diff --git a/tests/ut/ge/graph/execute/graph_execute_unittest.cc b/tests/ut/ge/graph/execute/graph_execute_unittest.cc index 6d982454..3e32405b 100644 --- a/tests/ut/ge/graph/execute/graph_execute_unittest.cc +++ b/tests/ut/ge/graph/execute/graph_execute_unittest.cc @@ -17,6 +17,8 @@ #include #include +#include "common/profiling/profiling_manager.h" + #define protected public #define private public #include "graph/execute/graph_execute.h" @@ -125,4 +127,46 @@ TEST_F(UtestGraphExecuteTest, test_set_callback) { auto status = executor.SetCallback(1, ge_root_model, callback); EXPECT_EQ(status, SUCCESS); } + +TEST_F(UtestGraphExecuteTest, test_without_subscribe) { + GraphExecutor executor; + auto ret = executor.ModelSubscribe(1); + EXPECT_EQ(ret, SUCCESS); +} + +TEST_F(UtestGraphExecuteTest, test_with_subscribe_failed1) { + GraphExecutor executor; + uint32_t graph_id = 1; + auto &profiling_manager = ProfilingManager::Instance(); + profiling_manager.SetSubscribeInfo(0, 1, true); + auto ret = executor.ModelSubscribe(graph_id); + profiling_manager.CleanSubscribeInfo(); + EXPECT_NE(ret, SUCCESS); +} + +TEST_F(UtestGraphExecuteTest, test_with_subscribe_failed2) { + GraphExecutor executor; + uint32_t graph_id = 1; + uint32_t model_id = 1; + auto &profiling_manager = ProfilingManager::Instance(); + profiling_manager.SetSubscribeInfo(0, 1, true); + profiling_manager.SetGraphIdToModelMap(2, model_id); + auto ret = executor.ModelSubscribe(graph_id); + profiling_manager.CleanSubscribeInfo(); + EXPECT_NE(ret, SUCCESS); +} + +TEST_F(UtestGraphExecuteTest, test_with_subscribe_success) { + GraphExecutor executor; + uint32_t graph_id = 1; + uint32_t model_id = 1; + GraphNodePtr graph_node = std::make_shared(graph_id); + DavinciModel model(model_id, nullptr); + auto &profiling_manager = ProfilingManager::Instance(); + profiling_manager.SetSubscribeInfo(0, 1, true); + profiling_manager.SetGraphIdToModelMap(graph_id, model_id); + auto ret = executor.ModelSubscribe(graph_id); + profiling_manager.CleanSubscribeInfo(); + EXPECT_EQ(ret, SUCCESS); +} } // namespace ge \ No newline at end of file diff --git a/tests/ut/ge/graph/load/model_manager_unittest.cc b/tests/ut/ge/graph/load/model_manager_unittest.cc index d9e4eabd..10c2273b 100644 --- a/tests/ut/ge/graph/load/model_manager_unittest.cc +++ b/tests/ut/ge/graph/load/model_manager_unittest.cc @@ -26,6 +26,7 @@ #include "graph/load/graph_loader.h" #include "graph/load/model_manager/davinci_model.h" #include "graph/ops_stub.h" +#include "common/profiling/profiling_manager.h" using namespace std; using namespace testing; @@ -166,7 +167,8 @@ class UtestModelManagerModelManager : public testing::Test { class DModelListener : public ModelListener { public: DModelListener(){}; - uint32_t OnComputeDone(uint32_t model_id, uint32_t data_index, uint32_t resultCode) { return 0; } + uint32_t OnComputeDone(uint32_t model_id, uint32_t data_index, + uint32_t resultCode, std::vector &outputs) { return 0; } }; TEST_F(UtestModelManagerModelManager, case_is_need_hybrid_load) { @@ -456,4 +458,30 @@ TEST_F(UtestModelManagerModelManager, test_launch_kernel_cust_aicpu) { EXPECT_EQ(mm.LaunchKernelCustAicpuSo("deleteCustOp"), SUCCESS); EXPECT_TRUE(mm.cust_aicpu_so_.empty()); } + +shared_ptr listerner(new DModelListener()); +TEST_F(UtestModelManagerModelManager, test_load_model_online) { + ModelManager mm; + uint32_t model_id = 1; + ComputeGraphPtr graph = std::make_shared("test"); + GeRootModelPtr ge_root_model = make_shared(graph); + auto &profiling_manager = ge::ProfilingManager::Instance(); + profiling_manager.SetSubscribeInfo(0, model_id, true); + Status ret = mm.LoadModelOnline(model_id, ge_root_model, listerner); + profiling_manager.CleanSubscribeInfo(); +} + +TEST_F(UtestModelManagerModelManager, command_profiling) { + ModelManager manager; + uint32_t model_id = 1; + Command cmd; + auto model = std::make_shared(1, listerner); + model->SetId(model_id); + cmd.cmd_params.push_back("modelId"); + cmd.cmd_params.push_back(to_string(model_id)); + auto &profiling_manager = ge::ProfilingManager::Instance(); + profiling_manager.SetSubscribeInfo(0, model_id, true); + Status ret = manager.HandleProfModelUnsubscribeCommand(cmd); + profiling_manager.CleanSubscribeInfo(); +} } // namespace ge diff --git a/tests/ut/ge/profiling/ge_profiling_manager_unittest.cc b/tests/ut/ge/profiling/ge_profiling_manager_unittest.cc index aae3f535..58a5c951 100644 --- a/tests/ut/ge/profiling/ge_profiling_manager_unittest.cc +++ b/tests/ut/ge/profiling/ge_profiling_manager_unittest.cc @@ -21,11 +21,16 @@ #include #include +#include "graph/load/model_manager/davinci_model.h" + #define protected public #define private public #include "common/profiling/profiling_manager.h" #include "graph/ge_local_context.h" #include "inc/framework/common/profiling/ge_profiling.h" +#include "graph/manager/graph_manager.h" +#include "graph/ops_stub.h" +#include "inc/framework/omg/omg_inner_types.h" #undef protected #undef private @@ -133,3 +138,77 @@ TEST_F(UtestGeProfilinganager, set_step_info_failed) { Status ret = ProfSetStepInfo(index_id, 1, stream); EXPECT_EQ(ret, ge::FAILED); } + +TEST_F(UtestGeProfilinganager, handle_subscribe_info) { + ProfCommandHandleType prof_type = kProfCommandhandleModelSubscribe; + ProfCommandHandleData prof_data; + prof_data.profSwitch = 0; + prof_data.modelId = 1; + domi::GetContext().train_flag = true; + auto prof_ptr = std::make_shared(prof_data); + Status ret = ProfCommandHandle(prof_type, static_cast(prof_ptr.get()), sizeof(prof_data)); + EXPECT_EQ(ret, ge::SUCCESS); +} + +TEST_F(UtestGeProfilinganager, handle_unsubscribe_info) { + ProfCommandHandleType prof_type = kProfCommandhandleModelUnsubscribe; + ProfCommandHandleData prof_data; + prof_data.profSwitch = 0; + prof_data.modelId = 1; + domi::GetContext().train_flag = true; + auto &profiling_manager = ge::ProfilingManager::Instance(); + profiling_manager.SetSubscribeInfo(0, 1, true); + auto prof_ptr = std::make_shared(prof_data); + Status ret = ProfCommandHandle(prof_type, static_cast(prof_ptr.get()), sizeof(prof_data)); + profiling_manager.CleanSubscribeInfo(); +} + +TEST_F(UtestGeProfilinganager, set_subscribe_info) { + auto &profiling_manager = ge::ProfilingManager::Instance(); + profiling_manager.SetSubscribeInfo(0, 1, true); + const auto &subInfo = profiling_manager.GetSubscribeInfo(); + EXPECT_EQ(subInfo.prof_switch, 0); + EXPECT_EQ(subInfo.graph_id, 1); + EXPECT_EQ(subInfo.is_subscribe, true); +} + +TEST_F(UtestGeProfilinganager, clean_subscribe_info) { + auto &profiling_manager = ge::ProfilingManager::Instance(); + profiling_manager.CleanSubscribeInfo(); + const auto &subInfo = profiling_manager.GetSubscribeInfo(); + EXPECT_EQ(subInfo.prof_switch, 0); + EXPECT_EQ(subInfo.graph_id, 0); + EXPECT_EQ(subInfo.is_subscribe, false); +} + +TEST_F(UtestGeProfilinganager, get_model_id_success) { + auto &profiling_manager = ge::ProfilingManager::Instance(); + profiling_manager.SetGraphIdToModelMap(0, 1); + uint32_t model_id = 0; + Status ret = profiling_manager.GetModelIdFromGraph(0, model_id); + EXPECT_EQ(ret, ge::SUCCESS); +} + +TEST_F(UtestGeProfilinganager, get_model_id_failed) { + auto &profiling_manager = ge::ProfilingManager::Instance(); + profiling_manager.SetGraphIdToModelMap(0, 1); + uint32_t model_id = 0; + Status ret = profiling_manager.GetModelIdFromGraph(10, model_id); + EXPECT_EQ(ret, ge::FAILED); +} + +TEST_F(UtestGeProfilinganager, get_device_id_success) { + auto &profiling_manager = ge::ProfilingManager::Instance(); + profiling_manager.SetGraphIdToDeviceMap(0, 1); + uint32_t device_id = 0; + Status ret = profiling_manager.GetDeviceIdFromGraph(0, device_id); + EXPECT_EQ(ret, ge::SUCCESS); +} + +TEST_F(UtestGeProfilinganager, get_device_id_failed) { + auto &profiling_manager = ge::ProfilingManager::Instance(); + profiling_manager.SetGraphIdToDeviceMap(0, 1); + uint32_t device_id = 0; + Status ret = profiling_manager.GetDeviceIdFromGraph(10, device_id); + EXPECT_EQ(ret, ge::FAILED); +} diff --git a/tests/ut/ge/session/inner_session_unittest.cc b/tests/ut/ge/session/inner_session_unittest.cc index 0d20f06a..0c9deeca 100644 --- a/tests/ut/ge/session/inner_session_unittest.cc +++ b/tests/ut/ge/session/inner_session_unittest.cc @@ -16,6 +16,8 @@ #include +#include "framework/common/profiling/ge_profiling.h" + #define private public #define protected public #include "session/inner_session.h" @@ -63,4 +65,16 @@ TEST_F(Utest_Inner_session, check_op_precision_mode) { auto ret = inner_session.Initialize(); EXPECT_NE(ret, ge::SUCCESS); } + +TEST_F(Utest_Inner_session, get_device_from_graph) { + std::map options = {}; + uint64_t session_id = 1; + InnerSession inner_session(session_id, options); + GraphId graph_id = 1; + uint32_t device_id = 0; + Graph graph("test_graph"); + Status ret = inner_session.AddGraph(graph_id, graph); + ret = ProfGetDeviceFormGraphId(graph_id, device_id); + EXPECT_EQ(ret, ge::SUCCESS); +} } // namespace ge