From 4e2059a627d40d5b64d27633f54230e1c5b661e4 Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 13 Jul 2021 15:01:19 +0800 Subject: [PATCH 1/7] fix --- .../node_executor/aicpu/aicpu_node_executor.cc | 215 +++++++++++++++++---- .../node_executor/aicpu/aicpu_node_executor.h | 84 ++++---- 2 files changed, 228 insertions(+), 71 deletions(-) diff --git a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc index 820c9b56..c44595d9 100755 --- a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc +++ b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc @@ -441,8 +441,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), @@ -467,6 +467,31 @@ 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"); + uint32_t flag = RT_KERNEL_DEFAULT; + auto rt_ret = rtCpuKernelLaunchWithFlag(reinterpret_cast(memcpy_so_name_.c_str()), + reinterpret_cast(memcpy_kernel_name_.c_str()), + 1, // default core dim is 1 + memcpy_args_.get(), memcpy_args_size_, + nullptr, context.GetStream(), flag); + 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), @@ -486,8 +511,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; @@ -528,8 +553,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", @@ -560,7 +585,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; @@ -648,7 +673,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; @@ -665,14 +690,122 @@ 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(); + GE_IF_BOOL_EXEC(memcpy_args.size() != memcpy_args_size_, + REPORT_INNER_ERROR("E19999", "MemCopy task def args.size=%zu, but args_size=%u not equal.", + memcpy_args.size(), memcpy_args_size_); + GELOGE(FAILED, "[Check][Size]MemCopy task def args.size=%zu, but args_size=%u not equal.", + memcpy_args.size(), memcpy_args_size_); + return FAILED;); + GE_IF_BOOL_EXEC(memcpy_args_size_ < sizeof(aicpu::AicpuParamHead), + REPORT_INNER_ERROR("E19999", + "Task def args_size=%u is less than aicpu param head len=%zu.", + memcpy_args_size_, sizeof(aicpu::AicpuParamHead)); + GELOGE(FAILED, + "[Check][Size] Task def args_size=%u is less than aicpu param head len=%zu.", + memcpy_args_size_, sizeof(aicpu::AicpuParamHead)); + return FAILED;); + + memcpy_args_.reset(new(std::nothrow) uint8_t[memcpy_args_size_]()); + GE_IF_BOOL_EXEC(memcpy_args_ == nullptr, + REPORT_INNER_ERROR("E19999", "new memory failed for Node[MemCopy], task_size[%u].", + memcpy_args_size_); + GELOGE(FAILED, "[Malloc][Memory] failed for Node[MemCopy], task_size[%u].", + memcpy_args_size_); + return FAILED;); + + errno_t sec_ret = memcpy_s(memcpy_args_.get(), memcpy_args_size_, memcpy_args.c_str(), memcpy_args.size()); + GE_IF_BOOL_EXEC(sec_ret != EOK, + REPORT_INNER_ERROR("E19999", + "memcpy_s argc_ failed for Node[MemCopy], ret: %d", sec_ret); + GELOGE(INTERNAL_ERROR, + "[Update][args] failed for Node[MemCopy], ret: %d", sec_ret); + return sec_ret;); + auto memcpy_param_head = reinterpret_cast(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), + ©_ioaddr_dev_, sizeof(uint64_t) * memcpy_io_num); + GE_IF_BOOL_EXEC(cpy_ret != 0, + REPORT_INNER_ERROR("E19999", "Node[Memcpoy] memcpy io addr to AicpuParamHead failed," + "ret=%d, args_size=%u, io nums=%u.", + cpy_ret, memcpy_args_size_, memcpy_io_num); + GELOGE(INTERNAL_ERROR, "[Update][io_addr]Node[MemCopy] memcpy io addr to AicpuParamHead failed," + "ret=%d, args_size=%u, io nums=%u.", + cpy_ret, memcpy_args_size_, memcpy_io_num); + return INTERNAL_ERROR;); + GELOGD("Set memcpy task for node[MemCopy] successfully."); + return SUCCESS; +} + +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); + + std::vector copy_io_addr; + 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())); + + // mem copy op has 4 inputs and 0 output. + const auto copy_io_addr_size = sizeof(uint64_t) * copy_io_addr.size(); + + // can alloc in init, it can reuse + GE_CHK_STATUS_RET(AllocTensorBuffer(copy_io_addr_size, copy_ioaddr_dev_), + "[Alloc][TensorBuffer] failed for Node[%s] to copy task ioaddr, size=%zu", + node_name_.c_str(), copy_io_addr_size); + + GE_CHK_RT_RET(rtMemcpy(copy_ioaddr_dev_->GetData(), copy_io_addr_size, + ©_io_addr[0], copy_io_addr_size, RT_MEMCPY_HOST_TO_DEVICE)); + 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(); @@ -761,7 +894,10 @@ Status AicpuNodeTask::Init(const HybridModel &model) { uint64_t ext_session_id = model.GetSessionId(); 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; @@ -769,7 +905,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; } @@ -785,13 +925,29 @@ Status AicpuNodeTask::UpdateIoAddr(TaskContext &context) { io_addrs.emplace_back(reinterpret_cast(inputData->GetData())); } - 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())); + // 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()); + + 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); @@ -829,23 +985,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 14bc8fcc..f9001f83 100644 --- a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.h +++ b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.h @@ -55,12 +55,34 @@ 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); + protected: const NodeItem *node_item_; // just reference. @@ -78,6 +100,15 @@ 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_; + bool need_sync_ = false; }; class AicpuTfNodeTask : public AicpuNodeTaskBase { @@ -93,33 +124,15 @@ 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(); - - 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); + const std::vector> &out_shape_hbm) override; - Status UpdateShapeByHbmBuffer(TaskContext &context, - const std::vector> &out_shape_hbm); + Status InitForDependComputeTask() override; - Status PrepareCopyInputs(const TaskContext &context, - const std::vector> &out_shape_hbm); + private: + Status SetMemCopyTask(const domi::TaskDef &task_def); static Status EnsureSessionCreated(uint64_t session_id); static uint64_t GetStepIdAddr(const HybridModel &model); @@ -135,17 +148,8 @@ 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_; }; @@ -162,16 +166,30 @@ 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; // args size uint32_t args_size_ = 0; + + std::vector copy_io_addr_; }; class AiCpuNodeExecutor : public NodeExecutor { From 1bbd6aba112cc85fb193a4037a2d856dcf4ca054 Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 13 Jul 2021 15:19:48 +0800 Subject: [PATCH 2/7] fix --- .../node_executor/aicpu/aicpu_node_executor.cc | 22 +++++----------------- 1 file changed, 5 insertions(+), 17 deletions(-) diff --git a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc index c44595d9..d9d4b35e 100755 --- a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc +++ b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc @@ -783,22 +783,10 @@ Status AicpuNodeTask::InitForDependComputeTask() { "[Alloc][TensorBuffer] failed for Node[%s] to copy task input dst, size=%zu", node_name_.c_str(), copy_input_buf_len); - std::vector copy_io_addr; - 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())); - - // mem copy op has 4 inputs and 0 output. - const auto copy_io_addr_size = sizeof(uint64_t) * copy_io_addr.size(); - - // can alloc in init, it can reuse - GE_CHK_STATUS_RET(AllocTensorBuffer(copy_io_addr_size, copy_ioaddr_dev_), - "[Alloc][TensorBuffer] failed for Node[%s] to copy task ioaddr, size=%zu", - node_name_.c_str(), copy_io_addr_size); - - GE_CHK_RT_RET(rtMemcpy(copy_ioaddr_dev_->GetData(), copy_io_addr_size, - ©_io_addr[0], copy_io_addr_size, RT_MEMCPY_HOST_TO_DEVICE)); + 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; } @@ -973,7 +961,7 @@ Status AicpuNodeTask::LaunchTask(TaskContext &context) { auto kernel_type = static_cast(kcontext.kernel_type()); uint32_t flag = RT_KERNEL_DEFAULT; if (kernel_type == ccKernelType::CUST_AI_CPU) { - flag |= static_cast(RT_KERNEL_CUSTOM_AICPU); + flag |= static_cast(RT_KERNEL_C USTOM_AICPU); } auto rt_ret = rtCpuKernelLaunchWithFlag(reinterpret_cast(so_name.c_str()), reinterpret_cast(kernel_name.c_str()), From e88728450caa58e760566d3dae959fa410d27625 Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 13 Jul 2021 18:40:53 +0800 Subject: [PATCH 3/7] 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 | 133 ++++++++++++++++++++++--- ge/single_op/task/op_task.h | 54 ++++++---- 5 files changed, 167 insertions(+), 42 deletions(-) diff --git a/ge/single_op/single_op_model.cc b/ge/single_op/single_op_model.cc index ca07d2ae..08778c09 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..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, 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 c6c99ab0..511492b8 100755 --- a/ge/single_op/task/op_task.cc +++ b/ge/single_op/task/op_task.cc @@ -564,6 +564,17 @@ AiCpuBaseTask::~AiCpuBaseTask() { if (ext_info_addr_dev_ != nullptr) { (void)rtFree(ext_info_addr_dev_); } + + 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::SetExtInfoAndType(const std::string &kernel_ext_info, uint64_t kernel_id) { @@ -768,17 +779,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) { @@ -808,7 +809,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; @@ -849,7 +850,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]; @@ -876,7 +877,20 @@ Status AiCpuTask::CopyDataToHbm(vector &outputs, return SUCCESS; } -Status AiCpuTask::UpdateShapeByHbmBuffer(vector &output_desc) { +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, dump_flag_); + GE_CHK_RT_RET(ret); + GE_CHK_RT_RET(rtStreamSynchronize(stream)); + return SUCCESS; +} + +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; @@ -905,7 +919,7 @@ Status AiCpuTask::UpdateShapeByHbmBuffer(vector &output_desc) { } -Status AiCpuTask::UpdateShapeAndDataByResultSummary(vector &output_desc, +Status AiCpuBaseTask::UpdateShapeAndDataByResultSummary(vector &output_desc, vector &outputs, rtStream_t stream) { if (num_outputs_ == 0) { @@ -1095,8 +1109,99 @@ Status AiCpuCCTask::LaunchKernel(const std::vector &input_desc, 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::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)); + + std::vector copy_io_addr; + 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_)); + + const auto copy_io_addr_size = sizeof(uint64_t) * copy_io_addr.size(); + + GE_CHK_RT_RET(rtMalloc(©_ioaddr_dev_, copy_io_addr_size, RT_MEMORY_HBM)); + + GE_CHK_RT_RET(rtMemcpy(copy_ioaddr_dev_, copy_io_addr_size, + copy_io_addr.data(), copy_io_addr_size, RT_MEMCPY_HOST_TO_DEVICE)); + 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(); + GE_IF_BOOL_EXEC(memcpy_args.size() != memcpy_args_size_, + REPORT_INNER_ERROR("E19999", "MemCopy task def args.size=%zu, but args_size=%u not equal.", + memcpy_args.size(), memcpy_args_size_); + GELOGE(FAILED, "[Check][Size]MemCopy task def args.size=%zu, but args_size=%u not equal.", + memcpy_args.size(), memcpy_args_size_); + return FAILED;); + GE_IF_BOOL_EXEC(memcpy_args_size_ < sizeof(aicpu::AicpuParamHead), + REPORT_INNER_ERROR("E19999", + "Task def args_size=%u is less than aicpu param head len=%zu.", + memcpy_args_size_, sizeof(aicpu::AicpuParamHead)); + GELOGE(FAILED, + "[Check][Size] Task def args_size=%u is less than aicpu param head len=%zu.", + memcpy_args_size_, sizeof(aicpu::AicpuParamHead)); + return FAILED;); + + memcpy_args_.reset(new(std::nothrow) uint8_t[memcpy_args_size_]()); + GE_IF_BOOL_EXEC(memcpy_args_ == nullptr, + REPORT_INNER_ERROR("E19999", "new memory failed for Node[MemCopy], task_size[%u].", + memcpy_args_size_); + GELOGE(FAILED, "[Malloc][Memory] failed for Node[MemCopy], task_size[%u].", + memcpy_args_size_); + return FAILED;); + + errno_t sec_ret = memcpy_s(memcpy_args_.get(), memcpy_args_size_, memcpy_args.c_str(), memcpy_args.size()); + GE_IF_BOOL_EXEC(sec_ret != EOK, + REPORT_INNER_ERROR("E19999", + "memcpy_s argc_ failed for Node[MemCopy], ret: %d", sec_ret); + GELOGE(INTERNAL_ERROR, + "[Update][args] failed for Node[MemCopy], ret: %d", sec_ret); + return sec_ret;); + auto memcpy_param_head = reinterpret_cast(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), + ©_ioaddr_dev_, sizeof(uint64_t) * memcpy_io_num); + GE_IF_BOOL_EXEC(cpy_ret != 0, + REPORT_INNER_ERROR("E19999", "Node[Memcpoy] memcpy io addr to AicpuParamHead failed," + "ret=%d, args_size=%u, io nums=%u.", + cpy_ret, memcpy_args_size_, memcpy_io_num); + GELOGE(INTERNAL_ERROR, "[Update][io_addr]Node[MemCopy] memcpy io addr to AicpuParamHead failed," + "ret=%d, args_size=%u, io nums=%u.", + cpy_ret, memcpy_args_size_, memcpy_io_num); + return INTERNAL_ERROR;); + GELOGD("Set memcpy task for node[MemCopy] successfully."); return SUCCESS; } diff --git a/ge/single_op/task/op_task.h b/ge/single_op/task/op_task.h index 132672b0..7b27fc60 100644 --- a/ge/single_op/task/op_task.h +++ b/ge/single_op/task/op_task.h @@ -178,7 +178,17 @@ 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; protected: size_t num_inputs_ = 0; size_t num_outputs_ = 0; @@ -186,6 +196,18 @@ class AiCpuBaseTask : public OpTask { std::unique_ptr aicpu_ext_handle_; void *ext_info_addr_dev_ = nullptr; vector input_is_const_; + + 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_; }; class AiCpuTask : public AiCpuBaseTask { @@ -206,16 +228,9 @@ class AiCpuTask : public AiCpuBaseTask { 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; + private: friend class AiCpuTaskBuilder; void *workspace_addr_ = nullptr; std::string task_info_; @@ -234,17 +249,7 @@ 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; }; @@ -263,13 +268,16 @@ class AiCpuCCTask : public AiCpuBaseTask { void SetkernelName(const std::string &kernel_Name); void SetIoAddr(uintptr_t *io_addr); size_t GetArgSize() const; - + Status SetMemCopyTask(const domi::KernelDef &kernel_def); 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: + Status InitForSummaryAndCopy(); + Status CopyDataToHbm(vector &outputs, rtStream_t stream) override; private: friend class AiCpuCCTaskBuilder; std::string so_name_; @@ -283,6 +291,12 @@ 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_; + // args size + uint32_t memcpy_args_size_ = 0; }; class MemcpyAsyncTask : public OpTask { From 98db35042199f10deeacc8b13e3f95cafb9449ad Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 13 Jul 2021 18:47:35 +0800 Subject: [PATCH 4/7] fix --- ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc | 2 +- ge/single_op/task/op_task.cc | 18 +++++------------- ge/single_op/task/op_task.h | 3 +-- 3 files changed, 7 insertions(+), 16 deletions(-) diff --git a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc index d9d4b35e..a2e1ef98 100755 --- a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc +++ b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc @@ -738,7 +738,7 @@ Status AicpuNodeTask::SetMemCopyTask(const domi::TaskDef &task_def) { 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), - ©_ioaddr_dev_, sizeof(uint64_t) * memcpy_io_num); + ©_io_addr_[0], sizeof(uint64_t) * memcpy_io_num); GE_IF_BOOL_EXEC(cpy_ret != 0, REPORT_INNER_ERROR("E19999", "Node[Memcpoy] memcpy io addr to AicpuParamHead failed," "ret=%d, args_size=%u, io nums=%u.", diff --git a/ge/single_op/task/op_task.cc b/ge/single_op/task/op_task.cc index 511492b8..f940cb36 100755 --- a/ge/single_op/task/op_task.cc +++ b/ge/single_op/task/op_task.cc @@ -1137,18 +1137,10 @@ Status AiCpuCCTask::InitForSummaryAndCopy() { 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)); - std::vector copy_io_addr; - 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_)); - - const auto copy_io_addr_size = sizeof(uint64_t) * copy_io_addr.size(); - - GE_CHK_RT_RET(rtMalloc(©_ioaddr_dev_, copy_io_addr_size, RT_MEMORY_HBM)); - - GE_CHK_RT_RET(rtMemcpy(copy_ioaddr_dev_, copy_io_addr_size, - copy_io_addr.data(), copy_io_addr_size, RT_MEMCPY_HOST_TO_DEVICE)); + 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; } @@ -1192,7 +1184,7 @@ Status AiCpuCCTask::SetMemCopyTask(const domi::KernelDef &kernel_def) { 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), - ©_ioaddr_dev_, sizeof(uint64_t) * memcpy_io_num); + ©_io_addr[0], sizeof(uint64_t) * memcpy_io_num); GE_IF_BOOL_EXEC(cpy_ret != 0, REPORT_INNER_ERROR("E19999", "Node[Memcpoy] memcpy io addr to AicpuParamHead failed," "ret=%d, args_size=%u, io nums=%u.", diff --git a/ge/single_op/task/op_task.h b/ge/single_op/task/op_task.h index 7b27fc60..d2e5bf70 100644 --- a/ge/single_op/task/op_task.h +++ b/ge/single_op/task/op_task.h @@ -200,8 +200,6 @@ class AiCpuBaseTask : public OpTask { 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; @@ -295,6 +293,7 @@ private: 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; }; From f3c04de30bfa2a8e816cf4ace48eb55c940164ea Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 13 Jul 2021 18:56:56 +0800 Subject: [PATCH 5/7] fix --- ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc index a2e1ef98..42c26802 100755 --- a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc +++ b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc @@ -961,7 +961,7 @@ Status AicpuNodeTask::LaunchTask(TaskContext &context) { auto kernel_type = static_cast(kcontext.kernel_type()); uint32_t flag = RT_KERNEL_DEFAULT; if (kernel_type == ccKernelType::CUST_AI_CPU) { - flag |= static_cast(RT_KERNEL_C USTOM_AICPU); + flag |= static_cast(RT_KERNEL_CUSTOM_AICPU); } auto rt_ret = rtCpuKernelLaunchWithFlag(reinterpret_cast(so_name.c_str()), reinterpret_cast(kernel_name.c_str()), From fee9d42990be6ff930629f3ec8a25aeba395b83d Mon Sep 17 00:00:00 2001 From: guopeian Date: Tue, 13 Jul 2021 19:19:26 +0800 Subject: [PATCH 6/7] fix --- 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 f940cb36..64ede2ed 100755 --- a/ge/single_op/task/op_task.cc +++ b/ge/single_op/task/op_task.cc @@ -1184,7 +1184,7 @@ Status AiCpuCCTask::SetMemCopyTask(const domi::KernelDef &kernel_def) { 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); + ©_io_addr_[0], sizeof(uint64_t) * memcpy_io_num); GE_IF_BOOL_EXEC(cpy_ret != 0, REPORT_INNER_ERROR("E19999", "Node[Memcpoy] memcpy io addr to AicpuParamHead failed," "ret=%d, args_size=%u, io nums=%u.", From 79366ad1e8cff40b5fc7ce8a1e662caf74dc57b6 Mon Sep 17 00:00:00 2001 From: guopeian Date: Sat, 17 Jul 2021 15:39:09 +0800 Subject: [PATCH 7/7] fitx --- tests/ut/ge/CMakeLists.txt | 1 + .../aicpu/aicpu_node_executor_unittest.cc | 103 +++++++++++++++++++++ 2 files changed, 104 insertions(+) create mode 100644 tests/ut/ge/hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc diff --git a/tests/ut/ge/CMakeLists.txt b/tests/ut/ge/CMakeLists.txt index 42fa6128..b4787304 100755 --- a/tests/ut/ge/CMakeLists.txt +++ b/tests/ut/ge/CMakeLists.txt @@ -733,6 +733,7 @@ set(HYBRID_TEST_FILES "hybrid/node_executor/node_executor_unittest.cc" "hybrid/node_executor/rts/rts_node_task_unittest.cc" "hybrid/node_executor/host_cpu/host_cpu_node_task_unittest.cc" + "hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc" "hybrid/node_executor/ge_local/ge_local_node_executor_unittest.cc" "hybrid/node_executor/hccl/hccl_node_executor_unittest.cc" "hybrid/executor/hybrid_model_async_executor_unittest.cc" 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 new file mode 100644 index 00000000..a71df6b1 --- /dev/null +++ b/tests/ut/ge/hybrid/node_executor/aicpu/aicpu_node_executor_unittest.cc @@ -0,0 +1,103 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +#define private public +#define protected public +#include "hybrid/executor/subgraph_context.h" +#include "hybrid/node_executor/aicpu/aicpu_node_executor.h" +#include "model/ge_root_model.h" +#include "graph/passes/graph_builder_utils.h" +#include "aicpu/common/aicpu_task_struct.h" +#include "graph/manager/graph_mem_manager.h" +#undef private +#undef protected + +using namespace std; +using namespace testing; + +namespace ge { +using namespace hybrid; + +namespace { +struct AicpuTaskStruct { + aicpu::AicpuParamHead head; + uint64_t io_addrp[2]; +}__attribute__((packed)); +} // namespace + +class UtestAiCpuNodeTask : public testing::Test { + protected: + void SetUp() {} + void TearDown() {} +}; + +TEST_F(UtestAiCpuNodeTask, test_load) { + ut::GraphBuilder builder = ut::GraphBuilder("graph"); + auto node = builder.AddNode("Data", "Data", 1, 1); + auto graph = builder.GetGraph(); + + GeRootModelPtr ge_root_model = std::make_shared(graph); + HybridModel hybrid_model(ge_root_model); + std::unique_ptr node_item; + ASSERT_EQ(NodeItem::Create(node, node_item), SUCCESS); + node_item->shape_inference_type = 4; + hybrid_model.node_items_[node] = std::move(node_item); + domi::TaskDef node_task; + node_task.set_type(RT_MODEL_TASK_KERNEL); + domi::KernelDef *node_kernel_def = node_task.mutable_kernel(); + node_kernel_def->set_so_name("libcpu_kernels.so"); + node_kernel_def->set_kernel_name("RunCpuKernel"); + node_kernel_def->set_kernel_ext_info_size(0); + uint32_t nod_param_len = static_cast(sizeof(AicpuParamHead)) + 2 * static_cast(sizeof(uint64_t)); + std::string node_task_args; + AicpuParamHead node_param_head = {node_param_len, 2, 0, 0}; + node_task_args.append(reinterpret_cast(&node_param_head), sizeof(AicpuParamHead)); + node_task_args.append(2 * static_cast(sizeof(uint64_t), ' '); + node_kernel_def->set_args(node_task_args.data(), node_param_len); + node_kernel_def->set_args_size(param_len); + domi::KernelContext *node_context = node_kernel_def->mutable_context(); + node_context->set_op_index(0); + node_context->set_kernel_type(cce::ccKernelType::AI_CPU); + + domi::TaskDef copy_task; + copy_task.set_type(RT_MODEL_TASK_KERNEL); + domi::KernelDef *copy_kernel_def = copy_task.mutable_kernel(); + copy_kernel_def->set_so_name("libcpu_kernels.so"); + copy_task_def->set_kernel_name("RunCpuKernel"); + copy_task_def->set_kernel_ext_info_size(0); + uint32_t copy_param_len = static_cast(sizeof(AicpuParamHead)) + static_cast(sizeof(uint64_t)); + std::string copy_task_args; + AicpuParamHead copy_param_head = {copy_param_len, 1, 0, 0}; + copy_task_args.append(reinterpret_cast(©_param_head), sizeof(AicpuParamHead)); + copy_task_args.append(static_cast(sizeof(uint64_t), ' '); + copy_task_def->set_args(copy_task_args.data(), node_param_len); + copy_task_def->set_args_size(param_len); + domi::KernelContext *copy_context = copy_task_def->mutable_context(); + copy_context->set_op_index(0); + copy_context->set_kernel_type(cce::ccKernelType::AI_CPU); + + hybrid_model.task_defs_[node] = {node_task, copy_task}; + hybrid_model.node_items_[node]->num_inputs = 1; + hybrid_model.node_items_[node]->num_outputs = 1; + NodeTaskPtr task = nullptr; + AiCpuNodeExecutor node_executor; + ASSERT_EQ(node_executor.LoadTask(hybrid_model, node, task), SUCCESS); +} +} // namespace ge