From 69a8d570d0d911ff49d9d39f8e30550e378216d8 Mon Sep 17 00:00:00 2001 From: zhupuxu Date: Fri, 9 Jul 2021 17:49:27 +0800 Subject: [PATCH] graph id Signed-off-by: zhupuxu --- ge/common/profiling/ge_profiling.cc | 32 +++++ ge/common/profiling/profiling_manager.cc | 51 +++++++- 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 | 5 + ge/session/inner_session.cc | 4 + inc/framework/common/profiling/ge_profiling.h | 2 + .../graph/execute/graph_execute_unittest.cc | 44 +++++++ .../ge/graph/load/model_manager_unittest.cc | 30 ++++- .../ge_profiling_manager_unittest.cc | 113 ++++++++++++++++++ 13 files changed, 370 insertions(+), 14 deletions(-) diff --git a/ge/common/profiling/ge_profiling.cc b/ge/common/profiling/ge_profiling.cc index fd104e90..1b5e5c84 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}, @@ -195,6 +198,31 @@ 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; + if (type == kProfCommandhandleModelUnsubscribe && is_subscribe) { + prof_params.clear(); + prof_params.emplace_back(kPofilingModelId); + uint32_t model_id = 0; + // GraphId is actually stored in prof_config_param + uint32_t graph_id = prof_config_param->modelId; + auto ret = profiling_manager.GetModelIdFromGraph(graph_id, model_id); + 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; + } + + prof_params.emplace_back(std::to_string(model_id)); + } ge::GraphLoader graph_loader; ge::Command command; command.cmd_params.clear(); @@ -248,3 +276,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 7fd63d7e..0464491d 100644 --- a/ge/common/profiling/profiling_manager.cc +++ b/ge/common/profiling/profiling_manager.cc @@ -66,10 +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; - index_id_ = UINT64_MAX; + : is_load_profiling_(false), + is_execute_profiling_(false), + is_training_trace_(false), + subscribe_count_(0), + prof_cb_({nullptr, nullptr}), + index_id_(UINT64_MAX), + subscribe_info_({false, 0, 0}) { } ProfilingManager::~ProfilingManager() {} @@ -610,6 +613,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfFi // 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) { @@ -632,6 +637,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; @@ -1057,4 +1064,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 25929895..e5137562 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; @@ -102,7 +108,15 @@ class FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ProfilingManager { 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); void SetStepInfoIndex(uint64_t index_id) { index_id_ = index_id; } - uint64_t GetStepInfoIndex() { return index_id_; } + uint64_t GetStepInfoIndex() const { return index_id_; } + 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); @@ -130,6 +144,9 @@ class FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ProfilingManager { std::string bp_point_; uint32_t reporter_max_len_ = 0; uint64_t index_id_; + 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 ba35e7c0..03abf91f 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; @@ -365,7 +366,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; } @@ -776,4 +781,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 b6d56dff..56e322f1 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 { @@ -148,6 +149,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 ddd6c0c4..1d6f7aff 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) \ @@ -763,8 +764,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 8b44daea..f1db6a99 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; } @@ -758,12 +768,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; } @@ -1826,5 +1839,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 a3605ec2..84ed3ab0 100755 --- a/ge/graph/manager/graph_manager.cc +++ b/ge/graph/manager/graph_manager.cc @@ -109,6 +109,7 @@ #include "register/custom_pass_helper.h" #include "external/graph/types.h" #include "common/util/error_manager/error_manager.h" +#include "common/profiling/profiling_manager.h" namespace { const char *const kSummary = "Summary"; @@ -462,6 +463,9 @@ Status GraphManager::AddGraph(const GraphId &graph_id, const Graph &graph, const std::map &options, const OmgContext &omg_context) { IncreaseGraphCount(graph_id); + auto device_id = GetContext().DeviceId(); + GELOGD("Device id is %u", device_id); + ProfilingManager::Instance().SetGraphIdToDeviceMap(graph_id, device_id); // validation for adding graphs of same graph_id in multi-thread secenario // 1.previous thread owns same graph_id has finished the AddGraph procession if (GetAddGraphCondition(graph_id) == kDoneAdded) { @@ -1715,6 +1719,7 @@ Status GraphManager::ParseTrainGraphFlag(bool &train_flag) { train_flag = true; } } + 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 fcb9d233..1dcc2996 100755 --- a/ge/session/inner_session.cc +++ b/ge/session/inner_session.cc @@ -35,6 +35,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 { @@ -231,6 +232,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/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 166ae4af..65b70a24 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; @@ -135,7 +136,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) { @@ -426,4 +428,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..35879df8 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 @@ -43,6 +48,23 @@ int32_t ReporterCallback(uint32_t moduleId, uint32_t type, void *data, uint32_t return -1; } +void CreateGraph(Graph &graph) { + TensorDesc desc(ge::Shape({1, 3, 224, 224})); + uint32_t size = desc.GetShape().GetShapeSize(); + desc.SetSize(size); + auto data = op::Data("Data").set_attr_index(0); + data.update_input_desc_data(desc); + data.update_output_desc_out(desc); + + auto flatten = op::Flatten("Flatten").set_input_x(data, data.name_out_out()); + + std::vector inputs{data}; + std::vector outputs{flatten}; + std::vector targets{flatten}; + // Graph graph("test_graph"); + graph.SetInputs(inputs).SetOutputs(outputs).SetTargets(targets); +} + TEST_F(UtestGeProfilinganager, init_success) { setenv("PROFILING_MODE", "true", true); Options options; @@ -133,3 +155,94 @@ TEST_F(UtestGeProfilinganager, set_step_info_failed) { Status ret = ProfSetStepInfo(index_id, 1, stream); EXPECT_EQ(ret, ge::FAILED); } + +TEST_F(UtestGeProfilinganager, get_device_from_graph) { + GraphId graph_id = 1; + uint32_t device_id = 0; + GraphManager graph_manager; + GraphNodePtr graph_node = MakeShared(graph_id); + graph_manager.AddGraphNode(graph_id, graph_node); + graph_manager.SetAddGraphCondition(graph_id, 2); + Graph graph("test_graph"); + CreateGraph(graph); + std::map options; + OmgContext context; + Status ret = graph_manager.AddGraph(graph_id, graph, options, context); + EXPECT_EQ(ret, ge::SUCCESS); + ret = ProfGetDeviceFormGraphId(graph_id, device_id); + EXPECT_EQ(ret, ge::SUCCESS); +} + +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); +}