From 359eb108178e9b26f843459179e58e01533fba82 Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 11:49:56 +0800 Subject: [PATCH 01/33] fix --- .../node_executor/aicpu/aicpu_node_executor.cc | 205 +++++++++++++++++---- .../node_executor/aicpu/aicpu_node_executor.h | 83 +++++---- 2 files changed, 216 insertions(+), 72 deletions(-) diff --git a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc index f309ebd0..19cfbfff 100755 --- a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc +++ b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc @@ -548,8 +548,8 @@ Status AicpuTfNodeTask::EnsureSessionCreated(uint64_t session_id) { return SUCCESS; } -Status AicpuTfNodeTask::ReadResultSummaryAndPrepareMemory(TaskContext &context, - std::vector> &out_shape_hbm) { +Status AicpuNodeTaskBase::ReadResultSummaryAndPrepareMemory(TaskContext &context, + std::vector> &out_shape_hbm) { for (auto i = 0; i < node_item_->num_outputs; ++i) { auto &result_summary = output_summary_host_[i]; GE_CHK_RT_RET(rtMemcpy(&result_summary, sizeof(aicpu::FWKAdapter::ResultSummary), @@ -574,6 +574,30 @@ Status AicpuTfNodeTask::ReadResultSummaryAndPrepareMemory(TaskContext &context, return SUCCESS; } +Status AicpuNodeTask::CopyDataToHbm(TaskContext &context, + const std::vector> &out_shape_hbm) { + GE_CHK_BOOL_RET_STATUS(out_shape_hbm.size() == static_cast(node_item_->num_outputs), + INTERNAL_ERROR, + "[Check][Size]Node[%s] has %d outputs but out shape is %zu not equal.", + node_name_.c_str(), node_item_->num_outputs, out_shape_hbm.size()); + + GE_CHK_STATUS_RET_NOLOG(PrepareCopyInputs(context, out_shape_hbm)); + + RECORD_CALLBACK_EVENT(context.GetExecutionContext(), node_name_.c_str(), "[LaunchCopy] Start"); + 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(), RT_KERNEL_DEFAULT); + GE_CHK_RT_RET(rt_ret); + + RECORD_CALLBACK_EVENT(context.GetExecutionContext(), node_name_.c_str(), "[LaunchCopy] End"); + + GE_CHK_RT_RET(rtStreamSynchronize(context.GetStream())); + RECORD_CALLBACK_EVENT(context.GetExecutionContext(), node_name_.c_str(), "[SynchronizeCopy] End"); + return SUCCESS; +} + Status AicpuTfNodeTask::CopyDataToHbm(TaskContext &context, const std::vector> &out_shape_hbm) { GE_CHK_BOOL_RET_STATUS(out_shape_hbm.size() == static_cast(node_item_->num_outputs), @@ -593,8 +617,8 @@ Status AicpuTfNodeTask::CopyDataToHbm(TaskContext &context, return SUCCESS; } -Status AicpuTfNodeTask::PrepareCopyInputs(const TaskContext &context, - const std::vector> &out_shape_hbm) { +Status AicpuNodeTaskBase::PrepareCopyInputs(const TaskContext &context, + const std::vector> &out_shape_hbm) { std::vector copy_input_release_flag; std::vector copy_input_data_size; std::vector copy_input_src; @@ -635,8 +659,8 @@ Status AicpuTfNodeTask::PrepareCopyInputs(const TaskContext &context, return SUCCESS; } -Status AicpuTfNodeTask::UpdateShapeByHbmBuffer(TaskContext &context, - const std::vector> &out_shape_hbm) { +Status AicpuNodeTaskBase::UpdateShapeByHbmBuffer(TaskContext &context, + const std::vector> &out_shape_hbm) { GE_CHK_BOOL_RET_STATUS(out_shape_hbm.size() == static_cast(node_item_->num_outputs), INTERNAL_ERROR, "Node[%s] has %d outputs but out shape is %zu", @@ -667,7 +691,7 @@ Status AicpuTfNodeTask::UpdateShapeByHbmBuffer(TaskContext &context, return SUCCESS; } -Status AicpuTfNodeTask::UpdateShapeAndDataByResultSummary(TaskContext &context) { +Status AicpuNodeTaskBase::UpdateShapeAndDataByResultSummary(TaskContext &context) { GELOGD("Node[%s] update shape and data by result summary begin.", node_name_.c_str()); std::vector> out_shape_hbm; @@ -762,7 +786,7 @@ Status AicpuTfNodeTask::LaunchTask(TaskContext &context) { return SUCCESS; } -Status AicpuTfNodeTask::TaskCallback(TaskContext &context) { +Status AicpuNodeTaskBase::TaskCallback(TaskContext &context) { GELOGD("Node[%s] task callback start. is_dynamic=%s, unknown_type=%d.", node_name_.c_str(), node_item_->is_dynamic ? "true" : "false", unknown_type_); Status callback_ret = SUCCESS; @@ -779,14 +803,115 @@ Status AicpuTfNodeTask::TaskCallback(TaskContext &context) { return callback_ret; } +Status AicpuNodeTask::SetMemCopyTask(const domi::TaskDef &task_def) { + if (node_item_->num_outputs == 0) { + GELOGD("Node[%s] type[%s] has no output, no need set mem_copy task.", + node_name_.c_str(), node_item_->node_type.c_str()); + return SUCCESS; + } + + GELOGD("Start to set memcpy task for node[%s].", node_name_.c_str()); + const domi::KernelDef &kernel_def = task_def.kernel(); + 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(); + 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_]()); + 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()); + 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); + 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; +} + +Status AicpuNodeTask::InitForDependComputeTask() { + if ((unknown_type_ != DEPEND_COMPUTE) || (node_item_->num_outputs == 0)) { + GELOGD("Node[%s] type[%s] unknown_type is %d, output num is %d.", + node_name_.c_str(), node_item_->node_type.c_str(), unknown_type_, node_item_->num_outputs); + return SUCCESS; + } + + output_summary_.resize(node_item_->num_outputs); + constexpr auto result_summary_size = sizeof(aicpu::FWKAdapter::ResultSummary); + for (auto i = 0; i < node_item_->num_outputs; ++i) { + GE_CHK_STATUS_RET(AllocTensorBuffer(result_summary_size, output_summary_[i]), + "[Alloc][TensorBuffer] failed for Node[%s] to copy result summary info, size=%zu.", + node_name_.c_str(), result_summary_size); + } + output_summary_host_.resize(node_item_->num_outputs); + + // init for mem copy task + // copy task need copy output_data and output_shape, max len is 2 * output_num + const size_t copy_input_buf_len = node_item_->num_outputs * 2 * sizeof(uint64_t); + GE_CHK_STATUS_RET(AllocTensorBuffer(copy_input_buf_len, copy_input_release_flag_dev_), + "[Alloc][TensorBuffer] failed for Node[%s] to copy task input release_flag, size=%zu", + node_name_.c_str(), copy_input_buf_len); + GE_CHK_STATUS_RET(AllocTensorBuffer(copy_input_buf_len, copy_input_data_size_dev_), + "[Alloc][TensorBuffer] failed for Node[%s] to copy task input data_size, size=%zu", + node_name_.c_str(), copy_input_buf_len); + GE_CHK_STATUS_RET(AllocTensorBuffer(copy_input_buf_len, copy_input_src_dev_), + "[Alloc][TensorBuffer] failed for Node[%s] to copy task input src, size=%zu", + node_name_.c_str(), copy_input_buf_len); + GE_CHK_STATUS_RET(AllocTensorBuffer(copy_input_buf_len, copy_input_dst_dev_), + "[Alloc][TensorBuffer] failed for Node[%s] to copy task input dst, size=%zu", + node_name_.c_str(), copy_input_buf_len); + + copy_io_addr_.emplace_back(reinterpret_cast(copy_input_release_flag_dev_->GetData())); + copy_io_addr_.emplace_back(reinterpret_cast(copy_input_data_size_dev_->GetData())); + copy_io_addr_.emplace_back(reinterpret_cast(copy_input_src_dev_->GetData())); + copy_io_addr_.emplace_back(reinterpret_cast(copy_input_dst_dev_->GetData())); + return SUCCESS; +} + Status AicpuNodeTask::Init(const HybridModel &model) { auto node_name = node_name_; GELOGD("Node[%s] init start.", node_name.c_str()); - GE_CHK_BOOL_RET_STATUS(unknown_type_ != DEPEND_COMPUTE, FAILED, - "[Check][Type]Node[%s] unknown type[%d] is depend compute, it's not supported now.", - node_name.c_str(), unknown_type_); - GE_CHK_BOOL_RET_STATUS(task_def_.has_kernel(), FAILED, "[Check][task_def_]Node[%s] task def does not has kernel.", node_name.c_str()); auto &kernel_def = task_def_.kernel(); @@ -877,7 +1002,9 @@ Status AicpuNodeTask::Init(const HybridModel &model) { GELOGD("Get op:%s attribute(is_blocking_op), value:%d", op_desc->GetName().c_str(), is_blocking_aicpu_op_); GE_CHK_STATUS_RET(InitExtInfo(kernel_ext_info, ext_session_id), "[Init][ExtInfo] failed for Node[%s].", node_name.c_str()); - + GE_CHK_STATUS_RET(InitForDependComputeTask(), + "[Init][DependComputeTask] failed for Node[%s].", + node_name_.c_str()); if (ext_info_addr_dev_ == nullptr) { aicpu_param_head->extInfoLength = 0; aicpu_param_head->extInfoAddr = 0; @@ -885,7 +1012,11 @@ Status AicpuNodeTask::Init(const HybridModel &model) { aicpu_param_head->extInfoLength = ext_info_addr_dev_->GetSize(); aicpu_param_head->extInfoAddr = reinterpret_cast(ext_info_addr_dev_->GetData()); } - + auto task_defs = model.GetTaskDefs(node_item_->node); + GE_CHECK_NOTNULL(task_defs); + if (unknown_type_ == DEPEND_COMPUTE) { + GE_CHK_STATUS_RET_NOLOG(SetMemCopyTask((*task_defs)[1])); + } GELOGD("Node[%s] init end.", node_name.c_str()); return SUCCESS; } @@ -900,14 +1031,29 @@ Status AicpuNodeTask::UpdateIoAddr(TaskContext &context) { GELOGD("Node[%s] input[%d] = %p, size = %zu", node_name_.c_str(), i, inputData->GetData(), inputData->GetSize()); io_addrs.emplace_back(reinterpret_cast(inputData->GetData())); } + // known shape or not depend compute + if (!node_item_->is_dynamic || unknown_type_ != DEPEND_COMPUTE) { + // unknown type 4 do this in call back. + GE_CHK_STATUS_RET_NOLOG(context.AllocateOutputs()); + for (auto j = 0; j < node_item_->num_outputs; ++j) { + auto outputData = context.GetOutput(j); + GE_CHECK_NOTNULL(outputData); + GELOGD("Node[%s] output[%d] addr = %p, size = %zu", + node_name_.c_str(), j, outputData->GetData(), outputData->GetSize()); + io_addrs.emplace_back(reinterpret_cast(outputData->GetData())); + } + } else { + // unknown type 4 use result summary update ioaddr. + GELOGD("Node[%s] is depend compute node, use result summary as out addr.", node_name_.c_str()); + GE_CHK_BOOL_RET_STATUS(output_summary_.size() == static_cast(node_item_->num_outputs), + INTERNAL_ERROR, + "[Check][Size]Node[%s] has %d output but %zu output summary not equal.", + node_name_.c_str(), node_item_->num_outputs, output_summary_.size()); - GE_CHK_STATUS_RET_NOLOG(context.AllocateOutputs()); - for (auto j = 0; j < node_item_->num_outputs; ++j) { - auto outputData = context.GetOutput(j); - GE_CHECK_NOTNULL(outputData); - GELOGD("Node[%s] output[%d] addr = %p, size = %zu", node_name_.c_str(), j, - outputData->GetData(), outputData->GetSize()); - io_addrs.emplace_back(reinterpret_cast(outputData->GetData())); + for (auto j = 0; j < node_item_->num_outputs; ++j) { + void *summary_addr = output_summary_[j]->GetData(); + io_addrs.emplace_back(reinterpret_cast(summary_addr)); + } } auto io_addr = args_.get() + sizeof(aicpu::AicpuParamHead); @@ -951,23 +1097,6 @@ Status AicpuNodeTask::LaunchTask(TaskContext &context) { return SUCCESS; } -Status AicpuNodeTask::TaskCallback(TaskContext &context) { - GELOGD("Node[%s] task callback start, is_dynamic = %s, unknown_type=%d.", - node_name_.c_str(), node_item_->is_dynamic ? "true" : "false", unknown_type_); - Status callback_ret = SUCCESS; - - // check need update shape, call update shape. - if (node_item_->is_dynamic && unknown_type_ == DEPEND_SHAPE_RANGE) { - // check result - callback_ret = UpdateOutputShapeFromExtInfo(context); - } else { - GELOGD("Node[%s] unknown shape type is %d no need update output shape.", - node_name_.c_str(), unknown_type_); - } - GELOGD("Node[%s] task callback end.", node_name_.c_str()); - return callback_ret; -} - Status AiCpuNodeExecutor::PrepareTask(NodeTask &task, TaskContext &context) const { // malloc HBM memory at Init, here just update them RECORD_EXECUTION_EVENT(context.GetExecutionContext(), context.GetNodeName(), "[AiCpuNodeExecutorPrepareTask] Start"); diff --git a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.h b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.h index 3911e090..304821aa 100644 --- a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.h +++ b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.h @@ -55,11 +55,33 @@ class AicpuNodeTaskBase : public NodeTask { virtual Status LaunchTask(TaskContext &context) = 0; - virtual Status TaskCallback(TaskContext &context) = 0; + virtual Status InitForDependComputeTask() = 0; + + Status TaskCallback(TaskContext &context); + + virtual Status UpdateShapeAndDataByResultSummary(TaskContext &context); virtual Status UpdateIoAddr(TaskContext &context) = 0; static Status AllocTensorBuffer(size_t size, std::unique_ptr &tensor_buffer); + + virtual Status CopyDataToHbm(TaskContext &context, + const std::vector> &out_shape_hbm) = 0; + + /// + /// read result summary and prepare copy task memory. + /// @param context task context + /// @param out_shape_hbm if scalar, TensorBuffer->data is null, size=0 + /// @return SUCCESS:success other:failed + /// + Status ReadResultSummaryAndPrepareMemory(TaskContext &context, + std::vector> &out_shape_hbm); + + Status UpdateShapeByHbmBuffer(TaskContext &context, + const std::vector> &out_shape_hbm); + + Status PrepareCopyInputs(const TaskContext &context, + const std::vector> &out_shape_hbm); Status DistributeWaitTaskForAicpuBlockingOp(rtStream_t stream); Status CheckDeviceSupportBlockingAicpuOpProcess(bool &is_support); @@ -83,6 +105,13 @@ class AicpuNodeTaskBase : public NodeTask { // ext info addr, device mem std::unique_ptr ext_info_addr_dev_; + std::vector> output_summary_; + std::vector output_summary_host_; + + std::unique_ptr copy_input_release_flag_dev_; + std::unique_ptr copy_input_data_size_dev_; + std::unique_ptr copy_input_src_dev_; + std::unique_ptr copy_input_dst_dev_; // for blocking aicpu op bool is_blocking_aicpu_op_ = false; rtEvent_t rt_event_ = nullptr; @@ -101,33 +130,14 @@ class AicpuTfNodeTask : public AicpuNodeTaskBase { Status LaunchTask(TaskContext &context) override; - Status TaskCallback(TaskContext &context) override; - Status UpdateIoAddr(TaskContext &context) override; - private: - Status SetMemCopyTask(const domi::TaskDef &task_def); + Status InitForDependComputeTask() override; - Status InitForDependComputeTask(); - - Status UpdateShapeAndDataByResultSummary(TaskContext &context); - - /// - /// read result summary and prepare copy task memory. - /// @param context task context - /// @param out_shape_hbm if scalar, TensorBuffer->data is null, size=0 - /// @return SUCCESS:success other:failed - /// - Status ReadResultSummaryAndPrepareMemory(TaskContext &context, - std::vector> &out_shape_hbm); Status CopyDataToHbm(TaskContext &context, - const std::vector> &out_shape_hbm); - - Status UpdateShapeByHbmBuffer(TaskContext &context, - const std::vector> &out_shape_hbm); - - Status PrepareCopyInputs(const TaskContext &context, - const std::vector> &out_shape_hbm); + const std::vector> &out_shape_hbm) override; + private: + Status SetMemCopyTask(const domi::TaskDef &task_def); static Status EnsureSessionCreated(uint64_t session_id); static uint64_t GetStepIdAddr(const HybridModel &model); @@ -142,16 +152,7 @@ class AicpuTfNodeTask : public AicpuNodeTaskBase { // just used for depend DEPEND_COMPUTE op std::unique_ptr copy_task_args_buf_; - - std::vector> output_summary_; - std::vector output_summary_host_; - std::unique_ptr copy_ioaddr_dev_; - - std::unique_ptr copy_input_release_flag_dev_; - 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; std::unique_ptr copy_workspace_buf_; @@ -170,14 +171,28 @@ class AicpuNodeTask : public AicpuNodeTaskBase { Status LaunchTask(TaskContext &context) override; - Status TaskCallback(TaskContext &context) override; + Status CopyDataToHbm(TaskContext &context, + const std::vector> &out_shape_hbm) override; Status UpdateIoAddr(TaskContext &context) override; + Status InitForDependComputeTask() override; +private: + Status SetMemCopyTask(const domi::TaskDef &task_def); + protected: // host mem std::unique_ptr args_; + // host memcpy mem + std::unique_ptr memcpy_args_; + + std::string memcpy_so_name_; + + std::string memcpy_kernel_name_; + // args size + uint32_t memcpy_args_size_ = 0; + std::vector copy_io_addr_; // args size uint32_t args_size_ = 0; }; From e06d338f581d78674170996299c2418d1f57e447 Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 12:02:51 +0800 Subject: [PATCH 02/33] fix --- ge/single_op/single_op_model.cc | 15 ++++-- ge/single_op/single_op_model.h | 2 +- ge/single_op/task/aicpu_kernel_task_builder.cc | 5 +- ge/single_op/task/op_task.cc | 71 ++++++++++++-------------- ge/single_op/task/op_task.h | 5 -- 5 files changed, 48 insertions(+), 50 deletions(-) diff --git a/ge/single_op/single_op_model.cc b/ge/single_op/single_op_model.cc index ca07d2ae..a126d8cd 100755 --- a/ge/single_op/single_op_model.cc +++ b/ge/single_op/single_op_model.cc @@ -333,7 +333,7 @@ Status SingleOpModel::BuildTaskList(StreamResource *stream_resource, SingleOp &s single_op.tasks_.emplace_back(tbe_task); } else if (kernel_type == ccKernelType::AI_CPU || kernel_type == ccKernelType::CUST_AI_CPU) { GELOGD("Building AICPU_CC task"); - OpTask *task = nullptr; + AiCpuCCTask *task = nullptr; uint64_t singleop_kernel_id = aicpu_kernel_id++; GELOGI("Build singleOp CCTask, kernel_id = %lu", singleop_kernel_id); GE_CHK_STATUS_RET_NOLOG(BuildCpuKernelTask(task_def.kernel(), &task, singleop_kernel_id)); @@ -489,7 +489,7 @@ Status SingleOpModel::BuildKernelExTask(const domi::KernelExDef &kernel_def, AiC return SUCCESS; } -Status SingleOpModel::BuildCpuKernelTask(const domi::KernelDef &kernel_def, OpTask **task, uint64_t kernel_id) { +Status SingleOpModel::BuildCpuKernelTask(const domi::KernelDef &kernel_def, AicpuCCTask **task, uint64_t kernel_id) { const auto &context = kernel_def.context(); auto iter = op_list_.find(context.op_index()); if (iter == op_list_.end()) { @@ -611,10 +611,19 @@ Status SingleOpModel::BuildTaskListForDynamicOp(StreamResource *stream_resource, } else if (lib_name == kEngineNameAiCpu) { const auto &task_def = task_defs[0]; GELOGD("Building AICPU_CC task"); - OpTask *task = nullptr; + AicpuCCTask *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)); + if (task->GetUnknownType() == DEPEND_COMPUTE) { + if (task_defs.size() < kNumTaskWithMemCpyTask) { + 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; + } + const TaskDef ©_task_def = task_defs[1]; + GE_CHK_STATUS_RET_NOLOG(task->SetMemCopyTask(copy_task_def.kernel())); + } task->SetModelArgs(model_name_, model_id_); single_op.op_task_.reset(task); } else if (lib_name == kEngineNameAiCpuTf) { diff --git a/ge/single_op/single_op_model.h b/ge/single_op/single_op_model.h index b1cd161c..4057682d 100755 --- a/ge/single_op/single_op_model.h +++ b/ge/single_op/single_op_model.h @@ -71,7 +71,7 @@ class SingleOpModel { Status BuildKernelTask(const domi::TaskDef &task_def, TbeOpTask **task); Status BuildAtomicTask(const domi::TaskDef &task_def, AtomicAddrCleanOpTask **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 BuildCpuKernelTask(const domi::KernelDef &kernel_def, AicpuCCTask **task, uint64_t kernel_id); static void ParseOpModelParams(ModelHelper &model_helper, SingleOpModelParam ¶m); void ParseArgTable(OpTask *task, SingleOp &op); diff --git a/ge/single_op/task/aicpu_kernel_task_builder.cc b/ge/single_op/task/aicpu_kernel_task_builder.cc index 2f0856bf..3099d8b6 100755 --- a/ge/single_op/task/aicpu_kernel_task_builder.cc +++ b/ge/single_op/task/aicpu_kernel_task_builder.cc @@ -102,11 +102,8 @@ Status AiCpuCCTaskBuilder::BuildTask(AiCpuCCTask &task, uint64_t kernel_id, cons return ret; } GE_CHK_STATUS_RET(task.SetInputConst(), "[Set][InputConst] failed."); + GE_CHK_STATUS_RET(task.InitForSummaryAndCopy(), "[Init][SummaryAndCopy] failed."); - if (task.GetUnknownType() == DEPEND_COMPUTE) { - GELOGE(FAILED, "[Get][UnknownType] is depend compute, it's not supported now."); - return FAILED; - } auto aicpu_param_head = reinterpret_cast(task.args_.get()); if (task.ext_info_addr_dev_ != nullptr) { aicpu_param_head->extInfoLength = kernel_ext_info.size(); diff --git a/ge/single_op/task/op_task.cc b/ge/single_op/task/op_task.cc index 83cb0529..4dd09c43 100755 --- a/ge/single_op/task/op_task.cc +++ b/ge/single_op/task/op_task.cc @@ -567,6 +567,16 @@ AiCpuBaseTask::~AiCpuBaseTask() { if (rt_event_ != nullptr) { (void)rtEventDestroy(rt_event_); } + FreeHbm(copy_input_release_flag_dev_); + FreeHbm(copy_input_data_size_dev_); + FreeHbm(copy_input_src_dev_); + FreeHbm(copy_input_dst_dev_); + for (auto summary : output_summary_) { + FreeHbm(summary); + } + for (auto out_shape : out_shape_hbm_) { + FreeHbm(out_shape); + } } Status AiCpuBaseTask::UpdateEventIdForBlockingAicpuOp() { @@ -878,17 +888,7 @@ AiCpuTask::~AiCpuTask() { FreeHbm(workspace_addr_); FreeHbm(copy_workspace_buf_); FreeHbm(copy_ioaddr_dev_); - FreeHbm(copy_input_release_flag_dev_); - FreeHbm(copy_input_data_size_dev_); - FreeHbm(copy_input_src_dev_); - FreeHbm(copy_input_dst_dev_); FreeHbm(copy_task_args_buf_); - for (auto summary : output_summary_) { - FreeHbm(summary); - } - for (auto out_shape : out_shape_hbm_) { - FreeHbm(out_shape); - } } Status AiCpuTask::LaunchKernel(rtStream_t stream) { @@ -926,7 +926,7 @@ Status AiCpuTask::LaunchKernel(rtStream_t stream) { return SUCCESS; } -Status AiCpuTask::PrepareCopyInputs(vector &outputs) { +Status AiCpuBaseTask::PrepareCopyInputs(vector &outputs) { std::vector copy_input_release_flag; std::vector copy_input_data_size; std::vector copy_input_src; @@ -967,7 +967,7 @@ Status AiCpuTask::PrepareCopyInputs(vector &outputs) { return SUCCESS; } -Status AiCpuTask::ReadResultSummaryAndPrepareMemory() { +Status AiCpuBaseTask::ReadResultSummaryAndPrepareMemory() { for (size_t i = 0; i < num_outputs_; ++i) { auto &result_summary = output_summary_host_[i]; @@ -984,6 +984,19 @@ Status AiCpuTask::ReadResultSummaryAndPrepareMemory() { return SUCCESS; } +Status AiCpuCCTask::CopyDataToHbm(vector &outputs, + rtStream_t stream) { + GE_CHK_STATUS_RET_NOLOG(PrepareCopyInputs(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, RT_KERNEL_DEFAULT); + GE_CHK_RT_RET(ret); + GE_CHK_RT_RET(rtStreamSynchronize(stream)); + return SUCCESS; +} + Status AiCpuTask::CopyDataToHbm(vector &outputs, rtStream_t stream) { GE_CHK_STATUS_RET_NOLOG(PrepareCopyInputs(outputs)); @@ -994,7 +1007,7 @@ Status AiCpuTask::CopyDataToHbm(vector &outputs, return SUCCESS; } -Status AiCpuTask::UpdateShapeByHbmBuffer(vector &output_desc) { +Status AiCpuBaseTask::UpdateShapeByHbmBuffer(vector &output_desc) { for (size_t i = 0; i < num_outputs_; ++i) { const auto &result_summary = output_summary_host_[i]; std::vector shape_dims; @@ -1023,9 +1036,9 @@ Status AiCpuTask::UpdateShapeByHbmBuffer(vector &output_desc) { } -Status AiCpuTask::UpdateShapeAndDataByResultSummary(vector &output_desc, - vector &outputs, - rtStream_t stream) { +Status AiCpuBaseTask::UpdateShapeAndDataByResultSummary(vector &output_desc, + vector &outputs, + rtStream_t stream) { if (num_outputs_ == 0) { GELOGI("Output num is 0, there is no need to update the output and size."); return SUCCESS; @@ -1123,11 +1136,11 @@ Status AiCpuTask::SetMemCopyTask(const domi::KernelExDef &kernel_def) { return SUCCESS; } -Status AiCpuTask::LaunchKernel(const std::vector &input_desc, - const std::vector &input_buffers, - std::vector &output_desc, - std::vector &output_buffers, - rtStream_t stream) { +Status AiCpuBaseTask::LaunchKernel(const std::vector &input_desc, + const std::vector &input_buffers, + std::vector &output_desc, + std::vector &output_buffers, + rtStream_t stream) { GE_CHK_STATUS_RET_NOLOG(UpdateExtInfo(input_desc, output_desc, stream)); if (unknown_type_ == DEPEND_COMPUTE) { std::vector summary_buffers; @@ -1209,22 +1222,6 @@ Status AiCpuCCTask::LaunchKernel(rtStream_t stream) { return SUCCESS; } -Status AiCpuCCTask::LaunchKernel(const std::vector &input_desc, - const std::vector &input_buffers, - std::vector &output_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)); - GE_CHK_STATUS_RET_NOLOG(LaunchKernel(stream)); - if (unknown_type_ == DEPEND_SHAPE_RANGE) { - GE_CHK_RT_RET(rtStreamSynchronize(stream)); - GE_CHK_STATUS_RET_NOLOG(UpdateOutputShape(output_desc)); - } - - return SUCCESS; -} - void AiCpuCCTask::GetIoAddr(uintptr_t *&arg_base, size_t &arg_count) { arg_base = io_addr_; arg_count = io_addr_num_; diff --git a/ge/single_op/task/op_task.h b/ge/single_op/task/op_task.h index adf51dba..8890c9d7 100644 --- a/ge/single_op/task/op_task.h +++ b/ge/single_op/task/op_task.h @@ -78,11 +78,6 @@ class TbeOpTask : public OpTask { public: ~TbeOpTask() override; Status LaunchKernel(rtStream_t stream) override; - Status LaunchKernel(const std::vector &input_desc, - const std::vector &input_buffers, - std::vector &output_desc, - std::vector &output_buffers, - rtStream_t stream) override; void GetIoAddr(uintptr_t *&arg_base, size_t &arg_count) override; void SetSmDesc(void *sm_desc); void SetStubFunc(const std::string &name, const void *stub_func); From 379ab5d11d2193b19a75dcc44e50e64c8c525d20 Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 12:05:54 +0800 Subject: [PATCH 03/33] fix --- ge/single_op/task/op_task.h | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/ge/single_op/task/op_task.h b/ge/single_op/task/op_task.h index 8890c9d7..5e2566e3 100644 --- a/ge/single_op/task/op_task.h +++ b/ge/single_op/task/op_task.h @@ -77,6 +77,11 @@ class OpTask { class TbeOpTask : public OpTask { public: ~TbeOpTask() override; + Status LaunchKernel(const std::vector &input_desc, + const std::vector &input_buffers, + std::vector &output_desc, + std::vector &output_buffers, + rtStream_t stream) override; Status LaunchKernel(rtStream_t stream) override; void GetIoAddr(uintptr_t *&arg_base, size_t &arg_count) override; void SetSmDesc(void *sm_desc); @@ -162,7 +167,11 @@ class AiCpuBaseTask : public OpTask { UnknowShapeOpType GetUnknownType() const { return unknown_type_; } Status UpdateArgTable(const SingleOpModelParam ¶m) override; const std::string &GetTaskType() const override; - + Status LaunchKernel(const std::vector &input_desc, + const std::vector &input_buffers, + std::vector &output_desc, + std::vector &output_buffers, + rtStream_t stream) override; protected: Status UpdateIoAddr(const std::vector &inputs, const std::vector &outputs); Status SetInputConst(); @@ -198,11 +207,7 @@ class AiCpuTask : public AiCpuBaseTask { Status LaunchKernel(rtStream_t stream) override; void GetIoAddr(uintptr_t *&arg_base, size_t &arg_count) override; - Status LaunchKernel(const std::vector &input_desc, - const std::vector &input_buffers, - std::vector &output_desc, - std::vector &output_buffers, - rtStream_t stream) override; + Status SetMemCopyTask(const domi::KernelExDef &kernel_def); private: @@ -266,12 +271,6 @@ class AiCpuCCTask : public AiCpuBaseTask { void SetIoAddr(uintptr_t *io_addr); size_t GetArgSize() const; - Status LaunchKernel(const std::vector &input_desc, - const std::vector &input_buffers, - std::vector &output_desc, - std::vector &output_buffers, - rtStream_t stream) override; - private: friend class AiCpuCCTaskBuilder; std::string so_name_; From bb608b22b7c5b4fb88b1943bf3e1fa8a11d5228b Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 12:09:56 +0800 Subject: [PATCH 04/33] fix --- ge/single_op/task/op_task.cc | 85 ++++++++++++++++++++++++++++++++++++++++++++ ge/single_op/task/op_task.h | 39 ++++++++++---------- 2 files changed, 105 insertions(+), 19 deletions(-) diff --git a/ge/single_op/task/op_task.cc b/ge/single_op/task/op_task.cc index 4dd09c43..b7b638de 100755 --- a/ge/single_op/task/op_task.cc +++ b/ge/single_op/task/op_task.cc @@ -1164,6 +1164,91 @@ Status AiCpuBaseTask::LaunchKernel(const std::vector &input_desc, return SUCCESS; } +Status AiCpuCCTask::InitForSummaryAndCopy() { + if (unknown_type_ != DEPEND_COMPUTE || num_outputs_ == 0) { + GELOGI("Unknown_type is %d, output num is %zu.", unknown_type_, num_outputs_); + return SUCCESS; + } + + output_summary_.resize(num_outputs_); + constexpr auto result_summary_size = sizeof(aicpu::FWKAdapter::ResultSummary); + for (size_t i = 0; i < num_outputs_; ++i) { + GE_CHK_RT_RET(rtMalloc(&output_summary_[i], result_summary_size, RT_MEMORY_HBM)); + } + output_summary_host_.resize(num_outputs_); + + const size_t copy_input_buf_len = num_outputs_ * kCopyNum * sizeof(uint64_t); + + GE_CHK_RT_RET(rtMalloc(©_input_release_flag_dev_, copy_input_buf_len, RT_MEMORY_HBM)); + GE_CHK_RT_RET(rtMalloc(©_input_data_size_dev_, copy_input_buf_len, RT_MEMORY_HBM)); + GE_CHK_RT_RET(rtMalloc(©_input_src_dev_, copy_input_buf_len, RT_MEMORY_HBM)); + GE_CHK_RT_RET(rtMalloc(©_input_dst_dev_, copy_input_buf_len, RT_MEMORY_HBM)); + + copy_io_addr_.emplace_back(reinterpret_cast(copy_input_release_flag_dev_)); + copy_io_addr_.emplace_back(reinterpret_cast(copy_input_data_size_dev_)); + copy_io_addr_.emplace_back(reinterpret_cast(copy_input_src_dev_)); + copy_io_addr_.emplace_back(reinterpret_cast(copy_input_dst_dev_)); + return SUCCESS; +} + +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(); + 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_]()); + 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()); + 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); + 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; +} + Status AiCpuBaseTask::UpdateArgTable(const SingleOpModelParam ¶m) { // aicpu do not have workspace, for now return DoUpdateArgTable(param, false); diff --git a/ge/single_op/task/op_task.h b/ge/single_op/task/op_task.h index 5e2566e3..1769d976 100644 --- a/ge/single_op/task/op_task.h +++ b/ge/single_op/task/op_task.h @@ -182,6 +182,16 @@ class AiCpuBaseTask : public OpTask { rtStream_t stream); Status UpdateOutputShape(vector &output_desc); Status UpdateShapeToOutputDesc(const GeShape &shape_new, GeTensorDesc &output_desc); + Status UpdateShapeAndDataByResultSummary(vector &output_desc, + vector &outputs, + rtStream_t stream); + Status ReadResultSummaryAndPrepareMemory(); + + Status PrepareCopyInputs(vector &outputs); + + Status UpdateShapeByHbmBuffer(vector &output_desc); + + virtual Status CopyDataToHbm(vector &outputs, rtStream_t stream) = 0; // for blocking aicpu op Status DistributeWaitTaskForAicpuBlockingOp(rtStream_t stream); Status UpdateEventIdForBlockingAicpuOp(); @@ -197,6 +207,15 @@ class AiCpuBaseTask : public OpTask { // for blocking aicpu op bool is_blocking_aicpu_op_ = false; rtEvent_t rt_event_ = nullptr; + std::vector output_summary_; + std::vector output_summary_host_; + + 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 out_shape_hbm_; }; class AiCpuTask : public AiCpuBaseTask { @@ -207,21 +226,12 @@ class AiCpuTask : public AiCpuBaseTask { Status LaunchKernel(rtStream_t stream) override; void GetIoAddr(uintptr_t *&arg_base, size_t &arg_count) override; - Status SetMemCopyTask(const domi::KernelExDef &kernel_def); private: // for copy task. Status InitForSummaryAndCopy(); - Status UpdateShapeAndDataByResultSummary(vector &output_desc, - vector &outputs, - rtStream_t stream); - Status ReadResultSummaryAndPrepareMemory(); - - Status CopyDataToHbm(vector &outputs, rtStream_t stream); - Status PrepareCopyInputs(vector &outputs); - - Status UpdateShapeByHbmBuffer(vector &output_desc); + Status CopyDataToHbm(vector &outputs, rtStream_t stream) override; friend class AiCpuTaskBuilder; void *workspace_addr_ = nullptr; @@ -241,17 +251,8 @@ class AiCpuTask : public AiCpuBaseTask { void *copy_task_args_buf_ = nullptr; void *copy_workspace_buf_ = nullptr; - std::vector output_summary_; - std::vector 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 out_shape_hbm_; uint64_t kernel_id_ = 0; }; From cff37a65a3834d29a2b1803ed447fd3dae249155 Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 14:02:41 +0800 Subject: [PATCH 05/33] fix --- ge/single_op/task/op_task.h | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/ge/single_op/task/op_task.h b/ge/single_op/task/op_task.h index 1769d976..a0d5b574 100644 --- a/ge/single_op/task/op_task.h +++ b/ge/single_op/task/op_task.h @@ -262,7 +262,7 @@ class AiCpuCCTask : public AiCpuBaseTask { ~AiCpuCCTask() override; AiCpuCCTask(const AiCpuCCTask &) = delete; AiCpuCCTask &operator=(const AiCpuCCTask &) = delete; - + Status SetMemCopyTask(const domi::KernelDef &kernel_def); Status LaunchKernel(rtStream_t stream) override; void GetIoAddr(uintptr_t *&arg_base, size_t &arg_count) override; const void *GetArgs() const; @@ -271,7 +271,10 @@ class AiCpuCCTask : public AiCpuBaseTask { void SetkernelName(const std::string &kernel_Name); void SetIoAddr(uintptr_t *io_addr); size_t GetArgSize() const; + private: + Status InitForSummaryAndCopy(); + Status CopyDataToHbm(vector &outputs, rtStream_t stream) override; private: friend class AiCpuCCTaskBuilder; std::string so_name_; @@ -285,6 +288,13 @@ private: uint32_t dump_flag_ = RT_KERNEL_DEFAULT; std::string op_type_; uint64_t kernel_id_ = 0; + // host memcpy mem + std::unique_ptr memcpy_args_; + std::string memcpy_so_name_; + std::string memcpy_kernel_name_; + std::vector copy_io_addr_; + // args size + uint32_t memcpy_args_size_ = 0; }; class MemcpyAsyncTask : public OpTask { From 78efacb55d68f1e634f3450ffa991415db559478 Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 14:07:59 +0800 Subject: [PATCH 06/33] fix ut --- .../aicpu/aicpu_node_executor_unittest.cc | 29 ++++++++---- tests/ut/ge/single_op/single_op_model_unittest.cc | 53 +++++++++++++++++++++- tests/ut/ge/single_op/single_op_task_unittest.cc | 30 +++++++++++- 3 files changed, 100 insertions(+), 12 deletions(-) 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 034b3f47..734ee2be 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 @@ -152,19 +152,28 @@ 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); } 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..f20e47d6 100644 --- a/tests/ut/ge/single_op/single_op_model_unittest.cc +++ b/tests/ut/ge/single_op/single_op_model_unittest.cc @@ -23,6 +23,7 @@ #include "graph/utils/graph_utils.h" #include "runtime/rt.h" #include "single_op/single_op_model.h" +#include "aicpu/common/aicpu_task_struct.h" #include "single_op/task/tbe_task_builder.h" #include "single_op/task/rts_kernel_task_builder.h" #include "single_op/task/op_task.h" @@ -43,6 +44,10 @@ 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 +320,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 +371,49 @@ 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); +} 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 52091856..e4f72f9b 100644 --- a/tests/ut/ge/single_op/single_op_task_unittest.cc +++ b/tests/ut/ge/single_op/single_op_task_unittest.cc @@ -195,7 +195,35 @@ TEST_F(UtestSingleOpTask, test_atomic_exec) { optiling::utils::OpRunInfo run_info(0, true, 0); task.CalcTilingInfo(run_info); } - +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; + 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)); + std::string ext_info_str(ext_mem, sizeof(ge::hybrid::AicpuExtInfo) + sizeof(int32_t)); + 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)); + ASSERT_EQ(task.SetExtInfoAndType(ext_info_str, 0), SUCCESS); + 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_aicpu_task_update_io_addr) { AiCpuCCTask task; task.num_inputs_ = 2; From 62d8e766bfae361157458ec05a13fe99b6b5f36f Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 14:18:26 +0800 Subject: [PATCH 07/33] fix ut --- ge/single_op/single_op_model.cc | 4 ++-- ge/single_op/single_op_model.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ge/single_op/single_op_model.cc b/ge/single_op/single_op_model.cc index a126d8cd..08778c09 100755 --- a/ge/single_op/single_op_model.cc +++ b/ge/single_op/single_op_model.cc @@ -489,7 +489,7 @@ Status SingleOpModel::BuildKernelExTask(const domi::KernelExDef &kernel_def, AiC return SUCCESS; } -Status SingleOpModel::BuildCpuKernelTask(const domi::KernelDef &kernel_def, AicpuCCTask **task, uint64_t kernel_id) { +Status SingleOpModel::BuildCpuKernelTask(const domi::KernelDef &kernel_def, AiCpuCCTask **task, uint64_t kernel_id) { const auto &context = kernel_def.context(); auto iter = op_list_.find(context.op_index()); if (iter == op_list_.end()) { @@ -611,7 +611,7 @@ Status SingleOpModel::BuildTaskListForDynamicOp(StreamResource *stream_resource, } else if (lib_name == kEngineNameAiCpu) { const auto &task_def = task_defs[0]; GELOGD("Building AICPU_CC task"); - AicpuCCTask *task = nullptr; + AiCpuCCTask *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)); diff --git a/ge/single_op/single_op_model.h b/ge/single_op/single_op_model.h index 4057682d..22ee11b2 100755 --- a/ge/single_op/single_op_model.h +++ b/ge/single_op/single_op_model.h @@ -71,7 +71,7 @@ class SingleOpModel { Status BuildKernelTask(const domi::TaskDef &task_def, TbeOpTask **task); Status BuildAtomicTask(const domi::TaskDef &task_def, AtomicAddrCleanOpTask **task); Status BuildKernelExTask(const domi::KernelExDef &kernel_def, AiCpuTask **task, uint64_t kernel_id); - Status BuildCpuKernelTask(const domi::KernelDef &kernel_def, AicpuCCTask **task, uint64_t kernel_id); + Status BuildCpuKernelTask(const domi::KernelDef &kernel_def, AiCpuCCTask **task, uint64_t kernel_id); static void ParseOpModelParams(ModelHelper &model_helper, SingleOpModelParam ¶m); void ParseArgTable(OpTask *task, SingleOp &op); From 0f2fe9b165c3aecb19c477d61e1578247053777c Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 14:31:18 +0800 Subject: [PATCH 08/33] fix --- ge/single_op/task/op_task.h | 1 + 1 file changed, 1 insertion(+) diff --git a/ge/single_op/task/op_task.h b/ge/single_op/task/op_task.h index a0d5b574..ac7e489c 100644 --- a/ge/single_op/task/op_task.h +++ b/ge/single_op/task/op_task.h @@ -172,6 +172,7 @@ class AiCpuBaseTask : public OpTask { std::vector &output_desc, std::vector &output_buffers, rtStream_t stream) override; + virtual Status LaunchKernel(rtStream_t stream) = 0; protected: Status UpdateIoAddr(const std::vector &inputs, const std::vector &outputs); Status SetInputConst(); From f4d4445e167204ae0a6f8dccbb67154f4f843d51 Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 15:13:36 +0800 Subject: [PATCH 09/33] fix --- ge/single_op/task/op_task.cc | 38 +++++++++++++++++++++++++++++++++----- ge/single_op/task/op_task.h | 18 ++++++++++-------- 2 files changed, 43 insertions(+), 13 deletions(-) diff --git a/ge/single_op/task/op_task.cc b/ge/single_op/task/op_task.cc index b7b638de..7e58cc04 100755 --- a/ge/single_op/task/op_task.cc +++ b/ge/single_op/task/op_task.cc @@ -1136,11 +1136,39 @@ Status AiCpuTask::SetMemCopyTask(const domi::KernelExDef &kernel_def) { return SUCCESS; } -Status AiCpuBaseTask::LaunchKernel(const std::vector &input_desc, - const std::vector &input_buffers, - std::vector &output_desc, - std::vector &output_buffers, - rtStream_t stream) { +Status AiCpuTask::LaunchKernel(const std::vector &input_desc, + const std::vector &input_buffers, + std::vector &output_desc, + std::vector &output_buffers, + rtStream_t stream) { + GE_CHK_STATUS_RET_NOLOG(UpdateExtInfo(input_desc, output_desc, stream)); + 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)); + GE_CHK_STATUS_RET_NOLOG(UpdateOutputShape(output_desc)); + } else if (unknown_type_ == DEPEND_COMPUTE) { + GE_CHK_RT_RET(rtStreamSynchronize(stream)); + GE_CHK_STATUS_RET_NOLOG(UpdateShapeAndDataByResultSummary(output_desc, output_buffers, stream)); + } + + return SUCCESS; +} + +Status AiCpuCCTask::LaunchKernel(const std::vector &input_desc, + const std::vector &input_buffers, + std::vector &output_desc, + std::vector &output_buffers, + rtStream_t stream) { GE_CHK_STATUS_RET_NOLOG(UpdateExtInfo(input_desc, output_desc, stream)); if (unknown_type_ == DEPEND_COMPUTE) { std::vector summary_buffers; diff --git a/ge/single_op/task/op_task.h b/ge/single_op/task/op_task.h index ac7e489c..836b2046 100644 --- a/ge/single_op/task/op_task.h +++ b/ge/single_op/task/op_task.h @@ -167,12 +167,6 @@ class AiCpuBaseTask : public OpTask { UnknowShapeOpType GetUnknownType() const { return unknown_type_; } Status UpdateArgTable(const SingleOpModelParam ¶m) override; const std::string &GetTaskType() const override; - Status LaunchKernel(const std::vector &input_desc, - const std::vector &input_buffers, - std::vector &output_desc, - std::vector &output_buffers, - rtStream_t stream) override; - virtual Status LaunchKernel(rtStream_t stream) = 0; protected: Status UpdateIoAddr(const std::vector &inputs, const std::vector &outputs); Status SetInputConst(); @@ -226,7 +220,11 @@ class AiCpuTask : public AiCpuBaseTask { Status LaunchKernel(rtStream_t stream) override; void GetIoAddr(uintptr_t *&arg_base, size_t &arg_count) override; - + Status LaunchKernel(const std::vector &input_desc, + const std::vector &input_buffers, + std::vector &output_desc, + std::vector &output_buffers, + rtStream_t stream) override; Status SetMemCopyTask(const domi::KernelExDef &kernel_def); private: @@ -265,6 +263,11 @@ class AiCpuCCTask : public AiCpuBaseTask { AiCpuCCTask &operator=(const AiCpuCCTask &) = delete; Status SetMemCopyTask(const domi::KernelDef &kernel_def); Status LaunchKernel(rtStream_t stream) override; + Status LaunchKernel(const std::vector &input_desc, + const std::vector &input_buffers, + std::vector &output_desc, + std::vector &output_buffers, + rtStream_t stream) override; void GetIoAddr(uintptr_t *&arg_base, size_t &arg_count) override; const void *GetArgs() const; void SetKernelArgs(std::unique_ptr args, size_t arg_size); @@ -274,7 +277,6 @@ class AiCpuCCTask : public AiCpuBaseTask { size_t GetArgSize() const; private: Status InitForSummaryAndCopy(); - Status CopyDataToHbm(vector &outputs, rtStream_t stream) override; private: friend class AiCpuCCTaskBuilder; From c8e2ac3c1358b9b94ed8a6581e612109ef05f663 Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 15:55:25 +0800 Subject: [PATCH 10/33] fix --- tests/ut/ge/single_op/single_op_task_unittest.cc | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) 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 e4f72f9b..57d2db13 100644 --- a/tests/ut/ge/single_op/single_op_task_unittest.cc +++ b/tests/ut/ge/single_op/single_op_task_unittest.cc @@ -197,7 +197,12 @@ TEST_F(UtestSingleOpTask, test_atomic_exec) { } TEST_F(UtestSingleOpTask, test_aicpu_task_launch_kernel) { AiCpuCCTask task; - rtStream_t stream = nullptr; + rtStream_t stream; + ASSERT_EQ(rtStreamCreate(&stream, 0), RT_ERROR_NONE); + auto op_desc = make_shared("deque", "Deque"); + ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, false); + AttrUtils::SetInt(op_desc, ::ge::ATTR_NAME_UNKNOWN_SHAPE_TYPE, ge::DEPEND_COMPUTE); + task.SetOpDesc(op_desc); task.num_inputs_ = 2; task.num_outputs_ = 1; task.input_is_const_ = {true, false}; @@ -220,7 +225,6 @@ TEST_F(UtestSingleOpTask, test_aicpu_task_launch_kernel) { vector outputs_desc(1, GeTensorDesc(GeShape(), FORMAT_NCHW, DT_FLOAT)); ASSERT_EQ(task.SetExtInfoAndType(ext_info_str, 0), SUCCESS); 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); } From 61546cc38ffc51f2c7f1bf4e9d46d7ad19f78a90 Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 16:25:41 +0800 Subject: [PATCH 11/33] fix ut --- tests/ut/ge/single_op/single_op_task_unittest.cc | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) 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 57d2db13..356fc0e8 100644 --- a/tests/ut/ge/single_op/single_op_task_unittest.cc +++ b/tests/ut/ge/single_op/single_op_task_unittest.cc @@ -202,6 +202,7 @@ TEST_F(UtestSingleOpTask, test_aicpu_task_launch_kernel) { auto op_desc = make_shared("deque", "Deque"); ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, false); AttrUtils::SetInt(op_desc, ::ge::ATTR_NAME_UNKNOWN_SHAPE_TYPE, ge::DEPEND_COMPUTE); + GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT); task.SetOpDesc(op_desc); task.num_inputs_ = 2; task.num_outputs_ = 1; @@ -221,11 +222,13 @@ TEST_F(UtestSingleOpTask, test_aicpu_task_launch_kernel) { std::string ext_info_str(ext_mem, sizeof(ge::hybrid::AicpuExtInfo) + sizeof(int32_t)); 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)); + vector inputs_desc(2, tensor); + vector outputs_desc(1, tensor); ASSERT_EQ(task.SetExtInfoAndType(ext_info_str, 0), SUCCESS); task.unknown_type_ = ge::DEPEND_COMPUTE; ASSERT_EQ(task.InitForSummaryAndCopy(), SUCCESS); + task.num_inputs_ = 0; + task.num_outputs_ = 0; ASSERT_EQ(task.LaunchKernel(inputs_desc, inputs, outputs_desc, outputs, stream), SUCCESS); } TEST_F(UtestSingleOpTask, test_aicpu_task_update_io_addr) { From 42c51addd3a1a2010395fbc0978dbd80e29b2a4b Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 16:57:24 +0800 Subject: [PATCH 12/33] fix --- tests/ut/ge/single_op/single_op_task_unittest.cc | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) 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 356fc0e8..74dba70f 100644 --- a/tests/ut/ge/single_op/single_op_task_unittest.cc +++ b/tests/ut/ge/single_op/single_op_task_unittest.cc @@ -203,6 +203,9 @@ TEST_F(UtestSingleOpTask, test_aicpu_task_launch_kernel) { ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, false); AttrUtils::SetInt(op_desc, ::ge::ATTR_NAME_UNKNOWN_SHAPE_TYPE, ge::DEPEND_COMPUTE); GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT); + op_desc->AddInputDesc(tensor); + op_desc->AddInputDesc(tensor); + op_desc->AddOutputDesc(tensor); task.SetOpDesc(op_desc); task.num_inputs_ = 2; task.num_outputs_ = 1; @@ -227,8 +230,6 @@ TEST_F(UtestSingleOpTask, test_aicpu_task_launch_kernel) { ASSERT_EQ(task.SetExtInfoAndType(ext_info_str, 0), SUCCESS); task.unknown_type_ = ge::DEPEND_COMPUTE; ASSERT_EQ(task.InitForSummaryAndCopy(), SUCCESS); - task.num_inputs_ = 0; - task.num_outputs_ = 0; ASSERT_EQ(task.LaunchKernel(inputs_desc, inputs, outputs_desc, outputs, stream), SUCCESS); } TEST_F(UtestSingleOpTask, test_aicpu_task_update_io_addr) { From 329b87db7158b756ae023b6d2f94dfd7fbd064d5 Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 17:29:43 +0800 Subject: [PATCH 13/33] fix --- tests/ut/ge/single_op/single_op_task_unittest.cc | 24 ++---------------------- 1 file changed, 2 insertions(+), 22 deletions(-) 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 74dba70f..790d64b0 100644 --- a/tests/ut/ge/single_op/single_op_task_unittest.cc +++ b/tests/ut/ge/single_op/single_op_task_unittest.cc @@ -199,14 +199,6 @@ TEST_F(UtestSingleOpTask, test_aicpu_task_launch_kernel) { AiCpuCCTask task; rtStream_t stream; ASSERT_EQ(rtStreamCreate(&stream, 0), RT_ERROR_NONE); - auto op_desc = make_shared("deque", "Deque"); - ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, false); - AttrUtils::SetInt(op_desc, ::ge::ATTR_NAME_UNKNOWN_SHAPE_TYPE, ge::DEPEND_COMPUTE); - GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT); - op_desc->AddInputDesc(tensor); - op_desc->AddInputDesc(tensor); - op_desc->AddOutputDesc(tensor); - task.SetOpDesc(op_desc); task.num_inputs_ = 2; task.num_outputs_ = 1; task.input_is_const_ = {true, false}; @@ -214,24 +206,12 @@ TEST_F(UtestSingleOpTask, test_aicpu_task_launch_kernel) { uint32_t* addrs[total_addr] = {nullptr, nullptr, nullptr}; task.io_addr_ = reinterpret_cast(addrs); task.io_addr_num_ = total_addr; - 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)); - std::string ext_info_str(ext_mem, sizeof(ge::hybrid::AicpuExtInfo) + sizeof(int32_t)); - vector inputs(2, DataBuffer()); vector outputs(1, DataBuffer()); - vector inputs_desc(2, tensor); - vector outputs_desc(1, tensor); - ASSERT_EQ(task.SetExtInfoAndType(ext_info_str, 0), SUCCESS); task.unknown_type_ = ge::DEPEND_COMPUTE; ASSERT_EQ(task.InitForSummaryAndCopy(), SUCCESS); - ASSERT_EQ(task.LaunchKernel(inputs_desc, inputs, outputs_desc, outputs, stream), SUCCESS); + ASSERT_EQ(task.CopyDataToHbm(outputs, stream), SUCCESS); } + TEST_F(UtestSingleOpTask, test_aicpu_task_update_io_addr) { AiCpuCCTask task; task.num_inputs_ = 2; From 4da8bee7502f4a621aab7665d13ac323f487b34f Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 18:21:18 +0800 Subject: [PATCH 14/33] fix --- tests/ut/ge/single_op/single_op_task_unittest.cc | 1 - 1 file changed, 1 deletion(-) 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 790d64b0..19895a09 100644 --- a/tests/ut/ge/single_op/single_op_task_unittest.cc +++ b/tests/ut/ge/single_op/single_op_task_unittest.cc @@ -209,7 +209,6 @@ TEST_F(UtestSingleOpTask, test_aicpu_task_launch_kernel) { vector outputs(1, DataBuffer()); task.unknown_type_ = ge::DEPEND_COMPUTE; ASSERT_EQ(task.InitForSummaryAndCopy(), SUCCESS); - ASSERT_EQ(task.CopyDataToHbm(outputs, stream), SUCCESS); } TEST_F(UtestSingleOpTask, test_aicpu_task_update_io_addr) { From bccd5893dcf0afe3c000765dc805f35f70090a98 Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 20 Jul 2021 19:26:10 +0800 Subject: [PATCH 15/33] fix ut --- .../ut/ge/hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 734ee2be..d7ad0932 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 @@ -240,7 +240,7 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_blocking_node_task) { kernel_def.set_args_size(args.head.length); domi::KernelDef *kernel_def_tmp = task_def.mutable_kernel(); *kernel_def_tmp = kernel_def; - + hybrid_model.task_defs_[node] = std::vector({task_def}); AicpuNodeTask aicpu_node_task(node_item, task_def); ASSERT_EQ(aicpu_node_task.Init(hybrid_model), SUCCESS); ASSERT_EQ(aicpu_node_task.LaunchTask(*node_state->GetTaskContext()), SUCCESS); @@ -323,7 +323,7 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_blocking_node_task_fail) { kernel_def.set_args_size(args.head.length); domi::KernelDef *kernel_def_tmp = task_def.mutable_kernel(); *kernel_def_tmp = kernel_def; - + hybrid_model.task_defs_[node] = std::vector({task_def}); AicpuNodeTask aicpu_node_task(node_item, task_def); RTS_STUB_RETURN_VALUE(rtGetDevice, rtError_t, 0x78000001); From eca6fb51a4c107325d9b6c3b4b6ea1e71c4bb2de Mon Sep 17 00:00:00 2001 From: guopeian Date: Wed, 21 Jul 2021 11:49:56 +0800 Subject: [PATCH 16/33] fix ut --- .../aicpu/aicpu_node_executor_unittest.cc | 25 ++++++++++++++++++++++ tests/ut/ge/single_op/single_op_model_unittest.cc | 17 +++++++++++++++ 2 files changed, 42 insertions(+) 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 d7ad0932..036ea8c7 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 @@ -177,6 +177,31 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_tf_node_task) { } +TEST_F(UtestAicpuNodeExecutor, aicpu_memcopy_task) { + std::unique_ptr new_node; + ASSERT_EQ(NodeItem::Create(node, new_node), SUCCESS); + NodeItem *node_item = new_node.get(); + AicpuTaskStruct args; + args.head.length = sizeof(args); + args.head.ioAddrNum = 6; + + domi::TaskDef task_def; + task_def.set_type(RT_MODEL_TASK_ALL_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); + node_item->num_outputs = 0; + AicpuNodeTask aicpu_node_task(node_item, task_def); + ASSERT_EQ(aicpu_nod_task.SetMemCopyTask(task_def), SUCCESS); + aicpu_node_task->node_item_->num_outputs = 1; + kernel_def->set_args_size(0); + ASSERT_EQ(aicpu_nod_task.SetMemCopyTask(task_def), FAILED); + char* args2 = "123"; + kernel_def->set_args(reinterpret_cast(&args2), 3); + kernel_def->set_args_size(3); + ASSERT_EQ(aicpu_nod_task.SetMemCopyTask(task_def), FAILED); +} + TEST_F(UtestAicpuNodeExecutor, aicpu_blocking_node_task) { ComputeGraphPtr graph = std::make_shared("test"); GeRootModelPtr ge_root_model = std::make_shared(graph); 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 f20e47d6..09d97b23 100644 --- a/tests/ut/ge/single_op/single_op_model_unittest.cc +++ b/tests/ut/ge/single_op/single_op_model_unittest.cc @@ -417,3 +417,20 @@ TEST_F(UtestSingleOpModel, build_dynamic_task02) { op_desc->SetOpKernelLibName(kEngineNameAiCpu); model.BuildTaskListForDynamicOp(res, single_op); } + +TEST_F(UtestSingleOpModel, build_memcpoy_task) { + 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(0); + AiCpuCCTask aicpu_task; + ASSERT_EQ(aicpu_task。SetMemCopyTask(kernel_def), FAILED); + char* args2 = "123"; + kernel_def->set_args(reinterpret_cast(&args2), 3); + kernel_def->set_args_size(3); + ASSERT_EQ(aicpu_task。SetMemCopyTask(kernel_def), FAILED); +} From 20a31151c63797ef1f4a6fcf3ced05843f380a8f Mon Sep 17 00:00:00 2001 From: guopeian Date: Wed, 21 Jul 2021 12:41:08 +0800 Subject: [PATCH 17/33] fix --- tests/ut/ge/single_op/single_op_model_unittest.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 09d97b23..77f3e3f1 100644 --- a/tests/ut/ge/single_op/single_op_model_unittest.cc +++ b/tests/ut/ge/single_op/single_op_model_unittest.cc @@ -428,9 +428,9 @@ TEST_F(UtestSingleOpModel, build_memcpoy_task) { kernel_def->set_args(reinterpret_cast(&args), args.head.length); kernel_def->set_args_size(0); AiCpuCCTask aicpu_task; - ASSERT_EQ(aicpu_task。SetMemCopyTask(kernel_def), FAILED); + ASSERT_EQ(aicpu_task.SetMemCopyTask(kernel_def), FAILED); char* args2 = "123"; kernel_def->set_args(reinterpret_cast(&args2), 3); kernel_def->set_args_size(3); - ASSERT_EQ(aicpu_task。SetMemCopyTask(kernel_def), FAILED); + ASSERT_EQ(aicpu_task.SetMemCopyTask(kernel_def), FAILED); } From a6140ebc17e7da227ef7d04f5bf483e3d4ba35b6 Mon Sep 17 00:00:00 2001 From: guopeian Date: Wed, 21 Jul 2021 13:59:16 +0800 Subject: [PATCH 18/33] fix ut --- tests/ut/ge/single_op/single_op_model_unittest.cc | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) 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 77f3e3f1..a6466972 100644 --- a/tests/ut/ge/single_op/single_op_model_unittest.cc +++ b/tests/ut/ge/single_op/single_op_model_unittest.cc @@ -422,15 +422,13 @@ TEST_F(UtestSingleOpModel, build_memcpoy_task) { 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(0); + domi::KernelDef kernel_def; + kernel_def.set_args(reinterpret_cast(&args), args.head.length); + kernel_def.set_args_size(0); AiCpuCCTask aicpu_task; ASSERT_EQ(aicpu_task.SetMemCopyTask(kernel_def), FAILED); char* args2 = "123"; - kernel_def->set_args(reinterpret_cast(&args2), 3); - kernel_def->set_args_size(3); + kernel_def.set_args(reinterpret_cast(&args2), 3); + kernel_def.set_args_size(3); ASSERT_EQ(aicpu_task.SetMemCopyTask(kernel_def), FAILED); } From 5682addc4f5019bee9db02b79169b94c79f56792 Mon Sep 17 00:00:00 2001 From: guopeian Date: Wed, 21 Jul 2021 14:24:41 +0800 Subject: [PATCH 19/33] fix ut --- .../node_executor/aicpu/aicpu_node_executor_unittest.cc | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) 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 036ea8c7..5d24cd81 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 @@ -178,6 +178,13 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_tf_node_task) { } TEST_F(UtestAicpuNodeExecutor, aicpu_memcopy_task) { + ComputeGraphPtr graph = std::make_shared("test"); + GeModelPtr ge_sub_model = std::make_shared(); + GeRootModelPtr ge_root_model = std::make_shared(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 new_node; ASSERT_EQ(NodeItem::Create(node, new_node), SUCCESS); NodeItem *node_item = new_node.get(); @@ -193,13 +200,13 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_memcopy_task) { node_item->num_outputs = 0; AicpuNodeTask aicpu_node_task(node_item, task_def); ASSERT_EQ(aicpu_nod_task.SetMemCopyTask(task_def), SUCCESS); - aicpu_node_task->node_item_->num_outputs = 1; + aicpu_node_task.node_item_->num_outputs = 1; kernel_def->set_args_size(0); - ASSERT_EQ(aicpu_nod_task.SetMemCopyTask(task_def), FAILED); + ASSERT_EQ(aicpu_node_task.SetMemCopyTask(task_def), FAILED); char* args2 = "123"; kernel_def->set_args(reinterpret_cast(&args2), 3); kernel_def->set_args_size(3); - ASSERT_EQ(aicpu_nod_task.SetMemCopyTask(task_def), FAILED); + ASSERT_EQ(aicpu_node_task.SetMemCopyTask(task_def), FAILED); } TEST_F(UtestAicpuNodeExecutor, aicpu_blocking_node_task) { From dfaa81737dc041a8696da824973c85d0925ad319 Mon Sep 17 00:00:00 2001 From: guopeian Date: Wed, 21 Jul 2021 14:47:34 +0800 Subject: [PATCH 20/33] fix ut --- tests/ut/ge/hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 5d24cd81..823de01c 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 @@ -199,7 +199,7 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_memcopy_task) { kernel_def->set_args_size(args.head.length); node_item->num_outputs = 0; AicpuNodeTask aicpu_node_task(node_item, task_def); - ASSERT_EQ(aicpu_nod_task.SetMemCopyTask(task_def), SUCCESS); + ASSERT_EQ(aicpu_node_task.SetMemCopyTask(task_def), SUCCESS); aicpu_node_task.node_item_->num_outputs = 1; kernel_def->set_args_size(0); ASSERT_EQ(aicpu_node_task.SetMemCopyTask(task_def), FAILED); From fed02a66747d39e77d3141c433ba8c5b7893e5e0 Mon Sep 17 00:00:00 2001 From: guopeian Date: Wed, 21 Jul 2021 14:59:56 +0800 Subject: [PATCH 21/33] fix --- tests/ut/ge/hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc | 1 - 1 file changed, 1 deletion(-) 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 823de01c..1b4b87f9 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 @@ -174,7 +174,6 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_tf_node_task) { //kernel_ex_def->set_allocated_kernel_ext_info(nullptr); free(ext_mem); free(ext_mem2); - } TEST_F(UtestAicpuNodeExecutor, aicpu_memcopy_task) { From bdcbe20915cea02285d376ba8506ee5a230a82b3 Mon Sep 17 00:00:00 2001 From: guopeian Date: Wed, 21 Jul 2021 15:21:20 +0800 Subject: [PATCH 22/33] fix ut --- .../ge/hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) 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 1b4b87f9..61427594 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 @@ -199,13 +199,14 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_memcopy_task) { node_item->num_outputs = 0; AicpuNodeTask aicpu_node_task(node_item, task_def); ASSERT_EQ(aicpu_node_task.SetMemCopyTask(task_def), SUCCESS); - aicpu_node_task.node_item_->num_outputs = 1; + node_item->num_outputs = 1; + AicpuNodeTask aicpu_node_task2(node_item, task_def); kernel_def->set_args_size(0); - ASSERT_EQ(aicpu_node_task.SetMemCopyTask(task_def), FAILED); + ASSERT_EQ(aicpu_node_task2.SetMemCopyTask(task_def), FAILED); char* args2 = "123"; kernel_def->set_args(reinterpret_cast(&args2), 3); kernel_def->set_args_size(3); - ASSERT_EQ(aicpu_node_task.SetMemCopyTask(task_def), FAILED); + ASSERT_EQ(aicpu_node_task2.SetMemCopyTask(task_def), FAILED); } TEST_F(UtestAicpuNodeExecutor, aicpu_blocking_node_task) { From c300f3b2aac083885461f5f960fd8a276e2af419 Mon Sep 17 00:00:00 2001 From: guopeian Date: Wed, 21 Jul 2021 15:56:49 +0800 Subject: [PATCH 23/33] fix ut --- tests/ut/ge/hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc | 1 + tests/ut/ge/single_op/single_op_model_unittest.cc | 2 ++ 2 files changed, 3 insertions(+) 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 61427594..402170c3 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 @@ -201,6 +201,7 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_memcopy_task) { ASSERT_EQ(aicpu_node_task.SetMemCopyTask(task_def), SUCCESS); node_item->num_outputs = 1; AicpuNodeTask aicpu_node_task2(node_item, task_def); + ASSERT_EQ(aicpu_node_task2.SetMemCopyTask(task_def), FAILED); kernel_def->set_args_size(0); ASSERT_EQ(aicpu_node_task2.SetMemCopyTask(task_def), FAILED); char* args2 = "123"; 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 a6466972..666c31c8 100644 --- a/tests/ut/ge/single_op/single_op_model_unittest.cc +++ b/tests/ut/ge/single_op/single_op_model_unittest.cc @@ -424,6 +424,8 @@ TEST_F(UtestSingleOpModel, build_memcpoy_task) { args.head.ioAddrNum = 6; domi::KernelDef kernel_def; kernel_def.set_args(reinterpret_cast(&args), args.head.length); + kernel_def.set_args_size(args.head.length); + ASSERT_EQ(aicpu_task.SetMemCopyTask(kernel_def), FAILED); kernel_def.set_args_size(0); AiCpuCCTask aicpu_task; ASSERT_EQ(aicpu_task.SetMemCopyTask(kernel_def), FAILED); From 77ef308619a754b2612e4156f31feb5c3ae5c60b Mon Sep 17 00:00:00 2001 From: guopeian Date: Wed, 21 Jul 2021 16:37:09 +0800 Subject: [PATCH 24/33] fix --- .../aicpu/aicpu_node_executor_unittest.cc | 79 ++++++++++++++++++++++ 1 file changed, 79 insertions(+) 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 402170c3..29a6e97c 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 @@ -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("test"); + GeModelPtr ge_sub_model = std::make_shared(); + GeRootModelPtr ge_root_model = std::make_shared(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 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(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(&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({task_def, task_def}); + + AicpuNodeTask aicpu_node_task(node_item, task_def); + std::vector> &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("test"); GeRootModelPtr ge_root_model = std::make_shared(graph); From 5037bd533d6e15126f949e598245a46e7ddaeb35 Mon Sep 17 00:00:00 2001 From: guopeian Date: Wed, 21 Jul 2021 17:02:26 +0800 Subject: [PATCH 25/33] fix ut --- tests/ut/ge/single_op/single_op_model_unittest.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 666c31c8..5c8661ef 100644 --- a/tests/ut/ge/single_op/single_op_model_unittest.cc +++ b/tests/ut/ge/single_op/single_op_model_unittest.cc @@ -425,9 +425,9 @@ TEST_F(UtestSingleOpModel, build_memcpoy_task) { domi::KernelDef kernel_def; kernel_def.set_args(reinterpret_cast(&args), args.head.length); kernel_def.set_args_size(args.head.length); + AiCpuCCTask aicpu_task; ASSERT_EQ(aicpu_task.SetMemCopyTask(kernel_def), FAILED); kernel_def.set_args_size(0); - AiCpuCCTask aicpu_task; ASSERT_EQ(aicpu_task.SetMemCopyTask(kernel_def), FAILED); char* args2 = "123"; kernel_def.set_args(reinterpret_cast(&args2), 3); From e370f1cefe6aa1704e9099a2bf99fa64743399cb Mon Sep 17 00:00:00 2001 From: guopeian Date: Wed, 21 Jul 2021 17:25:16 +0800 Subject: [PATCH 26/33] fix --- .../aicpu/aicpu_node_executor_unittest.cc | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-) 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 29a6e97c..294da594 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 @@ -265,24 +265,17 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_copy_data_to_hbm) { 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); - 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({task_def, task_def}); AicpuNodeTask aicpu_node_task(node_item, task_def); - std::vector> &out_shape_hbm; + std::vector> 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; + const auto &summary = aicpu_node_task.output_summary_[i]; + summary.shape_data_size = 1; + summary.raw_data_size = 1; + summary.shape_data_ptr = 0; + summary.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); From 00af5bdcbed6953ea046da4a327542b57d0c4601 Mon Sep 17 00:00:00 2001 From: guopeian Date: Thu, 22 Jul 2021 09:04:53 +0800 Subject: [PATCH 27/33] fix ut --- .../hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) 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 294da594..1fb5f91d 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 @@ -271,11 +271,11 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_copy_data_to_hbm) { std::vector> out_shape_hbm; ASSERT_EQ(aicpu_node_task.Init(hybrid_model), SUCCESS); for (int i = 0; i < node_item->num_outputs; i++) { - const auto &summary = aicpu_node_task.output_summary_[i]; - summary.shape_data_size = 1; - summary.raw_data_size = 1; - summary.shape_data_ptr = 0; - summary.raw_data_ptr = 0; + auto &summary = aicpu_node_task.output_summary_[i]; + summary->shape_data_size = 1; + summary->raw_data_size = 1; + summary->shape_data_ptr = 0; + summary->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); From 36aec1f9019a16e7d458a2377471ba36fa11f40b Mon Sep 17 00:00:00 2001 From: guopeian Date: Thu, 22 Jul 2021 11:22:26 +0800 Subject: [PATCH 28/33] fix ut --- .../node_executor/aicpu/aicpu_node_executor_unittest.cc | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) 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 1fb5f91d..36dcbdb6 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 @@ -271,13 +271,17 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_copy_data_to_hbm) { std::vector> out_shape_hbm; ASSERT_EQ(aicpu_node_task.Init(hybrid_model), SUCCESS); for (int i = 0; i < node_item->num_outputs; i++) { - auto &summary = aicpu_node_task.output_summary_[i]; - summary->shape_data_size = 1; - summary->raw_data_size = 1; - summary->shape_data_ptr = 0; - summary->raw_data_ptr = 0; + auto &summary = output_summary_host_[i]; + summary.shape_data_ptr = 0; + summary.shape_data_size = 1; + summary.raw_data_ptr = 0; + summary.raw_data_size = 1; + } + for (int i = 0; i < node_item->num_outputs; i++) { + std::unique_ptr shape_buffer; + AllocTensorBuffer(1, shape_buffer); + out_shape_hbm.emplace_back(std::move(shape_buffer)); } - 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); } From 46305366de888009cfa13465034e6765aaf3cba4 Mon Sep 17 00:00:00 2001 From: guopeian Date: Thu, 22 Jul 2021 13:54:17 +0800 Subject: [PATCH 29/33] fix --- .../node_executor/aicpu/aicpu_node_executor_unittest.cc | 15 ++++++++++++--- tests/ut/ge/single_op/single_op_model_unittest.cc | 2 +- 2 files changed, 13 insertions(+), 4 deletions(-) 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 36dcbdb6..2bf5b8ac 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 @@ -201,7 +201,7 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_memcopy_task) { ASSERT_EQ(aicpu_node_task.SetMemCopyTask(task_def), SUCCESS); node_item->num_outputs = 1; AicpuNodeTask aicpu_node_task2(node_item, task_def); - ASSERT_EQ(aicpu_node_task2.SetMemCopyTask(task_def), FAILED); + ASSERT_EQ(aicpu_node_task2.SetMemCopyTask(task_def), INTERNAL_ERROR); kernel_def->set_args_size(0); ASSERT_EQ(aicpu_node_task2.SetMemCopyTask(task_def), FAILED); char* args2 = "123"; @@ -265,13 +265,22 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_copy_data_to_hbm) { 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); + 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 = node_item->shape_inference_type; + 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_info, 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({task_def, task_def}); AicpuNodeTask aicpu_node_task(node_item, task_def); std::vector> out_shape_hbm; ASSERT_EQ(aicpu_node_task.Init(hybrid_model), SUCCESS); for (int i = 0; i < node_item->num_outputs; i++) { - auto &summary = output_summary_host_[i]; + auto &summary = aicpu_node_task.output_summary_host_[i]; summary.shape_data_ptr = 0; summary.shape_data_size = 1; summary.raw_data_ptr = 0; @@ -279,7 +288,7 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_copy_data_to_hbm) { } for (int i = 0; i < node_item->num_outputs; i++) { std::unique_ptr shape_buffer; - AllocTensorBuffer(1, shape_buffer); + AicpuNodeTask::AllocTensorBuffer(1, shape_buffer); out_shape_hbm.emplace_back(std::move(shape_buffer)); } ASSERT_EQ(aicpu_node_task.CopyDataToHbm(*node_state->GetTaskContext(), out_shape_hbm), SUCCESS); 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 5c8661ef..1e097616 100644 --- a/tests/ut/ge/single_op/single_op_model_unittest.cc +++ b/tests/ut/ge/single_op/single_op_model_unittest.cc @@ -426,7 +426,7 @@ TEST_F(UtestSingleOpModel, build_memcpoy_task) { kernel_def.set_args(reinterpret_cast(&args), args.head.length); kernel_def.set_args_size(args.head.length); AiCpuCCTask aicpu_task; - ASSERT_EQ(aicpu_task.SetMemCopyTask(kernel_def), FAILED); + ASSERT_EQ(aicpu_task.SetMemCopyTask(kernel_def), INTERNAL_ERROR); kernel_def.set_args_size(0); ASSERT_EQ(aicpu_task.SetMemCopyTask(kernel_def), FAILED); char* args2 = "123"; From c9d0ebc89ad1a007875fa14168c4ac84524febcb Mon Sep 17 00:00:00 2001 From: guopeian Date: Thu, 22 Jul 2021 16:48:43 +0800 Subject: [PATCH 30/33] fix ut --- ge/single_op/task/op_task.cc | 1 - tests/ut/ge/single_op/single_op_model_unittest.cc | 2 +- tests/ut/ge/single_op/single_op_task_unittest.cc | 34 ++++++++++++++++++++++- 3 files changed, 34 insertions(+), 3 deletions(-) diff --git a/ge/single_op/task/op_task.cc b/ge/single_op/task/op_task.cc index 7e58cc04..57222354 100755 --- a/ge/single_op/task/op_task.cc +++ b/ge/single_op/task/op_task.cc @@ -955,7 +955,6 @@ Status AiCpuBaseTask::PrepareCopyInputs(vector &outputs) { } const size_t copy_input_buf_len = num_outputs_ * kCopyNum * sizeof(uint64_t); - GE_CHK_RT_RET(rtMemcpy(copy_input_release_flag_dev_, copy_input_buf_len, copy_input_release_flag.data(), copy_input_buf_len, RT_MEMCPY_HOST_TO_DEVICE)); GE_CHK_RT_RET(rtMemcpy(copy_input_data_size_dev_, copy_input_buf_len, 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 1e097616..ba31f9b8 100644 --- a/tests/ut/ge/single_op/single_op_model_unittest.cc +++ b/tests/ut/ge/single_op/single_op_model_unittest.cc @@ -433,4 +433,4 @@ TEST_F(UtestSingleOpModel, build_memcpoy_task) { kernel_def.set_args(reinterpret_cast(&args2), 3); kernel_def.set_args_size(3); ASSERT_EQ(aicpu_task.SetMemCopyTask(kernel_def), FAILED); -} +} \ 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 19895a09..609bff65 100644 --- a/tests/ut/ge/single_op/single_op_task_unittest.cc +++ b/tests/ut/ge/single_op/single_op_task_unittest.cc @@ -16,7 +16,7 @@ #include #include - +#include #include "graph/load/model_manager/model_utils.h" #include "graph/utils/graph_utils.h" #include "hybrid/node_executor/aicpu/aicpu_ext_info.h" @@ -25,6 +25,7 @@ #define protected public #define private public #include "single_op/single_op_model.h" +#include "aicpu/common/aicpu_task_struct.h" #include "single_op/task/tbe_task_builder.h" #include "single_op/task/op_task.h" #include "single_op/task/tbe_task_builder.h" @@ -38,6 +39,13 @@ using namespace testing; using namespace ge; using namespace optiling; +namespace { + struct AicpuTaskStruct { + aicpu::AicpuParamHead head; + uint64_t io_addrp[3]; +}__attribute__((packed)); +} // namespace + class UtestSingleOpTask : public testing::Test { protected: void SetUp() { @@ -195,6 +203,7 @@ TEST_F(UtestSingleOpTask, test_atomic_exec) { optiling::utils::OpRunInfo run_info(0, true, 0); task.CalcTilingInfo(run_info); } + TEST_F(UtestSingleOpTask, test_aicpu_task_launch_kernel) { AiCpuCCTask task; rtStream_t stream; @@ -207,8 +216,31 @@ TEST_F(UtestSingleOpTask, test_aicpu_task_launch_kernel) { task.io_addr_ = reinterpret_cast(addrs); task.io_addr_num_ = total_addr; vector outputs(1, DataBuffer()); + outputs[0].data = 0; task.unknown_type_ = ge::DEPEND_COMPUTE; ASSERT_EQ(task.InitForSummaryAndCopy(), SUCCESS); + auto &summary = task.output_summary_host_[0]; + summary.shape_data_ptr = 0; + summary.shape_data_size = 1; + summary.raw_data_ptr = 0; + summary.raw_data_size = 1; + void *shape_buffer = nullptr; + rtMalloc(&shape_buffer, 1, RT_MEMORY_HBM); + task.out_shape_hbm_.emplace_back(shape_buffer); + task.memcpy_so_name_ = "libcpu_kernel.so"; + task.memcpy_kernel_name_ = "RunCpuKernel"; + AicpuTaskStruct args; + args.head.length = sizeof(args); + args.head.ioAddrNum = 3; + domi::TaskDef task_def; + 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); + auto &memcpy_args = kernel_def->args(); + task.memcpy_args_size_ = kernel_def->args_size(); + task.memcpy_args_.reset(new(std::nothrow) uint8_t[task.memcpy_args_size_]()); + memcpy_s(task.memcpy_args_.get(), task.memcpy_args_size_, memcpy_args.c_str(), memcpy_args.size()); + ASSERT_EQ(task.CopyDataToHbm(outputs, stream), SUCCESS); } TEST_F(UtestSingleOpTask, test_aicpu_task_update_io_addr) { From c42df5942e7b8ada59b117055d75eabc1d7d18d6 Mon Sep 17 00:00:00 2001 From: guopeian Date: Thu, 22 Jul 2021 17:18:10 +0800 Subject: [PATCH 31/33] fix ut --- tests/ut/ge/single_op/single_op_model_unittest.cc | 2 ++ 1 file changed, 2 insertions(+) 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 ba31f9b8..c3439aac 100644 --- a/tests/ut/ge/single_op/single_op_model_unittest.cc +++ b/tests/ut/ge/single_op/single_op_model_unittest.cc @@ -416,6 +416,8 @@ TEST_F(UtestSingleOpModel, build_dynamic_task02) { model.node_tasks_[node] = { *task_def, *task_def }; op_desc->SetOpKernelLibName(kEngineNameAiCpu); model.BuildTaskListForDynamicOp(res, single_op); + model.node_tasks_[node] = { *task_def}; + model.BuildTaskListForDynamicOp(res, single_op); } TEST_F(UtestSingleOpModel, build_memcpoy_task) { From eb9700d144aae7f03dc3de75754c61f9be0e3d58 Mon Sep 17 00:00:00 2001 From: guopeian Date: Fri, 23 Jul 2021 09:49:55 +0800 Subject: [PATCH 32/33] fix --- ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc index 19cfbfff..386726c8 100755 --- a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc +++ b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc @@ -856,7 +856,7 @@ Status AicpuNodeTask::SetMemCopyTask(const domi::TaskDef &task_def) { // 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); - if (cpy_ret != 0) { + if (cpy_ret != EOK) { 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); @@ -1060,7 +1060,7 @@ Status AicpuNodeTask::UpdateIoAddr(TaskContext &context) { // if has input and output, need copy to ioaddr int cpy_ret = memcpy_s(io_addr, args_size_ - sizeof(aicpu::AicpuParamHead), &io_addrs[0], sizeof(uint64_t) * io_addrs.size()); - GE_IF_BOOL_EXEC(cpy_ret != 0, + GE_IF_BOOL_EXEC(cpy_ret != EOK, REPORT_INNER_ERROR("E19999", "Node[%s] memcpy io addr to AicpuParamHead failed," "ret=%d, args_size=%u, io nums=%zu.", node_name_.c_str(), cpy_ret, args_size_, io_addrs.size()); From a134c4df32e5bbaab85bca7926e1d8b04184711b Mon Sep 17 00:00:00 2001 From: guopeian Date: Fri, 23 Jul 2021 10:57:08 +0800 Subject: [PATCH 33/33] fix ut --- ge/single_op/task/op_task.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ge/single_op/task/op_task.cc b/ge/single_op/task/op_task.cc index 57222354..f41a59aa 100755 --- a/ge/single_op/task/op_task.cc +++ b/ge/single_op/task/op_task.cc @@ -989,7 +989,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_), + block_dim_, memcpy_args_.get(), memcpy_args_size_, nullptr, stream, RT_KERNEL_DEFAULT); GE_CHK_RT_RET(ret); GE_CHK_RT_RET(rtStreamSynchronize(stream));