fix

ge/single_op/single_op_model.cc

@@ -558,43 +558,6 @@ Status SingleOpModel::BuildOp(StreamResource &resource, SingleOp &single_op) {
   return BuildTaskList(&resource, single_op);
 }
 
-Status SingleOpModel::BuildModelTaskKernel(StreamResource *stream_resource, const TaskDef &task_def,
-                                           DynamicSingleOp &single_op) {
-  auto task_type = static_cast<rtModelTaskType_t>(task_def.type());
-  const auto &context = task_type == RT_MODEL_TASK_KERNEL ? task_def.kernel().context() :
-                                                            task_def.kernel_with_handle().context();
-
-  auto kernel_type = static_cast<ccKernelType>(context.kernel_type());
-  if (kernel_type == ccKernelType::TE) {
-    GELOGD("Building TBE task.");
-    TbeOpTask *tbe_task = nullptr;
-    GE_CHK_STATUS_RET_NOLOG(BuildKernelTask(task_def, &tbe_task));
-    tbe_task->SetModelArgs(model_name_, model_id_);
-    if (tbe_task->tiling_buffer_ != nullptr) {
-      GELOGD("tiling buffer is not nullptr.");
-      tbe_task->stream_resource_ = stream_resource;
-    }
-    single_op.op_task_.reset(tbe_task);
-  } else if (kernel_type == ccKernelType::AI_CPU || kernel_type == ccKernelType::CUST_AI_CPU) {
-    GELOGD("Building AICPU_CC task");
-    OpTask *task = nullptr;
-    uint64_t dynamic_singleop_kernel_id = aicpu_kernel_id++;
-    GELOGI("Build dynamic singleOp CCTask, kernel_id = %lu", dynamic_singleop_kernel_id);
-    GE_CHK_STATUS_RET_NOLOG(BuildCpuKernelTask(task_def.kernel(), &task, dynamic_singleop_kernel_id));
-    task->SetModelArgs(model_name_, model_id_);
-    single_op.op_task_.reset(task);
-  } else {
-    GELOGE(ACL_ERROR_GE_OP_KERNEL_TYPE_INVALID,
-        "[Check][Param:TaskDef]Only TBE, AI_CPU, CUST_AI_CPU kernel are supported, but got %u", 
-        context.kernel_type());
-    REPORT_INNER_ERROR("E19999", 
-        "BuildModelTaskKernel fail for got:%u not supported, Only TBE, AI_CPU, CUST_AI_CPU kernel are supported.",
-        context.kernel_type());
-    return ACL_ERROR_GE_OP_KERNEL_TYPE_INVALID;
-  }
-  return SUCCESS;
-}
-
 Status SingleOpModel::BuildTaskListForDynamicOp(StreamResource *stream_resource, DynamicSingleOp &single_op) {
   auto ge_model = model_helper_.GetGeModel();
   GE_CHECK_NOTNULL(ge_model);
@@ -615,7 +578,47 @@ Status SingleOpModel::BuildTaskListForDynamicOp(StreamResource *stream_resource,
             "BuildTaskListForDynamicOp fail for Do not support dynamic op with multiple tasks.");
         return ACL_ERROR_GE_OP_TASK_TYPE_INVALID;
       }
-      GE_CHK_STATUS_RET_NOLOG(BuildModelTaskKernel(stream_resource, task_def, single_op));
+      auto task_type = static_cast<rtModelTaskType_t>(task_def.type());
+      const auto &context = task_type == RT_MODEL_TASK_KERNEL ? task_def.kernel().context() :
+                                                                task_def.kernel_with_handle().context();
+      auto kernel_type = static_cast<ccKernelType>(context.kernel_type());
+      if (kernel_type == ccKernelType::TE) {
+        GELOGD("Building TBE task.");
+        TbeOpTask *tbe_task = nullptr;
+        GE_CHK_STATUS_RET_NOLOG(BuildKernelTask(task_def, &tbe_task));
+        tbe_task->SetModelArgs(model_name_, model_id_);
+        if (tbe_task->tiling_buffer_ != nullptr) {
+          GELOGD("tiling buffer is not nullptr.");
+          tbe_task->stream_resource_ = stream_resource;
+        }
+        single_op.op_task_.reset(tbe_task);
+      } else if (kernel_type == ccKernelType::AI_CPU || kernel_type == ccKernelType::CUST_AI_CPU) {
+        GELOGD("Building AICPU_CC task");
+        AicpuCCTask *aicpu_kernel_task = nullptr;
+        uint64_t dynamic_singleop_kernel_id = aicpu_kernel_id++;
+        GELOGI("Build dynamic singleOp CCTask, kernel_id = %lu", dynamic_singleop_kernel_id);
+        GE_CHK_STATUS_RET_NOLOG(BuildCpuKernelTask(task_def.kernel(), &aicpu_kernel_task, dynamic_singleop_kernel_id));
+        if (aicpu_kernel_task->GetUnknownType() == DEPEND_COMPUTE) {
+          if (i >= tasks.size() - 1) {
+            GELOGE(ACL_ERROR_GE_PARAM_INVALID, "[Check][Task]The copy task of the fourth operator was not found.");
+            REPORT_INNER_ERROR("E19999", "The copy task of the fourth operator was not found.");
+            return ACL_ERROR_GE_PARAM_INVALID;
+          }
+          ++i;
+          const TaskDef &copy_task_def = tasks[i];
+          GE_CHK_STATUS_RET_NOLOG(aicpu_kernel_task->SetMemCopyTask(copy_task_def.kernel()));
+        }
+        task->SetModelArgs(model_name_, model_id_);
+        single_op.op_task_.reset(task);
+      } else {
+        GELOGE(ACL_ERROR_GE_OP_KERNEL_TYPE_INVALID,
+            "[Check][Param:TaskDef]Only TBE, AI_CPU, CUST_AI_CPU kernel are supported, but got %u", 
+            context.kernel_type());
+        REPORT_INNER_ERROR("E19999", 
+            "BuildTaskListForDynamicOp fail for got:%u not supported, Only TBE, AI_CPU, CUST_AI_CPU kernel are supported.",
+            context.kernel_type());
+        return ACL_ERROR_GE_OP_KERNEL_TYPE_INVALID;
+      }
     } else if (task_type == RT_MODEL_TASK_KERNEL_EX) {
       if (single_op.op_task_ != nullptr) {
         GELOGE(ACL_ERROR_GE_OP_TASK_TYPE_INVALID, "[Check][TaskType]Do not support dynamic op with multiple tasks.");

ge/single_op/single_op_model.h

@@ -70,9 +70,7 @@ class SingleOpModel {
   Status BuildTaskListForDynamicOp(StreamResource *stream_resource, DynamicSingleOp &dynamic_single_op);
   Status BuildKernelTask(const domi::TaskDef &task_def, TbeOpTask **task);
   Status BuildKernelExTask(const domi::KernelExDef &kernel_def, AiCpuTask **task, uint64_t kernel_id);
-  Status BuildCpuKernelTask(const domi::KernelDef &kernel_def, OpTask **task, uint64_t kernel_id);
-  Status BuildModelTaskKernel(StreamResource *stream_resource, const domi::TaskDef &task_def,
-                              DynamicSingleOp &single_op);
+  Status BuildCpuKernelTask(const domi::KernelDef &kernel_def, AiCpuCCTask **task, uint64_t kernel_id);
 
   static void ParseOpModelParams(ModelHelper &model_helper, SingleOpModelParam &param);
   void ParseArgTable(OpTask *task, SingleOp &op);