diff --git a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc index c15989fd..3927c7a0 100755 --- a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc +++ b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc @@ -477,12 +477,11 @@ Status AicpuNodeTask::CopyDataToHbm(TaskContext &context, GE_CHK_STATUS_RET_NOLOG(PrepareCopyInputs(context, out_shape_hbm)); RECORD_CALLBACK_EVENT(context.GetExecutionContext(), node_name_.c_str(), "[LaunchCopy] Start"); - uint32_t flag = RT_KERNEL_DEFAULT; auto rt_ret = rtCpuKernelLaunchWithFlag(reinterpret_cast(memcpy_so_name_.c_str()), reinterpret_cast(memcpy_kernel_name_.c_str()), 1, // default core dim is 1 memcpy_args_.get(), memcpy_args_size_, - nullptr, context.GetStream(), flag); + nullptr, context.GetStream(), RT_KERNEL_DEFAULT); GE_CHK_RT_RET(rt_ret); RECORD_CALLBACK_EVENT(context.GetExecutionContext(), node_name_.c_str(), "[LaunchCopy] End"); @@ -704,50 +703,55 @@ Status AicpuNodeTask::SetMemCopyTask(const domi::TaskDef &task_def) { 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;); + if (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; + } + + if (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;); + if (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;); + if (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(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), ©_io_addr_[0], 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;); + if (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; } diff --git a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.h b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.h index f9001f83..37dd4d0b 100644 --- a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.h +++ b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.h @@ -108,7 +108,6 @@ class AicpuNodeTaskBase : public NodeTask { std::unique_ptr copy_input_data_size_dev_; std::unique_ptr copy_input_src_dev_; std::unique_ptr copy_input_dst_dev_; - bool need_sync_ = false; }; class AicpuTfNodeTask : public AicpuNodeTaskBase { @@ -151,6 +150,8 @@ class AicpuTfNodeTask : public AicpuNodeTaskBase { std::unique_ptr copy_ioaddr_dev_; std::unique_ptr copy_workspace_buf_; + + bool need_sync_ = false; }; class AicpuNodeTask : public AicpuNodeTaskBase { diff --git a/ge/single_op/single_op.cc b/ge/single_op/single_op.cc index a82c30ba..23f4cfad 100755 --- a/ge/single_op/single_op.cc +++ b/ge/single_op/single_op.cc @@ -433,11 +433,13 @@ Status DynamicSingleOp::ExecuteAsync(const vector &input_desc, if (!inputs_size.empty()) { StreamResource *stream_resource = SingleOpManager::GetInstance().GetResource(resource_id_, stream_); GE_CHK_STATUS_RET_NOLOG(UpdateInputsBufferAddr(stream_resource, stream_, inputs_size, update_buffers)); - GE_CHK_STATUS_RET_NOLOG(SetHostTensorValue(input_desc, input_buffers)); } if (hybrid_model_executor_ != nullptr) { GELOGD("Execute multi-task dynamic single op by hybrid model executor"); + if (!inputs_size.empty()) { + GE_CHK_STATUS_RET_NOLOG(SetHostTensorValue(input_desc, input_buffers)); + } hybrid::HybridModelExecutor::ExecuteArgs args; GE_CHK_STATUS_RET_NOLOG(InitHybridModelArgs(update_buffers, output_buffers, input_desc, args)); diff --git a/ge/single_op/task/op_task.cc b/ge/single_op/task/op_task.cc index 3117d2fc..8f9dcacf 100755 --- a/ge/single_op/task/op_task.cc +++ b/ge/single_op/task/op_task.cc @@ -293,6 +293,9 @@ Status TbeOpTask::UpdateNodeByShape(const vector &input_desc, cons } Status TbeOpTask::EnableDynamicSupport(const NodePtr &node, void *tiling_buffer, uint32_t max_tiling_size) { + node_ = node; + tiling_buffer_ = tiling_buffer; + max_tiling_size_ = max_tiling_size; if (tiling_buffer != nullptr) { uintptr_t *arg_base = nullptr; size_t arg_num = 0; @@ -310,9 +313,6 @@ Status TbeOpTask::EnableDynamicSupport(const NodePtr &node, void *tiling_buffer, } arg_base[tiling_index] = reinterpret_cast(tiling_buffer); } - node_ = node; - tiling_buffer_ = tiling_buffer; - max_tiling_size_ = max_tiling_size; return SUCCESS; } @@ -481,6 +481,25 @@ void TbeOpTask::GetIoAddr(uintptr_t *&arg_base, size_t &arg_count) { } } +Status AtomicAddrCleanOpTask::EnableDynamicSupport(const NodePtr &node, void *tiling_buffer, uint32_t max_tiling_size) { + node_ = node; + tiling_buffer_ = tiling_buffer; + max_tiling_size_ = max_tiling_size; + if (tiling_buffer != nullptr) { + uintptr_t *arg_base = nullptr; + size_t arg_num = 0; + GetIoAddr(arg_base, arg_num); + uint32_t tiling_index = atomic_output_indices_.size(); + if (arg_num == 0 || arg_num < tiling_index) { + GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "[Check][Size]Tiling index %u, arg number %zu is invalid.", + tiling_index, arg_num); + return ACL_ERROR_GE_INTERNAL_ERROR; + } + arg_base[tiling_index] = reinterpret_cast(tiling_buffer); + } + return SUCCESS; +} + Status AtomicAddrCleanOpTask::UpdateNodeByShape(const vector &input_desc, const vector &output_desc) { return SUCCESS; @@ -585,7 +604,7 @@ Status AiCpuBaseTask::SetExtInfoAndType(const std::string &kernel_ext_info, uint int32_t unknown_shape_type_val = 0; (void) AttrUtils::GetInt(op_desc_, ::ge::ATTR_NAME_UNKNOWN_SHAPE_TYPE, unknown_shape_type_val); - GELOGD("Get unknown_type is %d.", unknown_shape_type_val); + GELOGI("Get unknown_type is %d.", unknown_shape_type_val); unknown_type_ = static_cast(unknown_shape_type_val); aicpu_ext_handle_.reset(new(std::nothrow) ::ge::hybrid::AicpuExtInfoHandler(op_desc_->GetName(), @@ -892,7 +911,7 @@ Status AiCpuCCTask::CopyDataToHbm(vector &outputs, auto ret = rtCpuKernelLaunchWithFlag(static_cast(memcpy_so_name_.data()), static_cast(memcpy_kernel_name_.data()), block_dim_, memcpy_args_.get(), static_cast(memcpy_args_size_), - nullptr, stream, dump_flag_); + nullptr, stream, RT_KERNEL_DEFAULT); GE_CHK_RT_RET(ret); GE_CHK_RT_RET(rtStreamSynchronize(stream)); return SUCCESS; @@ -1112,7 +1131,15 @@ Status AiCpuCCTask::LaunchKernel(const std::vector &input_desc, std::vector &output_buffers, rtStream_t stream) { GE_CHK_STATUS_RET_NOLOG(UpdateExtInfo(input_desc, output_desc, stream)); - GE_CHK_STATUS_RET_NOLOG(UpdateIoAddr(input_buffers, output_buffers)); + if (unknown_type_ == DEPEND_COMPUTE) { + std::vector summary_buffers; + for (size_t i = 0; i < num_outputs_; ++i) { + summary_buffers.emplace_back(output_summary_[i], sizeof(aicpu::FWKAdapter::ResultSummary), false); + } + GE_CHK_STATUS_RET_NOLOG(UpdateIoAddr(input_buffers, summary_buffers)); + } else { + GE_CHK_STATUS_RET_NOLOG(UpdateIoAddr(input_buffers, output_buffers)); + } GE_CHK_STATUS_RET_NOLOG(LaunchKernel(stream)); if (unknown_type_ == DEPEND_SHAPE_RANGE) { GE_CHK_RT_RET(rtStreamSynchronize(stream)); @@ -1157,50 +1184,55 @@ Status AiCpuCCTask::SetMemCopyTask(const domi::KernelDef &kernel_def) { 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;); + if (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; + } + if (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;); + if (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;); + if (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(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), ©_io_addr_[0], 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;); + if (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; } diff --git a/ge/single_op/task/op_task.h b/ge/single_op/task/op_task.h index d2e5bf70..83334fd1 100644 --- a/ge/single_op/task/op_task.h +++ b/ge/single_op/task/op_task.h @@ -97,7 +97,7 @@ class TbeOpTask : public OpTask { const void *GetArgs() const; size_t GetArgSize() const; const std::string &GetStubName() const; - Status EnableDynamicSupport(const NodePtr &node, void *tiling_buffer, uint32_t max_tiling_size); + virtual Status EnableDynamicSupport(const NodePtr &node, void *tiling_buffer, uint32_t max_tiling_size); const std::string &GetTaskType() const override; void SetHandle(void *handle); @@ -149,6 +149,7 @@ class TbeOpTask : public OpTask { class AtomicAddrCleanOpTask : public TbeOpTask { public: Status InitAtomicAddrCleanIndices(); + Status EnableDynamicSupport(const NodePtr &node, void *tiling_buffer, uint32_t max_tiling_size) override; private: Status UpdateNodeByShape(const vector &input_desc, @@ -156,8 +157,8 @@ class AtomicAddrCleanOpTask : public TbeOpTask { Status UpdateIoAddr(const vector &inputs, const vector &outputs) override; Status UpdateTilingArgs(rtStream_t stream) override; Status CalcTilingInfo(optiling::utils::OpRunInfo &run_info) override; - std::vector atomic_output_indices_; + std::vector atomic_output_indices_; }; class AiCpuBaseTask : public OpTask { diff --git a/ge/single_op/task/tbe_task_builder.cc b/ge/single_op/task/tbe_task_builder.cc index 017dac25..f947ca57 100644 --- a/ge/single_op/task/tbe_task_builder.cc +++ b/ge/single_op/task/tbe_task_builder.cc @@ -425,7 +425,7 @@ Status TbeTaskBuilder::InitTilingInfo(TbeOpTask &task) { GELOGD("[%s] Done allocating tiling buffer, size=%ld.", op_desc_->GetName().c_str(), max_size); } - task.EnableDynamicSupport(node_, tiling_buffer, static_cast(max_size)); + GE_CHK_STATUS_RET_NOLOG(task.EnableDynamicSupport(node_, tiling_buffer, static_cast(max_size))); return SUCCESS; } diff --git a/tests/ut/ge/hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc b/tests/ut/ge/hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc index 885123b6..d39fc24e 100644 --- a/tests/ut/ge/hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc +++ b/tests/ut/ge/hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc @@ -148,20 +148,30 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_tf_node_task) { domi::TaskDef task_def2; task_def2.set_type(RT_MODEL_TASK_ALL_KERNEL); - task_def2.mutable_kernel()->set_args(reinterpret_cast(&args), args.head.length); - task_def2.mutable_kernel()->set_args_size(args.head.length); - - hybrid_model.task_defs_[node] = std::vector({task_def2}); - - AicpuNodeTask aicpu_node_task(node_item, task_def); - ASSERT_EQ(aicpu_node_task.Init(hybrid_model), FAILED); + domi::KernelDef *kernel_def = task_def2.mutable_kernel(); + kernel_def->set_args(reinterpret_cast(&args), args.head.length); + kernel_def->set_args_size(args.head.length); + AicpuExtInfo aicpu_ext_info2; + aicpu_ext_info2.infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_SHAPE_TYPE; + aicpu_ext_info2.infoLen = sizeof(int32_t); + memcpy_s(aicpu_ext_info2.infoMsg, sizeof(int32_t), &type, sizeof(int32_t)); + char *ext_mem2 = (char*)malloc(sizeof(AicpuExtInfo) + sizeof(int32_t)); + memcpy_s(ext_mem2, sizeof(AicpuExtInfo) + sizeof(int32_t), &aicpu_ext_info2, sizeof(AicpuExtInfo) + sizeof(int32_t)); + kernel_def->set_kernel_ext_info(ext_mem2, sizeof(AicpuExtInfo) + sizeof(int32_t)); + kernel_def->set_kernel_ext_info_size(sizeof(AicpuExtInfo) + sizeof(int32_t)); + hybrid_model.task_defs_[node] = std::vector({task_def2, task_def2}); + + AicpuNodeTask aicpu_node_task(node_item, task_def2); + ASSERT_EQ(aicpu_node_task.Init(hybrid_model), SUCCESS); + ASSERT_EQ(aicpu_node_task.UpdateIoAddr(*node_state->GetTaskContext()), SUCCESS); ASSERT_EQ(aicpu_node_task.LaunchTask(*node_state->GetTaskContext()), SUCCESS); - - + + node_item->is_dynamic = false; + ASSERT_EQ(aicpu_node_task.UpdateIoAddr(*node_state->GetTaskContext()), SUCCESS); //kernel_ex_def->set_allocated_kernel_ext_info(nullptr); free(ext_mem); - + free(ext_mem2); } - } // namespace ge + diff --git a/tests/ut/ge/single_op/single_op_model_unittest.cc b/tests/ut/ge/single_op/single_op_model_unittest.cc index 7b7a05d8..75db349e 100644 --- a/tests/ut/ge/single_op/single_op_model_unittest.cc +++ b/tests/ut/ge/single_op/single_op_model_unittest.cc @@ -25,6 +25,7 @@ #include "single_op/single_op_model.h" #include "single_op/task/tbe_task_builder.h" #include "single_op/task/rts_kernel_task_builder.h" +#include "aicpu/common/aicpu_task_struct.h" #include "single_op/task/op_task.h" #include "framework/common/helper/model_helper.h" #include "single_op/single_op.h" @@ -43,6 +44,11 @@ constexpr char const *kAttrSupportDynamicShape = "support_dynamicshape"; const char *const kEngineNameAiCore = "AIcoreEngine"; const char *const kEngineNameAiCpu = "aicpu_ascend_kernel"; const char *const kEngineNameAiCpuTf = "aicpu_tf_kernel"; + +struct AicpuTaskStruct { + aicpu::AicpuParamHead head; + uint64_t io_addrp[6]; +}__attribute__((packed)); } // namespace class UtestSingleOpModel : public testing::Test { @@ -315,7 +321,7 @@ TEST_F(UtestSingleOpModel, BuildTaskList) { ASSERT_EQ(mem_task.LaunchKernel(0), SUCCESS); } -TEST_F(UtestSingleOpModel, build_dynamic_task) { +TEST_F(UtestSingleOpModel, build_dynamic_task01) { ComputeGraphPtr graph = make_shared("single_op"); GeModelPtr ge_model = make_shared(); ge_model->SetGraph(GraphUtils::CreateGraphFromComputeGraph(graph)); @@ -366,3 +372,50 @@ TEST_F(UtestSingleOpModel, build_dynamic_task) { op_desc->SetOpKernelLibName(kEngineNameAiCpu); model.BuildTaskListForDynamicOp(res, single_op); } + +TEST_F(UtestSingleOpModel, build_dynamic_task02) { + ComputeGraphPtr graph = make_shared("single_op"); + GeModelPtr ge_model = make_shared(); + ge_model->SetGraph(GraphUtils::CreateGraphFromComputeGraph(graph)); + shared_ptr model_task_def = make_shared(); + ge_model->SetModelTaskDef(model_task_def); + + AicpuTaskStruct args; + args.head.length = sizeof(args); + args.head.ioAddrNum = 6; + domi::TaskDef *task_def = model_task_def->add_task(); + task_def->set_type(RT_MODEL_TASK_KERNEL); + domi::KernelDef *kernel_def = task_def->mutable_kernel(); + kernel_def->set_args(reinterpret_cast(&args), args.head.length); + kernel_def->set_args_size(args.head.length); + ge::hybrid::AicpuExtInfo aicpu_ext_info; + aicpu_ext_info.infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_SHAPE_TYPE; + aicpu_ext_info.infoLen = sizeof(int32_t); + int32_t type = ge::DEPEND_COMPUTE; + memcpy_s(aicpu_ext_info.infoMsg, sizeof(int32_t), &type, sizeof(int32_t)); + char *ext_mem = (char*)malloc(sizeof(ge::hybrid::AicpuExtInfo) + sizeof(int32_t)); + memcpy_s(ext_mem, sizeof(ge::hybrid::AicpuExtInfo) + sizeof(int32_t), &aicpu_ext_info, + sizeof(ge::hybrid::AicpuExtInfo) + sizeof(int32_t)); + kernel_def->set_kernel_ext_info(ext_mem, sizeof(ge::hybrid::AicpuExtInfo) + sizeof(int32_t)); + kernel_def->set_kernel_ext_info_size(sizeof(ge::hybrid::AicpuExtInfo) + sizeof(int32_t)); + domi::KernelContext *context = kernel_def->mutable_context(); + context->set_kernel_type(6); // ccKernelType::AI_CPU + + string model_data_str = "dynamic_model"; + SingleOpModel model("model", model_data_str.c_str(), model_data_str.size()); + std::mutex stream_mu; + rtStream_t stream = nullptr; + rtStreamCreate(&stream, 0); + DynamicSingleOp single_op(0, &stream_mu, stream); + model.model_helper_.model_ = ge_model; + auto op_desc = std::make_shared("add", "Add"); + AttrUtils::SetInt(op_desc, ::ge::ATTR_NAME_UNKNOWN_SHAPE_TYPE, ge::DEPEND_COMPUTE); + NodePtr node = graph->AddNode(op_desc); + model.op_list_[0] = node; + StreamResource *res = new (std::nothrow) StreamResource(1); + + ASSERT_EQ(model.ParseTasks(), SUCCESS); + model.node_tasks_[node] = { *task_def, *task_def }; + op_desc->SetOpKernelLibName(kEngineNameAiCpu); + model.BuildTaskListForDynamicOp(res, single_op); +} \ No newline at end of file diff --git a/tests/ut/ge/single_op/single_op_task_unittest.cc b/tests/ut/ge/single_op/single_op_task_unittest.cc index 8964df74..6e9b273d 100644 --- a/tests/ut/ge/single_op/single_op_task_unittest.cc +++ b/tests/ut/ge/single_op/single_op_task_unittest.cc @@ -237,3 +237,49 @@ TEST_F(UtestSingleOpTask, test_aicpu_task_update_io_addr) { ASSERT_EQ(ret, PARAM_INVALID); } } + +TEST_F(UtestSingleOpTask, test_aicpu_task_launch_kernel) { + AiCpuCCTask task; + rtStream_t stream = nullptr; + task.num_inputs_ = 2; + task.num_outputs_ = 1; + task.input_is_const_ = {true, false}; + int total_addr = 3; + uint32_t* addrs[total_addr] = {nullptr, nullptr, nullptr}; + task.io_addr_ = reinterpret_cast(addrs); + task.io_addr_num_ = total_addr; + + { + vector inputs(2, DataBuffer()); + vector outputs(1, DataBuffer()); + vector inputs_desc(2, GeTensorDesc(GeShape(), FORMAT_NCHW, DT_FLOAT)); + vector outputs_desc(1, GeTensorDesc(GeShape(), FORMAT_NCHW, DT_FLOAT)); + task.unknown_type_ = ge::DEPEND_COMPUTE; + task.num_outputs_ = 1; + ASSERT_EQ(task.InitForSummaryAndCopy(), SUCCESS); + ASSERT_EQ(task.LaunchKernel(inputs_desc, inputs, outputs_desc, outputs, stream), SUCCESS); + } + +TEST_F(UtestSingleOpTask, test_dynamic_support) { + auto graph = make_shared("graph"); + auto op_desc = make_shared("Add", "Add"); + auto node = graph->AddNode(op_desc); + AtomicAddrCleanOpTask atomic_task; + TbeOpTask tbe_task; + + tbe_task.arg_size_ = sizeof(void *) * 1; + tbe_task.args_.reset(new (std::nothrow) uint8_t[tbe_task.arg_size_]); + atomic_task.arg_size_ = sizeof(void *) * 1; + atomic_task.args_.reset(new (std::nothrow) uint8_t[atomic_task.arg_size_]); + ASSERT_EQ(tbe_task.EnableDynamicSupport(node, (void *)0x0001, 1), ACL_ERROR_GE_INTERNAL_ERROR); + ASSERT_EQ(atomic_task.EnableDynamicSupport(node, (void *)0x0001, 1), ACL_ERROR_GE_INTERNAL_ERROR); + + tbe_task.arg_size_ = sizeof(void *) * 2; + tbe_task.args_.reset(new (std::nothrow) uint8_t[tbe_task.arg_size_]); + atomic_task.arg_size_ = sizeof(void *) * 2; + atomic_task.args_.reset(new (std::nothrow) uint8_t[atomic_task.arg_size_]); + ASSERT_EQ(tbe_task.EnableDynamicSupport(node, (void *)0x0001, 1), SUCCESS); + ASSERT_EQ(atomic_task.EnableDynamicSupport(node, (void *)0x0001, 1), SUCCESS); + tbe_task.tiling_buffer_ = nullptr; + atomic_task.tiling_buffer_ = nullptr; +}