Add UT

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

@@ -19,6 +19,7 @@
 #define private public
 #define protected public
 #include "graph/utils/graph_utils.h"
+#include "common/profiling/profiling_manager.h"
 #include "graph/load/new_model_manager/davinci_model.h"
 
 using namespace std;
@@ -36,6 +37,7 @@ class UtestDavinciModel : public testing::Test {
 TEST_F(UtestDavinciModel, init_success) {
   DavinciModel model(0, nullptr);
   ComputeGraphPtr graph = make_shared<ComputeGraph>("default");
+  ProfilingManager::Instance().is_load_profiling_ = true;
 
   GeModelPtr ge_model = make_shared<GeModel>();
   ge_model->SetGraph(GraphUtils::CreateGraphFromComputeGraph(graph));
@@ -53,40 +55,63 @@ TEST_F(UtestDavinciModel, init_success) {
   op_input->AddOutputDesc(tensor);
   op_input->SetInputOffset({1024});
   op_input->SetOutputOffset({1024});
-  NodePtr node_input = graph->AddNode(op_input);
+  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);
+  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);
+  NodePtr node_output = graph->AddNode(op_output);  // op_index = 3
+
 
-  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();
+  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));
+
+  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(1);
+  memcpy_async->set_op_index(2);
 
   EXPECT_EQ(model.Assign(ge_model), SUCCESS);
   EXPECT_EQ(model.Init(), SUCCESS);
 
   EXPECT_EQ(model.input_addrs_list_.size(), 1);
   EXPECT_EQ(model.output_addrs_list_.size(), 1);
-  EXPECT_EQ(model.task_list_.size(), 1);
-  EXPECT_EQ(model.op_list_.size(), 3);
+  EXPECT_EQ(model.task_list_.size(), 2);
+
+  ProfilingManager::Instance().is_load_profiling_ = false;
 }
 
 TEST_F(UtestDavinciModel, init_data_op) {
@@ -165,4 +190,96 @@ TEST_F(UtestDavinciModel, init_netoutput_op_subgraph) {
   EXPECT_TRUE(output_op_list.empty());
 }
 
+TEST_F(UtestDavinciModel, init_unknown) {
+  DavinciModel model(0, nullptr);
+  model.SetKnownNode(true);
+  ComputeGraphPtr graph = make_shared<ComputeGraph>("default");
+
+  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_STREAM_NUM, 1);
+
+  shared_ptr<domi::ModelTaskDef> model_task_def = make_shared<domi::ModelTaskDef>();
+  ge_model->SetModelTaskDef(model_task_def);
+
+  GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
+  TensorUtils::SetSize(tensor, 512);
+
+  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
+
+
+  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));
+
+  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);
+
+  EXPECT_EQ(model.Assign(ge_model), SUCCESS);
+  EXPECT_EQ(model.Init(), SUCCESS);
+
+  EXPECT_EQ(model.input_addrs_list_.size(), 1);
+  EXPECT_EQ(model.output_addrs_list_.size(), 1);
+  EXPECT_EQ(model.task_list_.size(), 2);
+
+  EXPECT_EQ(model.task_list_[0]->UpdateArgs(), SUCCESS);
+  EXPECT_EQ(model.task_list_[1]->UpdateArgs(), SUCCESS);
+
+  vector<string> out_shape_info;
+  model.GetModelAttr(out_shape_info);
+
+  vector<InputOutputDescInfo> input_descs;
+  vector<InputOutputDescInfo> output_descs;
+  EXPECT_EQ(model.GetInputOutputDescInfo(input_descs, output_descs), SUCCESS);
+
+  int32_t virtual_addr = 0;
+  const vector<void *> inputs = { &virtual_addr };
+  const vector<void *> outputs = { &virtual_addr  };
+  EXPECT_EQ(model.UpdateKnownNodeArgs(inputs, outputs), SUCCESS);
+}
 }  // namespace ge