fix

ge/single_op/task/op_task.cc

@@ -993,34 +993,56 @@ Status AiCpuCCTask::InitForSummaryAndCopy() {
   return SUCCESS;
 }
 
-Status AiCpuCCTask::SetMemCopyTask(const domi::KernelExDef &kernel_def) {
-  if (kernel_def.args_size() > sizeof(STR_FWK_OP_KERNEL)) {
-    GELOGE(ACL_ERROR_GE_PARAM_INVALID, "[Check][Size]sizeof STR_FWK_OP_KERNEL is: %lu, but args_size is: %d",
-        sizeof(STR_FWK_OP_KERNEL), kernel_def.args_size());
-    REPORT_INNER_ERROR("E19999", "[sizeof STR_FWK_OP_KERNEL is: %lu, but args_size is: %d",
-        sizeof(STR_FWK_OP_KERNEL), kernel_def.args_size());
-    return ACL_ERROR_GE_PARAM_INVALID;
-  }
-  GE_CHK_RT_RET(rtMalloc(&copy_workspace_buf_, kernel_def.task_info_size(), RT_MEMORY_HBM));
-  GE_CHK_RT_RET(rtMemcpy(copy_workspace_buf_, kernel_def.task_info_size(),
-                         kernel_def.task_info().data(), kernel_def.task_info_size(), RT_MEMCPY_HOST_TO_DEVICE));
-
-  STR_FWK_OP_KERNEL aicpu_task = {0};
-  auto sec_ret = memcpy_s(&aicpu_task, sizeof(STR_FWK_OP_KERNEL),
-                          kernel_def.args().data(), kernel_def.args().size());
-  if (sec_ret != EOK) {
-    GELOGE(ACL_ERROR_GE_MEMORY_OPERATE_FAILED, "[Update][TaskArgs] failed, ret: %d", sec_ret);
-    REPORT_INNER_ERROR("E19999", "update STR_FWK_OP_KERNEL args failed because memcpy_s return %d.", sec_ret);
-    return ACL_ERROR_GE_MEMORY_OPERATE_FAILED;
-  }
-
-  aicpu_task.fwkKernelBase.fwk_kernel.inputOutputAddr = reinterpret_cast<uintptr_t>(copy_ioaddr_dev_);
-  aicpu_task.fwkKernelBase.fwk_kernel.workspaceBaseAddr = reinterpret_cast<uintptr_t>(copy_workspace_buf_);
-  aicpu_task.fwkKernelBase.fwk_kernel.extInfoAddr = 0;
-  aicpu_task.fwkKernelBase.fwk_kernel.extInfoLen = 0;
-
-  GE_CHK_RT_RET(rtMemcpy(copy_task_args_buf_, sizeof(STR_FWK_OP_KERNEL),
-                         &aicpu_task, sizeof(STR_FWK_OP_KERNEL), RT_MEMCPY_HOST_TO_DEVICE));
+Status AiCpuCCTask::SetMemCopyTask(const domi::KernelDef &kernel_def) {
+  auto &memcpy_args = kernel_def.args();
+  memcpy_args_size_ = kernel_def.args_size();
+  memcpy_so_name_ = kernel_def.so_name();
+  memcpy_kernel_name_ = kernel_def.kernel_name();
+  GE_IF_BOOL_EXEC(memcpy_args.size() != memcpy_args_size_,
+                  REPORT_INNER_ERROR("E19999", "MemCopy task def args.size=%zu, but args_size=%u not equal.",
+                                     memcpy_args.size(), memcpy_args_size_);
+                  GELOGE(FAILED, "[Check][Size]MemCopy task def args.size=%zu, but args_size=%u not equal.",
+                         memcpy_args.size(), memcpy_args_size_);
+                  return FAILED;);
+  GE_IF_BOOL_EXEC(memcpy_args_size_ < sizeof(aicpu::AicpuParamHead),
+                  REPORT_INNER_ERROR("E19999",
+                                     "Task def args_size=%u is less than aicpu param head len=%zu.",
+                                     memcpy_args_size_, sizeof(aicpu::AicpuParamHead));
+                  GELOGE(FAILED,
+                         "[Check][Size] Task def args_size=%u is less than aicpu param head len=%zu.",
+                         memcpy_args_size_, sizeof(aicpu::AicpuParamHead));
+                  return FAILED;);
+
+  memcpy_args_.reset(new(std::nothrow) uint8_t[memcpy_args_size_]());
+  GE_IF_BOOL_EXEC(memcpy_args_ == nullptr,
+                  REPORT_INNER_ERROR("E19999", "new memory failed for Node[MemCopy], task_size[%u].",
+                                     memcpy_args_size_);
+                  GELOGE(FAILED, "[Malloc][Memory] failed for Node[MemCopy], task_size[%u].",
+                         memcpy_args_size_);
+                  return FAILED;);
+
+  errno_t sec_ret = memcpy_s(memcpy_args_.get(), memcpy_args_size_, memcpy_args.c_str(), memcpy_args.size());
+  GE_IF_BOOL_EXEC(sec_ret != EOK,
+                  REPORT_INNER_ERROR("E19999",
+                                     "memcpy_s argc_ failed for Node[MemCopy], ret: %d", sec_ret);
+                  GELOGE(INTERNAL_ERROR,
+                         "[Update][args] failed for Node[MemCopy], ret: %d", sec_ret);
+                  return sec_ret;);
+  auto memcpy_param_head = reinterpret_cast<aicpu::AicpuParamHead *>(memcpy_args_.get());
+  uint32_t memcpy_io_num = memcpy_param_head->ioAddrNum;
+  auto memcpy_io_addr = memcpy_args_.get() + sizeof(aicpu::AicpuParamHead);
+  // if has input and output, need copy to ioaddr
+  int cpy_ret = memcpy_s(memcpy_io_addr, memcpy_args_size_ - sizeof(aicpu::AicpuParamHead),
+                         &copy_ioaddr_dev_, sizeof(uint64_t) * memcpy_io_num);
+  GE_IF_BOOL_EXEC(cpy_ret != 0,
+                  REPORT_INNER_ERROR("E19999", "Node[Memcpoy] memcpy io addr to AicpuParamHead failed,"
+                         "ret=%d, args_size=%u, io nums=%u.",
+                         cpy_ret, memcpy_args_size_, memcpy_io_num);
+                  GELOGE(INTERNAL_ERROR, "[Update][io_addr]Node[MemCopy] memcpy io addr to AicpuParamHead failed,"
+                         "ret=%d, args_size=%u, io nums=%u.",
+                         cpy_ret, memcpy_args_size_, memcpy_io_num);
+                  return INTERNAL_ERROR;);
+  GELOGD("Set memcpy task for node[MemCopy] successfully.");
   return SUCCESS;
 }
 

ge/single_op/task/op_task.h

@@ -148,6 +148,18 @@ class AiCpuBaseTask : public OpTask {
   std::unique_ptr<ge::hybrid::AicpuExtInfoHandler> aicpu_ext_handle_;
   void *ext_info_addr_dev_ = nullptr;
   vector<bool> input_is_const_;
+  
+  std::vector<void *> output_summary_;
+  std::vector<aicpu::FWKAdapter::ResultSummary> output_summary_host_;
+
+  void *copy_ioaddr_dev_ = nullptr;
+
+  void *copy_input_release_flag_dev_ = nullptr;
+  void *copy_input_data_size_dev_ = nullptr;
+  void *copy_input_src_dev_ = nullptr;
+  void *copy_input_dst_dev_ = nullptr;
+
+  vector<void *> out_shape_hbm_;
 };
 
 class AiCpuTask : public AiCpuBaseTask {
@@ -195,18 +207,6 @@ class AiCpuTask : public AiCpuBaseTask {
   // for copy task
   void *copy_task_args_buf_ = nullptr;
   void *copy_workspace_buf_ = nullptr;
-
-  std::vector<void *> output_summary_;
-  std::vector<aicpu::FWKAdapter::ResultSummary> output_summary_host_;
-
-  void *copy_ioaddr_dev_ = nullptr;
-
-  void *copy_input_release_flag_dev_ = nullptr;
-  void *copy_input_data_size_dev_ = nullptr;
-  void *copy_input_src_dev_ = nullptr;
-  void *copy_input_dst_dev_ = nullptr;
-
-  vector<void *> out_shape_hbm_;
   uint64_t kernel_id_ = 0;
 };
 
@@ -225,7 +225,7 @@ class AiCpuCCTask : public AiCpuBaseTask {
   void SetkernelName(const std::string &kernel_Name);
   void SetIoAddr(uintptr_t *io_addr);
   size_t GetArgSize() const;
-  Status SetMemCopyTask(const domi::KernelExDef &kernel_def);
+  Status SetMemCopyTask(const domi::KernelDef &kernel_def);
   Status LaunchKernel(const std::vector<GeTensorDesc> &input_desc,
                       const std::vector<DataBuffer> &input_buffers,
                       std::vector<GeTensorDesc> &output_desc,
@@ -246,6 +246,12 @@ class AiCpuCCTask : public AiCpuBaseTask {
   uint32_t dump_flag_ = RT_KERNEL_DEFAULT;
   std::string op_type_;
   uint64_t kernel_id_ = 0;
+  // host memcpy mem
+  std::unique_ptr<uint8_t[]> memcpy_args_;
+  std::string memcpy_so_name_;
+  std::string memcpy_kernel_name_;
+  // args size
+  size_t memcpy_args_size_ = 0;  
 };
 
 class MemcpyAsyncTask : public OpTask {