Delete repeated rtSetDevice

ge/graph/load/model_manager/model_manager.cc

@@ -268,18 +268,6 @@ ModelManager::~ModelManager() {
   GE_IF_BOOL_EXEC(device_count > 0, GE_CHK_RT(rtDeviceReset(0)));
 }
 
-///
-/// @ingroup domi_ome
-/// @brief set Device. If no device available, return failure
-/// @return Status run result
-/// @author
-///
-Status ModelManager::SetDevice(int32_t deviceId) const {
-  GE_CHK_RT_RET(rtSetDevice(deviceId));
-
-  return SUCCESS;
-}
-
 ge::Status ModelManager::SetDynamicSize(uint32_t model_id, const std::vector<uint64_t> &batch_num,
                                         int32_t dynamic_type) {
   std::shared_ptr<DavinciModel> davinci_model = GetModel(model_id);
@@ -320,8 +308,6 @@ Status ModelManager::LoadModelOnline(uint32_t &model_id, const shared_ptr<ge::Ge
     return DoLoadHybridModelOnline(model_id, ge_root_model, listener);
   }
 
-  GE_CHK_STATUS_RET(SetDevice(static_cast<int32_t>(GetContext().DeviceId())), "Set device failed, model id:%u.",
-                    model_id);
   mmTimespec timespec = mmGetTickCount();
   std::shared_ptr<DavinciModel> davinci_model = MakeShared<DavinciModel>(0, listener);
   if (davinci_model == nullptr) {
@@ -358,8 +344,6 @@ Status ModelManager::LoadModelOnline(uint32_t &model_id, const shared_ptr<ge::Ge
     GELOGI("Parse model %u success.", model_id);
   } while (0);
 
-  GE_CHK_RT(rtDeviceReset(static_cast<int32_t>(GetContext().DeviceId())));
-
   return ret;
 }
 
@@ -1053,11 +1037,15 @@ Status ModelManager::LoadModelOffline(uint32_t &model_id, const ModelData &model
       ACL_ERROR_GE_PARAM_INVALID, "input key file path %s is invalid, %s", model.key.c_str(), strerror(errno));
   GenModelId(&model_id);
 
-  shared_ptr<DavinciModel> davinci_model = nullptr;
   mmTimespec timespec = mmGetTickCount();
 
   ModelHelper model_helper;
   Status ret = model_helper.LoadRootModel(model);
+  if (ret != SUCCESS) {
+    GELOGE(ret, "load model failed.");
+    return ret;
+  }
+
   if (model_helper.GetModelType()) {
     bool is_shape_unknown = false;
     GE_CHK_STATUS_RET(model_helper.GetGeRootModel()->CheckIsUnknownShape(is_shape_unknown),
@@ -1066,21 +1054,13 @@ Status ModelManager::LoadModelOffline(uint32_t &model_id, const ModelData &model
       return DoLoadHybridModelOnline(model_id, model_helper.GetGeRootModel(), listener);
     }
   }
-  if (ret != SUCCESS) {
-    GELOGE(ret, "load model failed.");
-    return ret;
-  }
 
   do {
     GeModelPtr ge_model = model_helper.GetGeModel();
-    try {
-      davinci_model = std::make_shared<DavinciModel>(model.priority, listener);
-    } catch (std::bad_alloc &) {
+    shared_ptr<DavinciModel> davinci_model = MakeShared<DavinciModel>(model.priority, listener);
+    if (davinci_model == nullptr) {
       GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Make shared failed");
       return ACL_ERROR_GE_MEMORY_ALLOCATION;
-    } catch (...) {
-      GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Make shared failed since other exception raise");
-      return ACL_ERROR_GE_MEMORY_ALLOCATION;
     }
     davinci_model->SetProfileTime(MODEL_LOAD_START, (timespec.tv_sec * kTimeSpecNano +
                                                      timespec.tv_nsec));  // 1000 ^ 3 converts second to nanosecond
@@ -1120,9 +1100,8 @@ Status ModelManager::LoadModelOffline(uint32_t &model_id, const ModelData &model
     InsertModel(model_id, davinci_model);
 
     GELOGI("Parse model %u success.", model_id);
-    
+
     GE_IF_BOOL_EXEC(ret == SUCCESS, device_count++);
-    return SUCCESS;
   } while (0);
 
   return ret;

ge/graph/load/model_manager/model_manager.h

@@ -247,8 +247,6 @@ class FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ModelManager {
 
   ge::Status GetModelAttr(uint32_t model_id, std::vector<string> &dynamic_output_shape_info);
 
-  ge::Status SetDevice(int32_t deviceId) const;
-
   ge::Status SetDynamicSize(uint32_t model_id, const std::vector<uint64_t> &batch_num, int32_t dynamic_type);
 
   ///

tests/ut/ge/graph/load/davinci_model_unittest.cc

@@ -38,7 +38,6 @@ int32_t MsprofReport(uint32_t moduleId, uint32_t type, void *data, uint32_t len)
   return 0;
 }
 
-/*
 TEST_F(UtestDavinciModel, init_success) {
   DavinciModel model(0, nullptr);
   ComputeGraphPtr graph = make_shared<ComputeGraph>("default");
@@ -46,7 +45,7 @@ TEST_F(UtestDavinciModel, init_success) {
 
   GeModelPtr ge_model = make_shared<GeModel>();
   ge_model->SetGraph(GraphUtils::CreateGraphFromComputeGraph(graph));
-  AttrUtils::SetInt(ge_model, ATTR_MODEL_MEMORY_SIZE, 5120000);
+  AttrUtils::SetInt(ge_model, ATTR_MODEL_MEMORY_SIZE, 10240);
   AttrUtils::SetInt(ge_model, ATTR_MODEL_STREAM_NUM, 1);
 
   shared_ptr<domi::ModelTaskDef> model_task_def = make_shared<domi::ModelTaskDef>();
@@ -54,60 +53,66 @@ TEST_F(UtestDavinciModel, init_success) {
 
   GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
   TensorUtils::SetSize(tensor, 512);
+  {
+    OpDescPtr op_desc = CreateOpDesc("data", DATA);
+    op_desc->AddInputDesc(tensor);
+    op_desc->AddOutputDesc(tensor);
+    op_desc->SetInputOffset({1024});
+    op_desc->SetOutputOffset({1024});
+    NodePtr node = graph->AddNode(op_desc);    // op_index = 0
+  }
 
-  OpDescPtr op_input = CreateOpDesc("data", DATA);
-  op_input->AddInputDesc(tensor);
-  op_input->AddOutputDesc(tensor);
-  op_input->SetInputOffset({1024});
-  op_input->SetOutputOffset({1024});
-  NodePtr node_input = graph->AddNode(op_input);    // op_index = 0
-
-  OpDescPtr op_kernel = CreateOpDesc("square", "Square");
-  op_kernel->AddInputDesc(tensor);
-  op_kernel->AddOutputDesc(tensor);
-  op_kernel->SetInputOffset({1024});
-  op_kernel->SetOutputOffset({1024});
-  NodePtr node_kernel = graph->AddNode(op_kernel);  // op_index = 1
-
-  OpDescPtr op_memcpy = CreateOpDesc("memcpy", MEMCPYASYNC);
-  op_memcpy->AddInputDesc(tensor);
-  op_memcpy->AddOutputDesc(tensor);
-  op_memcpy->SetInputOffset({1024});
-  op_memcpy->SetOutputOffset({5120});
-  NodePtr node_memcpy = graph->AddNode(op_memcpy);  // op_index = 2
-
-  OpDescPtr op_output = CreateOpDesc("output", NETOUTPUT);
-  op_output->AddInputDesc(tensor);
-  op_output->SetInputOffset({5120});
-  op_output->SetSrcName( { "memcpy" } );
-  op_output->SetSrcIndex( { 0 } );
-  NodePtr node_output = graph->AddNode(op_output);  // op_index = 3
+  {
+    OpDescPtr op_desc = CreateOpDesc("square", "Square");
+    op_desc->AddInputDesc(tensor);
+    op_desc->AddOutputDesc(tensor);
+    op_desc->SetInputOffset({1024});
+    op_desc->SetOutputOffset({1024});
+    NodePtr node = graph->AddNode(op_desc);  // op_index = 1
 
+    domi::TaskDef *task_def = model_task_def->add_task();
+    task_def->set_stream_id(0);
+    task_def->set_type(RT_MODEL_TASK_KERNEL);
+    domi::KernelDef *kernel_def = task_def->mutable_kernel();
+    kernel_def->set_stub_func("stub_func");
+    kernel_def->set_args_size(64);
+    string args(64, '1');
+    kernel_def->set_args(args.data(), 64);
+    domi::KernelContext *context = kernel_def->mutable_context();
+    context->set_op_index(op_desc->GetId());
+    context->set_kernel_type(2);    // ccKernelType::TE
+    uint16_t args_offset[9] = {0};
+    context->set_args_offset(args_offset, 9 * sizeof(uint16_t));
+  }
 
-  domi::TaskDef *task_def1 = model_task_def->add_task();
-  task_def1->set_stream_id(0);
-  task_def1->set_type(RT_MODEL_TASK_KERNEL);
-  domi::KernelDef *kernel_def = task_def1->mutable_kernel();
-  kernel_def->set_stub_func("stub_func");
-  kernel_def->set_args_size(64);
-  string args(64, '1');
-  kernel_def->set_args(args.data(), 64);
-  domi::KernelContext *context = kernel_def->mutable_context();
-  context->set_op_index(1);
-  context->set_kernel_type(2);    // ccKernelType::TE
-  uint16_t args_offset[9] = {0};
-  context->set_args_offset(args_offset, 9 * sizeof(uint16_t));
+  {
+    OpDescPtr op_desc = CreateOpDesc("memcpy", MEMCPYASYNC);
+    op_desc->AddInputDesc(tensor);
+    op_desc->AddOutputDesc(tensor);
+    op_desc->SetInputOffset({1024});
+    op_desc->SetOutputOffset({5120});
+    NodePtr node = graph->AddNode(op_desc);  // op_index = 2
+
+    domi::TaskDef *task_def = model_task_def->add_task();
+    task_def->set_stream_id(0);
+    task_def->set_type(RT_MODEL_TASK_MEMCPY_ASYNC);
+    domi::MemcpyAsyncDef *memcpy_async = task_def->mutable_memcpy_async();
+    memcpy_async->set_src(1024);
+    memcpy_async->set_dst(5120);
+    memcpy_async->set_dst_max(512);
+    memcpy_async->set_count(1);
+    memcpy_async->set_kind(RT_MEMCPY_DEVICE_TO_DEVICE);
+    memcpy_async->set_op_index(op_desc->GetId());
+  }
 
-  domi::TaskDef *task_def2 = model_task_def->add_task();
-  task_def2->set_stream_id(0);
-  task_def2->set_type(RT_MODEL_TASK_MEMCPY_ASYNC);
-  domi::MemcpyAsyncDef *memcpy_async = task_def2->mutable_memcpy_async();
-  memcpy_async->set_src(1024);
-  memcpy_async->set_dst(5120);
-  memcpy_async->set_dst_max(512);
-  memcpy_async->set_count(1);
-  memcpy_async->set_kind(RT_MEMCPY_DEVICE_TO_DEVICE);
-  memcpy_async->set_op_index(2);
+  {
+    OpDescPtr op_desc = CreateOpDesc("output", NETOUTPUT);
+    op_desc->AddInputDesc(tensor);
+    op_desc->SetInputOffset({5120});
+    op_desc->SetSrcName( { "memcpy" } );
+    op_desc->SetSrcIndex( { 0 } );
+    NodePtr node = graph->AddNode(op_desc);  // op_index = 3
+  }
 
   EXPECT_EQ(model.Assign(ge_model), SUCCESS);
   EXPECT_EQ(model.Init(), SUCCESS);
@@ -124,7 +129,6 @@ TEST_F(UtestDavinciModel, init_success) {
 
   ProfilingManager::Instance().is_load_profiling_ = false;
 }
-*/
 
 TEST_F(UtestDavinciModel, init_data_op) {
   DavinciModel model(0, nullptr);
@@ -752,7 +756,6 @@ TEST_F(UtestDavinciModel, init_data_aipp_input_dims_normal) {
   EXPECT_EQ(model.op_list_.size(), 1);
 }
 
-/*
 // test label_set_task Init
 TEST_F(UtestDavinciModel, label_task_success) {
   DavinciModel model(0, nullptr);
@@ -760,7 +763,7 @@ TEST_F(UtestDavinciModel, label_task_success) {
 
   GeModelPtr ge_model = make_shared<GeModel>();
   ge_model->SetGraph(GraphUtils::CreateGraphFromComputeGraph(graph));
-  AttrUtils::SetInt(ge_model, ATTR_MODEL_MEMORY_SIZE, 5120000);
+  AttrUtils::SetInt(ge_model, ATTR_MODEL_MEMORY_SIZE, 10240);
   AttrUtils::SetInt(ge_model, ATTR_MODEL_STREAM_NUM, 1);
 
   shared_ptr<domi::ModelTaskDef> model_task_def = make_shared<domi::ModelTaskDef>();
@@ -769,7 +772,6 @@ TEST_F(UtestDavinciModel, label_task_success) {
   GeTensorDesc tensor(GeShape(), FORMAT_ND, DT_INT32);
   TensorUtils::SetSize(tensor, 64);
 
-  uint32_t op_index = 0;
   {
     OpDescPtr op_desc = CreateOpDesc("label_switch", LABELSWITCHBYINDEX);
     op_desc->AddInputDesc(tensor);
@@ -781,7 +783,7 @@ TEST_F(UtestDavinciModel, label_task_success) {
     task_def1->set_stream_id(0);
     task_def1->set_type(RT_MODEL_TASK_STREAM_LABEL_SWITCH_BY_INDEX);
     domi::LabelSwitchByIndexDef *label_task_def = task_def1->mutable_label_switch_by_index();
-    label_task_def->set_op_index(op_index++);
+    label_task_def->set_op_index(op_desc->GetId());
     label_task_def->set_label_max(2);
   }
 
@@ -794,7 +796,7 @@ TEST_F(UtestDavinciModel, label_task_success) {
     task_def1->set_stream_id(0);
     task_def1->set_type(RT_MODEL_TASK_LABEL_SET);
     domi::LabelSetDef *label_task_def = task_def1->mutable_label_set();
-    label_task_def->set_op_index(op_index++);
+    label_task_def->set_op_index(op_desc->GetId());
   }
 
   {
@@ -806,7 +808,7 @@ TEST_F(UtestDavinciModel, label_task_success) {
     task_def2->set_stream_id(0);
     task_def2->set_type(RT_MODEL_TASK_STREAM_LABEL_GOTO);
     domi::LabelGotoExDef *label_task_def = task_def2->mutable_label_goto_ex();
-    label_task_def->set_op_index(op_index++);
+    label_task_def->set_op_index(op_desc->GetId());
   }
 
   {
@@ -818,7 +820,7 @@ TEST_F(UtestDavinciModel, label_task_success) {
     task_def1->set_stream_id(0);
     task_def1->set_type(RT_MODEL_TASK_LABEL_SET);
     domi::LabelSetDef *label_task_def = task_def1->mutable_label_set();
-    label_task_def->set_op_index(op_index++);
+    label_task_def->set_op_index(op_desc->GetId());
   }
 
   {
@@ -830,7 +832,7 @@ TEST_F(UtestDavinciModel, label_task_success) {
     task_def1->set_stream_id(0);
     task_def1->set_type(RT_MODEL_TASK_LABEL_SET);
     domi::LabelSetDef *label_task_def = task_def1->mutable_label_set();
-    label_task_def->set_op_index(op_index++);
+    label_task_def->set_op_index(op_desc->GetId());
   }
 
   EXPECT_TRUE(AttrUtils::SetInt(ge_model, ATTR_MODEL_LABEL_NUM, 3));
@@ -840,7 +842,6 @@ TEST_F(UtestDavinciModel, label_task_success) {
   EXPECT_EQ(model.output_addrs_list_.size(), 0);
   EXPECT_EQ(model.task_list_.size(), 5);
 }
-*/ 
 
 TEST_F(UtestDavinciModel, LoadWithQueue_fail_with_diff_args) {
   DavinciModel model(0, nullptr);