OpenI
/
MegEngine
Not watched
1
0
Fork 0
Code
Releases 31 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: f971982829
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f971982829'
${ noResults }
MegEngine/lite/test/test_tensor.cpp

592 lines
20 kB
Raw Blame History 

  1. /**

  2.  * \file test/test_tensor.cpp

  3.  * MegEngine is Licensed under the Apache License, Version 2.0 (the "License")

  4.  *

  5.  * Copyright (c) 2014-2021 Megvii Inc. All rights reserved.

  6.  *

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

  8.  * software distributed under the License is distributed on an

  9.  * "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  10.  */

  11. 

  12. #include "lite_build_config.h"

  13. 

  14. #if LITE_BUILD_WITH_MGE

  15. #include "../src/misc.h"

  16. #include "../src/mge/common.h"

  17. #include "../src/mge/network_impl.h"

  18. #include "lite/tensor.h"

  19. 

  20. #include <gtest/gtest.h>

  21. 

  22. #include <string.h>

  23. #include <memory>

  24. 

  25. using namespace lite;

  26. 

  27. TEST(TestTensor, Basic) {

  28.     Layout layout{{1, 3, 224, 224}, 4};

  29.     Tensor tensor1(LiteDeviceType::LITE_CPU);

  30.     Tensor tensor2(LiteDeviceType::LITE_CPU, layout);

  31.     Tensor tensor3(LiteDeviceType::LITE_CPU, layout);

  32.     //! mge tensor has created

  33.     ASSERT_TRUE(TensorHelper::implement(&tensor1));

  34.     ASSERT_TRUE(TensorHelper::implement(&tensor2));

  35.     ASSERT_TRUE(TensorHelper::implement(&tensor3));

  36.     //! check member

  37.     ASSERT_EQ(tensor2.get_device_type(), LiteDeviceType::LITE_CPU);

  38.     ASSERT_EQ(tensor2.get_layout(), layout);

  39.     ASSERT_EQ(tensor3.get_layout(), layout);

  40.     //! check the real tensor

  41.     ASSERT_EQ(tensor2.get_tensor_total_size_in_byte(), 1 * 3 * 224 * 224 * 4);

  42.     ASSERT_EQ(tensor3.get_tensor_total_size_in_byte(), 1 * 3 * 224 * 224 * 4);

  43. 

  44.     ASSERT_TRUE(TensorHelper::implement(&tensor1)

  45.                         ->cast_final_safe<TensorImplDft>()

  46.                         .host_tensor());

  47. 

  48.     ASSERT_FALSE(TensorHelper::implement(&tensor1)

  49.                          ->cast_final_safe<TensorImplDft>()

  50.                          .dev_tensor());

  51.     ASSERT_FALSE(TensorHelper::implement(&tensor1)

  52.                          ->cast_final_safe<TensorImplDft>()

  53.                          .dev_tensor());

  54.     ASSERT_TRUE(TensorHelper::implement(&tensor1)

  55.                         ->cast_final_safe<TensorImplDft>()

  56.                         .host_tensor());

  57. }

  58. 

  59. TEST(TestTensor, SetLayoutReAlloc) {

  60.     Layout layout{{1, 3, 224, 224}, 4};

  61.     Tensor tensor1;

  62.     Tensor tensor2(LiteDeviceType::LITE_CPU, layout);

  63.     Tensor tensor3(LiteDeviceType::LITE_CPU, layout);

  64.     auto old_ptr2 = tensor2.get_memory_ptr();

  65.     auto old_ptr3 = tensor3.get_memory_ptr();

  66. 

  67.     //! layout set through

  68.     Layout layout1{{1, 3, 100, 100}, 4, LiteDataType::LITE_INT8};

  69.     tensor1.set_layout(layout1);

  70.     tensor2.set_layout(layout1);

  71.     tensor3.set_layout(layout1);

  72.     ASSERT_EQ(tensor2.get_tensor_total_size_in_byte(), 1 * 3 * 100 * 100);

  73.     ASSERT_EQ(tensor3.get_tensor_total_size_in_byte(), 1 * 3 * 100 * 100);

  74.     auto layout2 = TensorHelper::implement(&tensor2)

  75.                            ->cast_final_safe<TensorImplDft>()

  76.                            .host_tensor()

  77.                            ->layout();

  78.     auto layout3 = TensorHelper::implement(&tensor3)

  79.                            ->cast_final_safe<TensorImplDft>()

  80.                            .host_tensor()

  81.                            ->layout();

  82.     ASSERT_EQ(to_lite_layout(layout2), layout1);

  83.     ASSERT_EQ(to_lite_layout(layout3), layout1);

  84. 

  85.     auto new_ptr2 = tensor2.get_memory_ptr();

  86.     auto new_ptr3 = tensor3.get_memory_ptr();

  87. 

  88.     ASSERT_EQ(old_ptr2, new_ptr2);

  89.     ASSERT_EQ(old_ptr3, new_ptr3);

  90. }

  91. 

  92. TEST(TestTensor, Reset) {

  93.     Layout layout{{3, 20}, 2, LiteDataType::LITE_FLOAT};

  94.     Tensor tensor1;

  95.     Tensor tensor2(LiteDeviceType::LITE_CPU, layout);

  96.     Tensor tensor3(LiteDeviceType::LITE_CPU, layout);

  97. 

  98.     auto old_ptr2 = tensor2.get_memory_ptr();

  99.     auto old_ptr3 = tensor3.get_memory_ptr();

  100.     //! make sure memory is allocted

  101.     ASSERT_NO_THROW(memcpy(old_ptr2, old_ptr3, 3 * 20 * 2));

  102. 

  103.     std::shared_ptr<float> new_ptr2(new float[3 * 20],

  104.                                     [](float* ptr) { delete[] ptr; });

  105.     std::shared_ptr<float> new_ptr3(new float[3 * 20],

  106.                                     [](float* ptr) { delete[] ptr; });

  107.     tensor1.reset(new_ptr2.get(), layout);

  108.     tensor2.reset(new_ptr2.get(), 3 * 20 * 4);

  109.     tensor3.reset(new_ptr3.get(), 3 * 20 * 4);

  110.     //! After reset the original mem is freed

  111.     /*ASSERT_EXIT((memcpy(old_ptr2, old_ptr3, 3 * 20 * 2), exit(0)),

  112.                 ::testing::KilledBySignal(SIGSEGV), ".*");*/

  113. 

  114.     ASSERT_EQ(tensor2.get_memory_ptr(), new_ptr2.get());

  115.     ASSERT_EQ(tensor3.get_memory_ptr(), new_ptr3.get());

  116. 

  117.     ASSERT_NO_THROW(memcpy(new_ptr2.get(), new_ptr3.get(), 3 * 20 * 2));

  118. 

  119.     Layout layout1{{6, 20}, 2, LiteDataType::LITE_FLOAT};

  120.     std::shared_ptr<float> ptr2(new float[6 * 20],

  121.                                 [](float* ptr) { delete[] ptr; });

  122.     std::shared_ptr<float> ptr3(new float[6 * 20],

  123.                                 [](float* ptr) { delete[] ptr; });

  124.     tensor2.reset(ptr2.get(), layout1);

  125.     tensor3.reset(ptr3.get(), layout1);

  126. 

  127.     //! memory is not freed by Tensor reset

  128.     ASSERT_NO_THROW(memcpy(new_ptr2.get(), new_ptr3.get(), 3 * 20 * 2));

  129.     auto host_layout2 = TensorHelper::implement(&tensor2)

  130.                                 ->cast_final_safe<TensorImplDft>()

  131.                                 .host_tensor()

  132.                                 ->layout();

  133.     auto host_layout3 = TensorHelper::implement(&tensor3)

  134.                                 ->cast_final_safe<TensorImplDft>()

  135.                                 .host_tensor()

  136.                                 ->layout();

  137. 

  138.     ASSERT_EQ(to_lite_layout(host_layout2), layout1);

  139.     ASSERT_EQ(to_lite_layout(host_layout3), layout1);

  140. }

  141. 

  142. TEST(TestTensor, CrossCNCopy) {

  143.     Layout layout{{1, 3, 224, 224}, 4};

  144.     Tensor tensor1(LiteDeviceType::LITE_CPU);

  145.     Tensor tensor2(LiteDeviceType::LITE_CPU, layout);

  146.     Tensor tensor3(LiteDeviceType::LITE_CPU, layout);

  147.     tensor2.copy_from(tensor3);

  148.     tensor3.copy_from(tensor2);

  149.     auto old_ptr2 = tensor2.get_memory_ptr();

  150.     auto old_ptr3 = tensor3.get_memory_ptr();

  151. 

  152.     //! test source tenor is empty

  153.     ASSERT_THROW(tensor2.copy_from(tensor1), std::exception);

  154.     tensor1.copy_from(tensor2);

  155.     tensor2.copy_from(tensor3);

  156.     tensor3.copy_from(tensor2);

  157. 

  158.     ASSERT_EQ(tensor2.get_memory_ptr(), old_ptr2);

  159.     ASSERT_EQ(tensor3.get_memory_ptr(), old_ptr3);

  160. }

  161. 

  162. TEST(TestTensor, SharedTensorMemory) {

  163.     Layout layout{{1, 3, 224, 224}, 4};

  164.     Tensor tensor1(LiteDeviceType::LITE_CPU);

  165.     {

  166.         Tensor tensor2(LiteDeviceType::LITE_CPU, layout);

  167.         tensor1.share_memory_with(tensor2);

  168.         auto ptr1 = tensor1.get_memory_ptr();

  169.         auto ptr2 = tensor2.get_memory_ptr();

  170.         ASSERT_EQ(ptr1, ptr2);

  171.     }

  172.     // check after tensor2 destroy, tensor1 can also visit

  173.     auto ptr1 = static_cast<float*>(tensor1.get_memory_ptr());

  174.     size_t length = tensor1.get_tensor_total_size_in_byte() /

  175.                     tensor1.get_layout().get_elem_size();

  176.     for (size_t i = 0; i < length; i++) {

  177.         ptr1[i] = i;

  178.     }

  179. }

  180. 

  181. TEST(TestTensor, Reshape) {

  182.     Layout layout{{1, 3, 224, 224}, 4};

  183.     Tensor tensor2(LiteDeviceType::LITE_CPU, layout);

  184.     auto ptr = tensor2.get_memory_ptr();

  185. 

  186.     //! test wrong case

  187.     ASSERT_THROW(tensor2.reshape({-1, -1, 3 * 224 * 224}), std::exception);

  188.     ASSERT_THROW(tensor2.reshape({-1, 3, 3 * 224 * 224}), std::exception);

  189.     ASSERT_THROW(tensor2.reshape({1, 3, 3 * 224 * 224}), std::exception);

  190.     ASSERT_THROW(tensor2.reshape({3, 3, 3 * 224 * 224}), std::exception);

  191. 

  192.     tensor2.reshape({3 * 224 * 224});

  193.     ASSERT_EQ(tensor2.get_layout().ndim, 1);

  194.     ASSERT_EQ(tensor2.get_layout().data_type, LiteDataType::LITE_FLOAT);

  195.     ASSERT_EQ(tensor2.get_layout().shapes[0], 3 * 224 * 224);

  196.     tensor2.reshape({-1, 224, 224});

  197.     ASSERT_EQ(tensor2.get_layout().ndim, 3);

  198.     ASSERT_EQ(tensor2.get_layout().shapes[0], 3);

  199.     ASSERT_EQ(tensor2.get_layout().shapes[1], 224);

  200. 

  201.     ASSERT_EQ(tensor2.get_memory_ptr(), ptr);

  202. }

  203. 

  204. TEST(TestTensor, Slice) {

  205.     Layout layout{{20, 20}, 2};

  206.     Tensor tensor2(LiteDeviceType::LITE_CPU, layout);

  207.     auto ptr = tensor2.get_memory_ptr();

  208. 

  209.     //! test source tenor is empty

  210.     ASSERT_THROW(tensor2.slice({5, 10, 10}, {10, 15}), std::exception);

  211.     ASSERT_THROW(tensor2.slice({5, 10}, {10, 15}, {5}), std::exception);

  212.     ASSERT_THROW(tensor2.slice({5, 10}, {10, 15, 10}), std::exception);

  213.     for (int i = 0; i < 20 * 20; i++) {

  214.         *(static_cast<float*>(ptr) + i) = i;

  215.     }

  216.     auto check = [&](size_t start, size_t end, size_t step) {

  217.         Tensor tensor3;

  218.         tensor3.copy_from(

  219.                 *tensor2.slice({start, start}, {end, end}, {step, step}));

  220.         float* new_ptr = static_cast<float*>(tensor3.get_memory_ptr());

  221.         for (size_t i = start; i < end; i += step) {

  222.             for (size_t j = start; j < end; j += step) {

  223.                 ASSERT_EQ(float(i * 20 + j), *new_ptr);

  224.                 ++new_ptr;

  225.             }

  226.         }

  227.     };

  228.     check(5, 10, 1);

  229.     check(5, 11, 2);

  230.     check(2, 18, 4);

  231. 

  232.     Tensor tensor3;

  233.     tensor3.copy_from(*tensor2.slice({3}, {9}, {2}));

  234.     float* new_ptr = static_cast<float*>(tensor3.get_memory_ptr());

  235.     for (size_t i = 3; i < 9; i += 2) {

  236.         for (size_t j = 0; j < 20; j++) {

  237.             ASSERT_EQ(float(i * 20 + j), *new_ptr);

  238.             ++new_ptr;

  239.         }

  240.     }

  241. }

  242. 

  243. TEST(TestTensor, SliceCopy) {

  244.     Layout layout{{20, 20}, 2};

  245.     Tensor tensor(LiteDeviceType::LITE_CPU, layout);

  246.     //! alloc memory

  247.     auto ptr = static_cast<float*>(tensor.get_memory_ptr());

  248. 

  249.     Layout layout_slice{{20, 10}, 2};

  250.     Tensor tensor0(LiteDeviceType::LITE_CPU, layout_slice);

  251.     auto ptr0 = tensor0.get_memory_ptr();

  252.     for (int i = 0; i < 10 * 20; i++) {

  253.         *(static_cast<float*>(ptr0) + i) = i;

  254.     }

  255.     Tensor tensor1(LiteDeviceType::LITE_CPU, layout_slice);

  256.     auto ptr1 = tensor1.get_memory_ptr();

  257.     for (int i = 0; i < 10 * 20; i++) {

  258.         *(static_cast<float*>(ptr1) + i) = i + 200;

  259.     }

  260. 

  261.     auto slice0 = tensor.slice({0, 0}, {20, 10});

  262.     auto slice1 = tensor.slice({0, 10}, {20, 20});

  263. 

  264.     slice0->copy_from(tensor0);

  265.     slice1->copy_from(tensor1);

  266. 

  267.     ASSERT_FALSE(slice0->is_continue_memory());

  268.     ASSERT_FALSE(slice1->is_continue_memory());

  269. 

  270.     for (size_t i = 0; i < 20; i++) {

  271.         for (size_t j = 0; j < 10; j++) {

  272.             ASSERT_EQ(float(i * 10 + j), *ptr);

  273.             ++ptr;

  274.         }

  275.         for (size_t j = 0; j < 10; j++) {

  276.             ASSERT_EQ(float(i * 10 + j + 200), *ptr);

  277.             ++ptr;

  278.         }

  279.     }

  280.     slice0->fill_zero();

  281.     Tensor tmp;

  282.     tmp.copy_from(*slice0);

  283.     float* tmp_ptr = static_cast<float*>(tmp.get_memory_ptr());

  284.     for (size_t i = 0; i < 20; i++) {

  285.         for (size_t j = 0; j < 10; j++) {

  286.             ASSERT_EQ(float(0), *tmp_ptr);

  287.             ++tmp_ptr;

  288.         }

  289.     }

  290. }

  291. 

  292. TEST(TestTensor, GetPtrOffset) {

  293.     Layout layout{{20, 20}, 2};

  294.     Tensor tensor(LiteDeviceType::LITE_CPU, layout);

  295.     //! alloc memory

  296.     auto ptr = static_cast<float*>(tensor.get_memory_ptr());

  297. 

  298.     auto ptr_offset = tensor.get_memory_ptr({10, 10});

  299.     ASSERT_EQ(ptr_offset, ptr + 10 * 20 + 10);

  300. 

  301.     auto slice0 = tensor.slice({0, 0}, {20, 10});

  302.     auto slice1 = tensor.slice({0, 10}, {20, 20});

  303. 

  304.     ASSERT_FALSE(slice0->is_continue_memory());

  305.     ASSERT_FALSE(slice1->is_continue_memory());

  306. 

  307.     auto ptr_offset_slice0 = slice0->get_memory_ptr({6, 5});

  308.     auto ptr_offset_slice1 = slice1->get_memory_ptr({2, 5});

  309. 

  310.     ASSERT_EQ(ptr_offset_slice0, ptr + 6 * 20 + 5);

  311.     ASSERT_EQ(ptr_offset_slice1, ptr + 2 * 20 + 10 + 5);

  312. }

  313. 

  314. TEST(TestTensor, Concat) {

  315.     Layout layout{{5, 5, 5}, 3};

  316.     std::vector<Tensor> tensors;

  317.     for (int i = 0; i < 4; i++) {

  318.         Tensor tensor(LiteDeviceType::LITE_CPU, layout);

  319.         auto ptr = static_cast<float*>(tensor.get_memory_ptr());

  320.         for (int n = 0; n < 5 * 5 * 5; n++) {

  321.             ptr[n] = i;

  322.         }

  323.         tensors.push_back(tensor);

  324.     }

  325.     auto check = [&](int dim) {

  326.         auto new_tensor = TensorUtils::concat(tensors, dim);

  327.         auto ptr = static_cast<float*>(new_tensor->get_memory_ptr());

  328.         size_t stride = std::pow(5, (3 - dim));

  329.         for (int i = 0; i < 4; i++) {

  330.             for (size_t j = 0; j < stride; j++) {

  331.                 ASSERT_EQ(ptr[i * stride + j], i);

  332.             }

  333.         }

  334.     };

  335.     check(0);

  336.     check(1);

  337.     check(2);

  338. }

  339. 

  340. #if LITE_WITH_CUDA

  341. TEST(TestTensor, BasicDevice) {

  342.     Layout layout{{1, 3, 224, 224}, 4};

  343.     Tensor tensor1(LiteDeviceType::LITE_CUDA, layout);

  344.     Tensor tensor2(LiteDeviceType::LITE_CPU, layout);

  345.     //! mge tensor has created

  346.     ASSERT_TRUE(TensorHelper::implement(&tensor1));

  347.     ASSERT_TRUE(TensorHelper::implement(&tensor2));

  348. 

  349.     //! check member

  350.     ASSERT_EQ(tensor1.get_device_type(), LiteDeviceType::LITE_CUDA);

  351.     ASSERT_EQ(tensor2.get_device_type(), LiteDeviceType::LITE_CPU);

  352.     ASSERT_EQ(tensor2.get_layout(), layout);

  353.     //! check the real tensor

  354.     ASSERT_EQ(tensor1.get_tensor_total_size_in_byte(), 1 * 3 * 224 * 224 * 4);

  355.     ASSERT_EQ(tensor2.get_tensor_total_size_in_byte(), 1 * 3 * 224 * 224 * 4);

  356. 

  357.     ASSERT_TRUE(TensorHelper::implement(&tensor2)

  358.                         ->cast_final_safe<TensorImplDft>()

  359.                         .host_tensor());

  360. 

  361.     ASSERT_FALSE(TensorHelper::implement(&tensor2)

  362.                          ->cast_final_safe<TensorImplDft>()

  363.                          .dev_tensor());

  364.     ASSERT_TRUE(TensorHelper::implement(&tensor1)

  365.                         ->cast_final_safe<TensorImplDft>()

  366.                         .dev_tensor());

  367.     ASSERT_FALSE(TensorHelper::implement(&tensor1)

  368.                          ->cast_final_safe<TensorImplDft>()

  369.                          .host_tensor());

  370. }

  371. 

  372. TEST(TestTensor, SetLayoutReAllocDevice) {

  373.     Layout layout{{1, 3, 224, 224}, 4};

  374.     Tensor tensor2(LiteDeviceType::LITE_CUDA, layout);

  375.     auto old_ptr2 = tensor2.get_memory_ptr();

  376. 

  377.     //! layout set through

  378.     Layout layout1{{1, 3, 100, 100}, 4, LiteDataType::LITE_INT8};

  379.     tensor2.set_layout(layout1);

  380.     ASSERT_EQ(tensor2.get_tensor_total_size_in_byte(), 1 * 3 * 100 * 100);

  381.     auto layout2 = TensorHelper::implement(&tensor2)

  382.                            ->cast_final_safe<TensorImplDft>()

  383.                            .dev_tensor()

  384.                            ->layout();

  385.     ASSERT_EQ(to_lite_layout(layout2), layout1);

  386. 

  387.     auto new_ptr2 = tensor2.get_memory_ptr();

  388. 

  389.     ASSERT_EQ(old_ptr2, new_ptr2);

  390. }

  391. 

  392. TEST(TestTensor, CrossCNCopyDevice) {

  393.     Layout layout{{1, 3, 224, 224}, 4};

  394.     Tensor tensor0;

  395.     Tensor tensor1(LiteDeviceType::LITE_CPU);

  396.     Tensor tensor2(LiteDeviceType::LITE_CPU, layout);

  397.     Tensor tensor3(LiteDeviceType::LITE_CUDA, layout);

  398. 

  399.     tensor2.copy_from(tensor3);

  400.     tensor3.copy_from(tensor2);

  401. 

  402.     auto old_ptr2 = tensor2.get_memory_ptr();

  403.     auto old_ptr3 = tensor3.get_memory_ptr();

  404.     ASSERT_THROW(tensor3.copy_from(tensor1), std::exception);

  405. 

  406.     tensor1.copy_from(tensor3);

  407.     tensor0.copy_from(tensor3);

  408. 

  409.     tensor2.copy_from(tensor3);

  410.     tensor3.copy_from(tensor2);

  411. 

  412.     ASSERT_EQ(tensor2.get_memory_ptr(), old_ptr2);

  413.     ASSERT_EQ(tensor3.get_memory_ptr(), old_ptr3);

  414. }

  415. 

  416. TEST(TestTensor, PinnedHostMem) {

  417.     Layout layout{{1, 3, 224, 224}, 4};

  418.     Tensor tensor1(LiteDeviceType::LITE_CPU);

  419.     bool is_pinned_host = true;

  420.     Tensor tensor2(LiteDeviceType::LITE_CUDA, layout, is_pinned_host);

  421.     Tensor tensor3(LiteDeviceType::LITE_CUDA, layout);

  422.     tensor2.copy_from(tensor3);

  423.     tensor3.copy_from(tensor2);

  424. 

  425.     ASSERT_EQ(tensor2.is_pinned_host(), true);

  426.     ASSERT_EQ(tensor3.is_pinned_host(), false);

  427. 

  428.     auto old_ptr2 = tensor2.get_memory_ptr();

  429.     auto old_ptr3 = tensor3.get_memory_ptr();

  430. 

  431.     //! test source tenor is empty

  432.     ASSERT_THROW(tensor2.copy_from(tensor1), std::exception);

  433.     tensor1.copy_from(tensor2);

  434.     tensor2.copy_from(tensor3);

  435.     tensor3.copy_from(tensor2);

  436. 

  437.     ASSERT_EQ(tensor2.get_memory_ptr(), old_ptr2);

  438.     ASSERT_EQ(tensor3.get_memory_ptr(), old_ptr3);

  439. }

  440. 

  441. TEST(TestTensor, DeviceId) {

  442.     if(get_device_count(LITE_CUDA) <= 1)

  443.         return;

  444.     Layout layout{{1, 3, 224, 224}, 4};

  445.     Tensor tensor2(0, LiteDeviceType::LITE_CUDA, layout);

  446.     Tensor tensor3(1, LiteDeviceType::LITE_CUDA, layout);

  447. 

  448.     tensor2.copy_from(tensor3);

  449.     tensor3.copy_from(tensor2);

  450. 

  451.     Tensor tensor1;

  452.     tensor1.copy_from(tensor2);

  453.     tensor1.copy_from(tensor3);

  454. }

  455. 

  456. TEST(TestTensor, SliceDevice) {

  457.     Layout layout{{20, 20}, 2};

  458.     Tensor host_tensor0;

  459.     Tensor dev_tensor0(LiteDeviceType::LITE_CUDA, layout);

  460.     host_tensor0.copy_from(dev_tensor0);

  461.     auto ptr = host_tensor0.get_memory_ptr();

  462. 

  463.     for (int i = 0; i < 20 * 20; i++) {

  464.         *(static_cast<float*>(ptr) + i) = i;

  465.     }

  466.     dev_tensor0.copy_from(host_tensor0);

  467. 

  468.     auto check = [&](size_t start, size_t end, size_t step) {

  469.         Tensor host_tensor;

  470.         host_tensor.copy_from(

  471.                 *dev_tensor0.slice({start, start}, {end, end}, {step, step}));

  472.         float* new_ptr = static_cast<float*>(host_tensor.get_memory_ptr());

  473.         for (size_t i = start; i < end; i += step) {

  474.             for (size_t j = start; j < end; j += step) {

  475.                 ASSERT_EQ(float(i * 20 + j), *new_ptr);

  476.                 ++new_ptr;

  477.             }

  478.         }

  479.     };

  480.     check(5, 10, 1);

  481.     check(5, 11, 2);

  482.     check(2, 18, 4);

  483. }

  484. 

  485. TEST(TestTensor, MemSetDevice) {

  486.     Layout layout{{20, 20}, 2, LiteDataType::LITE_INT8};

  487.     Tensor host_tensor0(LiteDeviceType::LITE_CPU, layout);

  488.     Tensor dev_tensor0(LiteDeviceType::LITE_CUDA, layout);

  489.     auto check = [&](uint8_t val, const Tensor& tensor) {

  490.         auto ptr = static_cast<uint8_t*>(tensor.get_memory_ptr());

  491.         for (int i = 0; i < 20 * 20; i++) {

  492.             ASSERT_EQ(val, *(ptr + i));

  493.         }

  494.     };

  495.     host_tensor0.fill_zero();

  496.     check(0, host_tensor0);

  497. 

  498.     Tensor host_tensor1;

  499.     dev_tensor0.fill_zero();

  500.     host_tensor1.copy_from(dev_tensor0);

  501.     check(0, host_tensor1);

  502. }

  503. 

  504. TEST(TestTensor, DeviceSliceCopy) {

  505.     Layout layout{{20, 20}, 2};

  506.     Tensor tensor(LiteDeviceType::LITE_CUDA, layout);

  507.     //! alloc memory

  508.     tensor.get_memory_ptr();

  509. 

  510.     Layout layout_slice{{20, 10}, 2};

  511.     Tensor tensor0(LiteDeviceType::LITE_CPU, layout_slice);

  512.     auto ptr0 = tensor0.get_memory_ptr();

  513.     for (int i = 0; i < 10 * 20; i++) {

  514.         *(static_cast<float*>(ptr0) + i) = i;

  515.     }

  516.     Tensor tensor1(LiteDeviceType::LITE_CPU, layout_slice);

  517.     auto ptr1 = tensor1.get_memory_ptr();

  518.     for (int i = 0; i < 10 * 20; i++) {

  519.         *(static_cast<float*>(ptr1) + i) = i + 200;

  520.     }

  521. 

  522.     auto slice0 = tensor.slice({0, 0}, {20, 10});

  523.     auto slice1 = tensor.slice({0, 10}, {20, 20});

  524. 

  525.     slice0->copy_from(tensor0);

  526.     slice1->copy_from(tensor1);

  527. 

  528.     ASSERT_FALSE(slice0->is_continue_memory());

  529.     ASSERT_FALSE(slice1->is_continue_memory());

  530. 

  531.     Tensor host_tensor;

  532.     host_tensor.copy_from(tensor);

  533.     auto ptr = static_cast<float*>(host_tensor.get_memory_ptr());

  534. 

  535.     for (size_t i = 0; i < 20; i++) {

  536.         for (size_t j = 0; j < 10; j++) {

  537.             ASSERT_EQ(float(i * 10 + j), *ptr);

  538.             ++ptr;

  539.         }

  540.         for (size_t j = 0; j < 10; j++) {

  541.             ASSERT_EQ(float(i * 10 + j + 200), *ptr);

  542.             ++ptr;

  543.         }

  544.     }

  545.     slice0->fill_zero();

  546.     Tensor tmp;

  547.     tmp.copy_from(*slice0);

  548.     float* tmp_ptr = static_cast<float*>(tmp.get_memory_ptr());

  549.     for (size_t i = 0; i < 20; i++) {

  550.         for (size_t j = 0; j < 10; j++) {

  551.             ASSERT_EQ(float(0), *tmp_ptr);

  552.             ++tmp_ptr;

  553.         }

  554.     }

  555. }

  556. 

  557. TEST(TestTensor, ConcatDevice) {

  558.     Layout layout{{5, 5, 5}, 3};

  559.     std::vector<Tensor> tensors;

  560.     for (int i = 0; i < 4; i++) {

  561.         Tensor tensor(LiteDeviceType::LITE_CPU, layout);

  562.         auto ptr = static_cast<float*>(tensor.get_memory_ptr());

  563.         for (int n = 0; n < 5 * 5 * 5; n++) {

  564.             ptr[n] = i;

  565.         }

  566.         tensors.push_back(tensor);

  567.     }

  568.     auto check = [&](int dim) {

  569.         auto new_tensor =

  570.                 TensorUtils::concat(tensors, dim, LiteDeviceType::LITE_CUDA, 0);

  571. 

  572.         Tensor tensor(LiteDeviceType::LITE_CPU);

  573.         tensor.copy_from(*new_tensor);

  574.         auto ptr = static_cast<float*>(tensor.get_memory_ptr());

  575.         size_t stride = std::pow(5, (3 - dim));

  576.         for (int i = 0; i < 4; i++) {

  577.             for (size_t j = 0; j < stride; j++) {

  578.                 ASSERT_EQ(ptr[i * stride + j], i);

  579.             }

  580.         }

  581.         ASSERT_EQ(new_tensor->get_device_type(), LiteDeviceType::LITE_CUDA);

  582.         ASSERT_EQ(new_tensor->get_device_id(), 0);

  583.     };

  584.     check(0);

  585.     check(1);

  586.     check(2);

  587. }

  588. #endif

  589. #endif

  590. 

  591. // vim: syntax=cpp.doxygen foldmethod=marker foldmarker=f{{{,f}}}