fix

tests/ut/ge/hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc

@@ -210,6 +210,85 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_memcopy_task) {
   ASSERT_EQ(aicpu_node_task2.SetMemCopyTask(task_def), FAILED);
 }
 
+TEST_F(UtestAicpuNodeExecutor, aicpu_copy_data_to_hbm) {
+  ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
+  GeModelPtr ge_sub_model = std::make_shared<GeModel>();
+  GeRootModelPtr ge_root_model = std::make_shared<GeRootModel>(graph);
+  ge_root_model->SetModelName("test_name");
+  ge_root_model->SetSubgraphInstanceNameToModel("sub", ge_sub_model);
+  HybridModel hybrid_model(ge_root_model);
+
+  NodePtr node = CreateNode(graph, "frameworkop", FRAMEWORK_OP_TYPE, 4, 2);
+
+  std::unique_ptr<NodeItem> new_node;
+  ASSERT_EQ(NodeItem::Create(node, new_node), SUCCESS);
+  NodeItem *node_item = new_node.get();
+  hybrid_model.node_items_[node] = std::move(new_node);
+  node_item->input_start = 0;
+  node_item->output_start = 0;
+  node_item->is_dynamic = true;
+  node_item->shape_inference_type = DEPEND_COMPUTE;
+  node_item->num_outputs = 2;
+  GraphItem graph_item;
+  graph_item.node_items_.emplace_back(node_item);
+  graph_item.total_inputs_ = 4;
+  graph_item.total_outputs_ = 2;
+
+  GraphExecutionContext graph_context;
+  SubgraphContext subgraph_context(&graph_item, &graph_context);
+  ASSERT_EQ(subgraph_context.Init(), SUCCESS);
+  graph_context.callback_manager = std::unique_ptr<CallbackManager>(new CallbackManager());
+
+  auto node_state = subgraph_context.GetOrCreateNodeState(node_item);
+  ASSERT_NE(node_state, nullptr);
+
+  for (int i=0; i<4; ++i) {
+    uint64_t value_0 = 512;
+    TensorValue in_tensor0(&value_0, sizeof(value_0));
+    subgraph_context.SetInput(*node_item, 0, in_tensor0);
+  }
+
+  uint64_t value_0 = 512;
+  TensorValue out_tensor0(&value_0, sizeof(value_0));
+  subgraph_context.SetOutput(*node_item, 0, out_tensor0);
+
+  uint64_t value_1 = 512;
+  TensorValue out_tensor1(&value_1, sizeof(value_1));
+  subgraph_context.SetOutput(*node_item, 1, out_tensor1);
+
+  // task
+  domi::TaskDef task_def;
+  AicpuTaskStruct args;
+  args.head.length = sizeof(args);
+  args.head.ioAddrNum = 6;
+  task_def.set_type(RT_MODEL_TASK_ALL_KERNEL);
+  domi::KernelDef *kernel_def = task_def.mutable_kernel();
+  kernel_def->set_args(reinterpret_cast<const char *>(&args), args.head.length);
+  kernel_def->set_args_size(args.head.length);
+  AicpuExtInfo aicpu_ext_info;
+  aicpu_ext_info.infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_SHAPE_TYPE;
+  aicpu_ext_info.infoLen = sizeof(int32_t);
+  memcpy_s(aicpu_ext_info.infoMsg, sizeof(int32_t), &type, sizeof(int32_t));
+  char *ext_mem = (char*)malloc(sizeof(AicpuExtInfo) + sizeof(int32_t));
+  memcpy_s(ext_mem, sizeof(AicpuExtInfo) + sizeof(int32_t), &aicpu_ext_info2, sizeof(AicpuExtInfo) + sizeof(int32_t));
+  kernel_def->set_kernel_ext_info(ext_mem, sizeof(AicpuExtInfo) + sizeof(int32_t));
+  kernel_def->set_kernel_ext_info_size(sizeof(AicpuExtInfo) + sizeof(int32_t));
+  hybrid_model.task_defs_[node] = std::vector<domi::TaskDef>({task_def, task_def});
+
+  AicpuNodeTask aicpu_node_task(node_item, task_def);
+  std::vector<std::unique_ptr<TensorBuffer>> &out_shape_hbm;
+  ASSERT_EQ(aicpu_node_task.Init(hybrid_model), SUCCESS);
+  for (int i = 0; i < node_item->num_outputs; i++) {
+    aicpu_node_task.output_summary_[i].shape_data_size = 1;
+    aicpu_node_task.output_summary_[i].raw_data_size = 1;
+    aicpu_node_task.output_summary_[i].shape_data_ptr = 0;
+    aicpu_node_task.output_summary_[i].raw_data_ptr = 0;
+  }
+  ASSERT_EQ(aicpu_node_task.ReadResultSummaryAndPrepareMemory(*node_state->GetTaskContext(), out_shape_hbm), SUCCESS);
+  ASSERT_EQ(aicpu_node_task.CopyDataToHbm(*node_state->GetTaskContext(), out_shape_hbm), SUCCESS);
+  free(ext_mem);
+}
+
 TEST_F(UtestAicpuNodeExecutor, aicpu_blocking_node_task) {
   ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
   GeRootModelPtr ge_root_model = std::make_shared<GeRootModel>(graph);