hummingbird
/
graphengine
Not watched
2
0
Fork 0
Code
Releases 13 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 3dfd2119c1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3dfd2119c1'
${ noResults }
graphengine/tests/ut/ge/single_op/single_op_task_unittest.cc

367 lines
14 kB
Raw Blame History 

  1. /**

  2.  * Copyright 2019-2020 Huawei Technologies Co., Ltd

  3.  *

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7.  *

  8.  * http://www.apache.org/licenses/LICENSE-2.0

  9.  *

  10.  * Unless required by applicable law or agreed to in writing, software

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */

  16. 

  17. #include <gtest/gtest.h>

  18. #include <vector>

  19. 

  20. #include "graph/load/model_manager/model_utils.h"

  21. #include "graph/utils/graph_utils.h"

  22. #include "hybrid/node_executor/aicpu/aicpu_ext_info.h"

  23. #include "runtime/rt.h"

  24. 

  25. #define protected public

  26. #define private public

  27. #include "single_op/single_op_model.h"

  28. #include "single_op/task/tbe_task_builder.h"

  29. #include "single_op/task/op_task.h"

  30. #include "single_op/task/tbe_task_builder.h"

  31. #include "external/register/op_tiling_registry.h"

  32. #undef private

  33. #undef protected

  34. #include "tests/depends/runtime/src/runtime_stub.h"

  35. 

  36. using namespace std;

  37. using namespace testing;

  38. using namespace ge;

  39. using namespace optiling;

  40. 

  41. class UtestSingleOpTask : public testing::Test {

  42.  protected:

  43.   void SetUp() {

  44.     RTS_STUB_SETUP();

  45.   }

  46. 

  47.   void TearDown() {

  48.     RTS_STUB_TEARDOWN();

  49.   }

  50. };

  51. 

  52. TEST_F(UtestSingleOpTask, test_build_kernel_task) {

  53.   string model_data_str = "123456789";

  54.   SingleOpModel model("model", model_data_str.c_str(), model_data_str.size());

  55.   model.input_offset_list_.push_back(0);

  56.   model.input_sizes_.push_back(16);

  57. 

  58.   model.output_offset_list_.push_back(0);

  59.   model.output_sizes_.push_back(16);

  60. 

  61.   auto graph = make_shared<ComputeGraph>("graph");

  62.   auto op_desc = make_shared<OpDesc>("Add", "Add");

  63.   AttrUtils::SetStr(op_desc, TVM_ATTR_NAME_MAGIC, "RT_DEV_BINARY_MAGIC_ELF");

  64.   std::vector<char> kernelBin;

  65.   TBEKernelPtr tbe_kernel = std::make_shared<ge::OpKernelBin>("name/Add", std::move(kernelBin));

  66.   op_desc->SetExtAttr(ge::OP_EXTATTR_NAME_TBE_KERNEL, tbe_kernel);

  67.   std::string kernel_name("kernel/Add");

  68.   AttrUtils::SetStr(op_desc, op_desc->GetName() + "_kernelname", kernel_name);

  69. 

  70.   vector<int64_t> shape{16, 16};

  71.   GeShape ge_shape(shape);

  72.   GeTensorDesc desc(ge_shape);

  73.   op_desc->AddInputDesc(desc);

  74.   op_desc->AddOutputDesc(desc);

  75.   auto node = graph->AddNode(op_desc);

  76. 

  77.   std::mutex stream_mu_;

  78.   rtStream_t stream_ = nullptr;

  79.   StreamResource stream_resource(0);

  80.   SingleOp single_op(&stream_resource, &stream_mu_, stream_);

  81. 

  82.   domi::TaskDef task_def;

  83.   task_def.set_type(RT_MODEL_TASK_ALL_KERNEL);

  84.   domi::KernelDefWithHandle *kernel_with_handle = task_def.mutable_kernel_with_handle();

  85.   kernel_with_handle->set_original_kernel_key("");

  86.   kernel_with_handle->set_node_info("");

  87.   kernel_with_handle->set_block_dim(32);

  88.   kernel_with_handle->set_args_size(64);

  89.   string args(64, '1');

  90.   kernel_with_handle->set_args(args.data(), 64);

  91.   domi::KernelContext *context = kernel_with_handle->mutable_context();

  92.   context->set_op_index(1);

  93.   context->set_kernel_type(2);    // ccKernelType::TE

  94.   uint16_t args_offset[9] = {0};

  95.   context->set_args_offset(args_offset, 9 * sizeof(uint16_t));

  96.   model.op_list_[1] = node;

  97. 

  98.   TbeOpTask task_tmp;

  99.   TbeOpTask *task = &task_tmp;

  100.   ASSERT_EQ(model.BuildKernelTask(task_def, &task), SUCCESS);

  101.   ge::DataBuffer data_buffer;

  102.   vector<GeTensorDesc> input_desc;

  103.   vector<DataBuffer> input_buffers = { data_buffer };

  104.   vector<GeTensorDesc> output_desc;

  105.   vector<DataBuffer> output_buffers = { data_buffer };

  106.   task->node_ = node;

  107.   OpTilingFunc op_tiling_func = [](const TeOpParas &, const OpCompileInfo &, OpRunInfo &) -> bool {return true;};

  108.   OpTilingRegistryInterf("Add", op_tiling_func);

  109.   ge::AttrUtils::SetStr(op_desc, "compile_info_key", "op_compile_info_key");

  110.   ge::AttrUtils::SetStr(op_desc, "compile_info_json", "op_compile_info_json");

  111.   char c = '0';

  112.   char* buffer = &c;

  113.   task->tiling_buffer_ = buffer;

  114.   task->max_tiling_size_ = 64;

  115.   task->tiling_data_ = "tiling_data";

  116.   task->arg_size_ = 64;

  117.   task->args_.reset(new (std::nothrow) uint8_t[sizeof(void *) * 3]);

  118. 

  119.   ASSERT_EQ(task->LaunchKernel(input_desc, input_buffers, output_desc, output_buffers, stream_), SUCCESS);

  120.   char *handle = "00";

  121.   task->SetHandle(handle);

  122.   ASSERT_EQ(task->LaunchKernel(input_desc, input_buffers, output_desc, output_buffers, stream_), SUCCESS);

  123. }

  124. 

  125. TEST_F(UtestSingleOpTask, test_update_ioaddr) {

  126.   auto graph = make_shared<ComputeGraph>("graph");

  127.   auto op_desc = make_shared<OpDesc>("Add", "Add");

  128. 

  129.   GeTensorDesc desc;

  130.   op_desc->AddInputDesc(desc);

  131.   op_desc->AddInputDesc(desc);

  132.   op_desc->AddOutputDesc(desc);

  133.   vector<bool> is_input_const = { true, false };

  134.   op_desc->SetIsInputConst(is_input_const);

  135.   auto node = graph->AddNode(op_desc);

  136. 

  137.   TbeOpTask task;

  138.   task.op_desc_ = op_desc;

  139.   task.node_ = node;

  140.   ASSERT_EQ(task.SetArgIndex(), SUCCESS);

  141.   task.arg_size_ = sizeof(void *) * 4;

  142.   task.args_.reset(new (std::nothrow) uint8_t[task.arg_size_]);

  143.   task.arg_index_ = {0};

  144.   task.input_num_ = 2;

  145.   task.output_num_ = 1;

  146. 

  147.   vector<void *> args;

  148.   vector<DataBuffer> inputs;

  149.   vector<DataBuffer> outputs;

  150.   ASSERT_EQ(task.UpdateIoAddr(inputs, outputs), ACL_ERROR_GE_PARAM_INVALID);

  151. 

  152.   ge::DataBuffer data_buffer;

  153.   inputs = { data_buffer };

  154.   outputs = { data_buffer };

  155.   ASSERT_EQ(task.UpdateIoAddr(inputs, outputs), SUCCESS);

  156. 

  157.   task.tiling_buffer_ = (void *)0x0001;

  158.   task.workspaces_ = { (void *)0x0002 };

  159.   ASSERT_EQ(task.UpdateTilingArgs(nullptr), SUCCESS);

  160.   task.tiling_buffer_ = nullptr;

  161. }

  162. 

  163. TEST_F(UtestSingleOpTask, test_atomic_exec) {

  164.   auto graph = make_shared<ComputeGraph>("graph");

  165.   auto op_desc = make_shared<OpDesc>("Add", "Add");

  166.   GeTensorDesc desc;

  167.   op_desc->AddInputDesc(desc);

  168.   op_desc->AddOutputDesc(desc);

  169.   auto node = graph->AddNode(op_desc);

  170.   AtomicAddrCleanOpTask task;

  171.   task.op_desc_ = op_desc;

  172.   task.node_ = node;

  173. 

  174.   vector<DataBuffer> inputs;

  175.   vector<DataBuffer> outputs;

  176.   std::vector<int64_t> atomic_output_indices;

  177.   ge::AttrUtils::SetListInt(op_desc, ATOMIC_ATTR_OUTPUT_INDEX, atomic_output_indices);

  178.   ASSERT_EQ(task.InitAtomicAddrCleanIndices(), INTERNAL_ERROR);

  179.   atomic_output_indices = { 0 };

  180.   ge::AttrUtils::SetListInt(op_desc, ATOMIC_ATTR_OUTPUT_INDEX, atomic_output_indices);

  181.   ASSERT_EQ(task.InitAtomicAddrCleanIndices(), INTERNAL_ERROR);

  182.   task.arg_size_ = sizeof(void *) * 2;

  183.   task.args_.reset(new (std::nothrow) uint8_t[task.arg_size_]);

  184.   ASSERT_EQ(task.InitAtomicAddrCleanIndices(), SUCCESS);

  185.   ASSERT_EQ(task.UpdateIoAddr(inputs, outputs), ACL_ERROR_GE_PARAM_INVALID);

  186. 

  187.   ge::DataBuffer data_buffer;

  188.   outputs = { data_buffer };

  189.   ASSERT_EQ(task.UpdateIoAddr(inputs, outputs), SUCCESS);

  190. 

  191.   task.tiling_buffer_ = (void *)0x0001;

  192.   ASSERT_EQ(task.UpdateTilingArgs(nullptr), SUCCESS);

  193.   task.tiling_buffer_ = nullptr;

  194. 

  195.   optiling::utils::OpRunInfo run_info(0, true, 0);

  196.   task.CalcTilingInfo(run_info);

  197. }

  198. 

  199. TEST_F(UtestSingleOpTask, test_aicpu_task_update_io_addr) {

  200.   AiCpuCCTask task;

  201.   task.num_inputs_ = 2;

  202.   task.num_outputs_ = 1;

  203.   task.input_is_const_ = {true, false};

  204.   int total_addr = 3;

  205.   uint32_t* addrs[total_addr] = {nullptr, nullptr, nullptr};

  206.   task.io_addr_ = reinterpret_cast<uintptr_t*>(addrs);

  207.   task.io_addr_num_ = total_addr;

  208. 

  209.   {

  210.     vector<DataBuffer> inputs(1, DataBuffer());

  211.     vector<DataBuffer> outputs(1, DataBuffer());

  212.     auto ret = task.UpdateIoAddr(inputs, outputs);

  213.     ASSERT_EQ(ret, SUCCESS);

  214.     ASSERT_EQ(addrs[0], nullptr);

  215.     ASSERT_EQ(addrs[1], nullptr);

  216.     ASSERT_EQ(addrs[2], nullptr);

  217.   }

  218. 

  219.   {

  220.     uint32_t data_buf[2];

  221.     vector<DataBuffer> inputs{DataBuffer(&data_buf[0], 4, false)};

  222.     vector<DataBuffer> outputs{DataBuffer(&data_buf[1], 4, false)};

  223.     auto ret = task.UpdateIoAddr(inputs, outputs);

  224.     ASSERT_EQ(ret, SUCCESS);

  225.     ASSERT_EQ(addrs[0], nullptr);

  226.     ASSERT_EQ(addrs[1], &data_buf[0]);

  227.     ASSERT_EQ(addrs[2], &data_buf[1]);

  228.   }

  229. 

  230.   {

  231.     uint32_t data_buf[2];

  232.     vector<DataBuffer> inputs{DataBuffer(nullptr, 4, false)};

  233.     vector<DataBuffer> outputs{DataBuffer(&data_buf[1], 4, false)};

  234.     auto ret = task.UpdateIoAddr(inputs, outputs);

  235.     ASSERT_EQ(ret, PARAM_INVALID);

  236.   }

  237. 

  238.   {

  239.     uint32_t data_buf[2];

  240.     vector<DataBuffer> inputs{DataBuffer(&data_buf[0], 4, false)};

  241.     vector<DataBuffer> outputs{DataBuffer(nullptr, 4, false)};

  242.     auto ret = task.UpdateIoAddr(inputs, outputs);

  243.     ASSERT_EQ(ret, PARAM_INVALID);

  244.   }

  245. }

  246. 

  247. TEST_F(UtestSingleOpTask, test_blocking_aicpu_op_01) {

  248.   int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo);

  249.   vector<char> aicpu_ext_info(len, 0);

  250.   char *buf = aicpu_ext_info.data();

  251.   int offset = 0;

  252.   hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset);

  253.   ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT;

  254.   ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo);

  255.   offset += sizeof(hybrid::AicpuExtInfo);

  256.   hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset);

  257.   async_wait_info->waitType = 0;

  258.   async_wait_info->waitId = 0;

  259.   async_wait_info->timeOut = 0;

  260.   async_wait_info->reserved = 0;

  261. 

  262.   domi::KernelDef kernel_def;

  263.   kernel_def.set_kernel_ext_info(buf, len);

  264.   kernel_def.set_kernel_ext_info_size(len);

  265. 

  266.   auto op_desc = make_shared<OpDesc>("deque", "Deque");

  267.   ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, true);

  268.   AiCpuCCTask aicpu_task;

  269.   aicpu_task.SetOpDesc(op_desc);

  270.   rtStream_t stream;

  271.   ASSERT_EQ(rtStreamCreate(&stream, 0), RT_ERROR_NONE);

  272. 

  273.   ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), SUCCESS);

  274.   ASSERT_EQ(aicpu_task.LaunchKernel(stream), SUCCESS);

  275. }

  276. 

  277. TEST_F(UtestSingleOpTask, test_blocking_aicpu_op_02) {

  278.   int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo);

  279.   vector<char> aicpu_ext_info(len, 0);

  280.   char *buf = aicpu_ext_info.data();

  281.   int offset = 0;

  282.   hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset);

  283.   ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT;

  284.   ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo);

  285.   offset += sizeof(hybrid::AicpuExtInfo);

  286.   hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset);

  287.   async_wait_info->waitType = 0;

  288.   async_wait_info->waitId = 0;

  289.   async_wait_info->timeOut = 0;

  290.   async_wait_info->reserved = 0;

  291. 

  292.   domi::KernelDef kernel_def;

  293.   kernel_def.set_kernel_ext_info(buf, len);

  294.   kernel_def.set_kernel_ext_info_size(len);

  295. 

  296.   auto op_desc = make_shared<OpDesc>("deque", "Deque");

  297.   ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, true);

  298.   AiCpuTask aicpu_task;

  299.   aicpu_task.SetOpDesc(op_desc);

  300.   rtStream_t stream;

  301.   ASSERT_EQ(rtStreamCreate(&stream, 0), RT_ERROR_NONE);

  302. 

  303.   ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), SUCCESS);

  304.   ASSERT_EQ(aicpu_task.LaunchKernel(stream), SUCCESS);

  305. }

  306. 

  307. TEST_F(UtestSingleOpTask, test_blocking_aicpu_op_fail) {

  308.   int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo);

  309.   vector<char> aicpu_ext_info(len, 0);

  310.   char *buf = aicpu_ext_info.data();

  311.   int offset = 0;

  312.   hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset);

  313.   ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT;

  314.   ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo);

  315.   offset += sizeof(hybrid::AicpuExtInfo);

  316.   hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset);

  317.   async_wait_info->waitType = 0;

  318.   async_wait_info->waitId = 0;

  319.   async_wait_info->timeOut = 0;

  320.   async_wait_info->reserved = 0;

  321. 

  322.   domi::KernelDef kernel_def;

  323.   kernel_def.set_kernel_ext_info(buf, len);

  324.   kernel_def.set_kernel_ext_info_size(len);

  325. 

  326.   auto op_desc = make_shared<OpDesc>("deque", "Deque");

  327.   ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, true);

  328.   AiCpuTask aicpu_task;

  329.   aicpu_task.SetOpDesc(op_desc);

  330.   rtStream_t stream;

  331.   ASSERT_EQ(rtStreamCreate(&stream, 0), RT_ERROR_NONE);

  332. 

  333.   ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), SUCCESS);

  334.   ASSERT_EQ(aicpu_task.LaunchKernel(stream), SUCCESS);

  335. 

  336.   RTS_STUB_RETURN_VALUE(rtGetDevice, rtError_t, 0x78000001);

  337.   ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), FAILED);

  338. 

  339.   RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, 0x78000001);

  340.   ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), FAILED);

  341. 

  342.   RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, 0x78000001);

  343.   ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), FAILED);

  344. 

  345.   RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE);

  346.   RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_SUPPORT + 1);

  347.   ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), FAILED);

  348. 

  349.   RTS_STUB_RETURN_VALUE(rtGetDevice, rtError_t, 0x78000001);

  350.   ASSERT_EQ(aicpu_task.LaunchKernel(stream), FAILED);

  351. 

  352.   ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), SUCCESS);

  353.   RTS_STUB_RETURN_VALUE(rtStreamWaitEvent, rtError_t, 0x78000001);

  354.   ASSERT_EQ(aicpu_task.LaunchKernel(stream), FAILED);

  355. 

  356.   ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), SUCCESS);

  357.   RTS_STUB_RETURN_VALUE(rtEventReset, rtError_t, 0x78000001);

  358.   ASSERT_EQ(aicpu_task.LaunchKernel(stream), FAILED);

  359. 

  360.   RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE);

  361.   RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_NOT_SUPPORT);

  362.   EXPECT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), SUCCESS);

  363.   RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE);

  364.   RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_NOT_SUPPORT);

  365.   EXPECT_EQ(aicpu_task.LaunchKernel(stream), SUCCESS);

  366. }