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: 6e882c1a86
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6e882c1a86'
${ noResults }
MegEngine/dnn/test/cuda/relayout.cpp

921 lines
38 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/test/cuda/relayout.cpp

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

  4.  *

  5.  * Copyright (c) 2014-2020 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 "test/common/relayout.h"

  13. #include "megdnn/oprs.h"

  14. #include "test/common/checker.h"

  15. #include "test/cuda/benchmark.h"

  16. #include "test/cuda/fixture.h"

  17. #include "test/common/rng.h"

  18. 

  19. using namespace megdnn;

  20. using namespace test;

  21. 

  22. namespace {

  23. template <typename tag>

  24. class CUDA_RELAYOUT : public CUDA {};

  25. TYPED_TEST_CASE(CUDA_RELAYOUT, relayout::test_types);

  26. TYPED_TEST(CUDA_RELAYOUT, run) {

  27.     relayout::run_test<TypeParam>(this->handle_cuda());

  28. }

  29. }  // namespace

  30. 

  31. TEST_F(CUDA, RELAYOUT_TRANSPOSE) {

  32.     Checker<Relayout> checker(handle_cuda());

  33.     auto run = [&](size_t batch, size_t m, size_t n, size_t c, DType dtype) {

  34.         checker.set_dtype(0, dtype).set_dtype(1, dtype);

  35.         TensorLayout src = {{batch, m, n, c}, dtype};

  36.         src.init_contiguous_stride();

  37.         TensorLayout dst = {{batch, m, n, c}, dtype};

  38.         dst.stride[0] = m * n * c;

  39.         dst.stride[1] = c;

  40.         dst.stride[2] = m * c;

  41.         dst.stride[3] = 1;

  42.         checker.execl({src, dst});

  43.     };

  44.     run(16, 30, 40, 4, dtype::Int8());

  45.     run(16, 20, 10, 4, dtype::Int8());

  46.     run(1, 30, 20, 1, dtype::Int32());

  47.     run(1, 20, 30, 1, dtype::Int32());

  48.     run(1, 11, 21, 1, dtype::Float32());

  49. }

  50. 

  51. #if MEGDNN_WITH_BENCHMARK

  52. TEST_F(CUDA, BENCHMARK_RELAYOUT_TRANSPOSE) {

  53.     static constexpr size_t RUNS = 1000;

  54.     CUBenchmarker<Relayout> benchmarker(handle_cuda());

  55.     benchmarker.set_times(RUNS);

  56.     auto run = [&](size_t batch, size_t m, size_t n, size_t c, DType dtype) {

  57.         benchmarker.set_dtype(0, dtype).set_dtype(1, dtype);

  58.         TensorLayout src = {{batch, m, n, c}, dtype};

  59.         src.init_contiguous_stride();

  60.         TensorLayout dst = {{batch, m, n, c}, dtype};

  61.         dst.stride[0] = m * n * c;

  62.         dst.stride[1] = c;

  63.         dst.stride[2] = m * c;

  64.         dst.stride[3] = 1;

  65.         auto time_ms =

  66.                 benchmarker.execl({src, dst}) / RUNS;

  67.         printf("{%zux%zux%zux%zu}->{%zux%zux%zux%zu} bandwidth: %.2f gbps\n",

  68.                batch, m, n, c, batch, n, m, c,

  69.                2.f * batch * m * n * c * dtype.size() / (1e6 * time_ms));

  70.     };

  71.     run(16, 640, 480, 4, dtype::Int8());

  72.     run(256, 224, 224, 4, dtype::Int8());

  73.     run(1, 256, 224 * 224, 1, dtype::Int32());

  74.     run(1, 256, 7 * 7 * 512, 1, dtype::Int32());

  75.     run(1, 4096, 4096, 1, dtype::Float32());

  76. }

  77. 

  78. TEST_F(CUDA, BENCHMARK_RELAYOUT) {

  79.     //! benchmark contious layout, such as (a, b, c, d) -> (b, a, c,d)

  80.     //! just change the first two axis

  81.     static constexpr size_t RUNS = 3;

  82.     auto run = [&](const TensorLayoutArray& layouts) {

  83.         Benchmarker<Relayout> benchmarker(handle_cuda());

  84. 

  85.         benchmarker.set_times(RUNS);

  86.         for (auto&& layout : layouts) {

  87.             TensorLayout src = layout.dimshuffle({1, 0, 2});

  88.             TensorLayout dst = layout;

  89.             std::swap(dst.shape[0], dst.shape[1]);

  90.             dst.init_contiguous_stride();

  91.             auto used = benchmarker.execl({src, dst});

  92.             printf("layout: %s bandwith: %f gbps/s\n",

  93.                    layout.to_string().c_str(),

  94.                    2 * layout.total_nr_elems() * layout.dtype.size() * RUNS /

  95.                            used * 1000 / (1024 * 1024 * 1024));

  96.         }

  97.     };

  98. 

  99.     TensorLayoutArray layouts = {

  100.             {{12, 23, 2}, dtype::Int32()},

  101.             {{12, 23, 8}, dtype::Int32()},

  102.             {{12, 23, 17}, dtype::Int32()},

  103.             {{12, 23, 64}, dtype::Int32()},

  104.             {{12, 23, 129}, dtype::Int32()},

  105.             {{12, 23, 256}, dtype::Int32()},

  106.             {{12, 23, 1029}, dtype::Int32()},

  107.             {{12, 23, 4096}, dtype::Int32()},

  108.             {{12, 23, 9143}, dtype::Int32()},

  109.             {{12, 23, 18284}, dtype::Int32()},

  110.             {{2, 2, 1000000}, dtype::Int32()},

  111.     };

  112.     run(layouts);

  113. 

  114.     auto run2 = [&](const TensorLayoutArray& layouts) {

  115.         Benchmarker<Relayout> benchmarker(handle_cuda());

  116. 

  117.         benchmarker.set_times(RUNS);

  118.         for (auto&& layout : layouts) {

  119.             TensorLayout src = layout.dimshuffle({0, 2, 1, 3});

  120.             TensorLayout dst = layout;

  121.             std::swap(dst.shape[0], dst.shape[1]);

  122.             dst.init_contiguous_stride();

  123.             auto used = benchmarker.execl({src, dst});

  124. 

  125.             printf("layout: %s bandwith: %f gbps/s\n",

  126.                    layout.to_string().c_str(),

  127.                    2 * layout.total_nr_elems() * layout.dtype.size() * RUNS /

  128.                            used * 1000 / (1024 * 1024 * 1024));

  129.         }

  130.     };

  131. 

  132.     layouts = {

  133.             {{3, 12, 24, 100}, dtype::Int32()},

  134.             {{3, 12, 24, 1029}, dtype::Int32()},

  135.             {{3, 4, 24, 9143}, dtype::Int32()},

  136.             {{3, 4, 24, 18284}, dtype::Int32()},

  137.     };

  138. 

  139.     run2(layouts);

  140. }

  141. 

  142. TEST_F(CUDA, BENCHMARK_RELAYOUT_LAST_CONTIG) {

  143.     //! src and dst are all get subtensor in channel axis

  144.     static constexpr size_t RUNS = 3;

  145. 

  146.     Benchmarker<Relayout> benchmarker(handle_cuda());

  147.     benchmarker.set_times(RUNS);

  148.     TensorLayout src =

  149.             TensorLayout({5, 5, 100000}, {800000, 100000, 1}, dtype::Float32());

  150.     TensorLayout dst =

  151.             TensorLayout({5, 5, 100000}, {700000, 100000, 1}, dtype::Float32());

  152.     auto used = benchmarker.execl({src, dst});

  153. 

  154.     printf("src: %s dst: %s bandwith: %f gbps/s\n", src.to_string().c_str(),

  155.            dst.to_string().c_str(),

  156.            2 * src.total_nr_elems() * src.dtype.size() * RUNS / used * 1000 /

  157.                    (1024 * 1024 * 1024));

  158. }

  159. 

  160. TEST_F(CUDA, BENCHMARK_RELAYOUT_LAST_NOT_CONTIG) {

  161.     static constexpr size_t RUNS = 3;

  162. 

  163.     auto run = [&](TensorLayout src, TensorLayout dst) {

  164.         Benchmarker<Relayout> benchmarker(handle_cuda());

  165.         auto&& layout = src;

  166.         benchmarker.set_times(RUNS);

  167.         dst.init_contiguous_stride();

  168.         auto used = benchmarker.execl({src, dst});

  169.         printf("layout: %s bandwith: %f gbps/s\n", layout.to_string().c_str(),

  170.                2 * layout.total_nr_elems() * layout.dtype.size() * RUNS / used *

  171.                        1000 / (1024 * 1024 * 1024));

  172.     };

  173. 

  174.     run({{16, 128, 128}, {49152, 384, 3}, dtype::Float32()},

  175.         {{16, 128, 128}, {16384, 128, 1}, dtype::Float32()});

  176. }

  177. 

  178. TEST_F(CUDA, BENCHMARK_RELAYOUT_6) {

  179.     static constexpr size_t RUNS = 3;

  180.     auto run = [&](TensorLayoutArray layouts,

  181.                    std::vector<std::vector<size_t>> permutations) {

  182.         Benchmarker<Relayout> benchmarker(handle_cuda());

  183. 

  184.         benchmarker.set_times(RUNS);

  185.         int i = 0;

  186.         for (auto&& layout : layouts) {

  187.             auto per = permutations[i];

  188.             TensorLayout src = layout.dimshuffle(per);

  189.             TensorLayout dst = layout;

  190.             std::swap(dst.shape[0], dst.shape[1]);

  191.             dst.init_contiguous_stride();

  192.             auto used = benchmarker.execl({src, dst});

  193.             Checker<Relayout> checker(handle_cuda());

  194.             checker.exec(TensorLayoutArray{src, dst});

  195.             printf("layout: %s bandwith: %f gbps/s\n",

  196.                    layout.to_string().c_str(),

  197.                    2 * layout.total_nr_elems() * layout.dtype.size() * RUNS /

  198.                            used * 1000 / (1024 * 1024 * 1024));

  199.             i++;

  200.         }

  201.     };

  202.     TensorLayoutArray layouts = {

  203.             {{7248, 7248}, dtype::Int32()},

  204.             {{43408, 1216}, dtype::Int32()},

  205.             {{1216, 43408}, dtype::Int32()},

  206.             {{368, 384, 384}, dtype::Int32()},

  207.             {{2144, 64, 384}, dtype::Int32()},

  208.             {{368, 64, 2307}, dtype::Int32()},

  209.             {{384, 384, 355}, dtype::Int32()},

  210.             {{2320, 384, 59}, dtype::Int32()},

  211.             {{384, 2320, 59}, dtype::Int32()},

  212.             {{384, 355, 384}, dtype::Int32()},

  213.             {{2320, 59, 384}, dtype::Int32()},

  214.             {{384, 59, 2320}, dtype::Int32()},

  215.             {{80, 96, 75, 96}, dtype::Int32()},

  216.             {{464, 16, 75, 96}, dtype::Int32()},

  217.             {{80, 16, 75, 582}, dtype::Int32()},

  218.             {{96, 75, 96, 75}, dtype::Int32()},

  219.             {{608, 12, 96, 75}, dtype::Int32()},

  220.             {{96, 12, 608, 75}, dtype::Int32()},

  221.             {{96, 75, 96, 75}, dtype::Int32()},

  222.             {{608, 12, 96, 75}, dtype::Int32()},

  223.             {{96, 12, 608, 75}, dtype::Int32()},

  224.             {{96, 96, 75, 75}, dtype::Int32()},

  225.             {{608, 96, 12, 75}, dtype::Int32()},

  226.             {{96, 608, 12, 75}, dtype::Int32()},

  227.             {{96, 75, 75, 96}, dtype::Int32()},

  228.             {{608, 12, 75, 96}, dtype::Int32()},

  229.             {{96, 12, 75, 608}, dtype::Int32()},

  230.             {{32, 48, 28, 28, 48}, dtype::Int32()},

  231.             {{176, 8, 28, 28, 48}, dtype::Int32()},

  232.             {{32, 8, 28, 28, 298}, dtype::Int32()},

  233.             {{48, 28, 28, 48, 28}, dtype::Int32()},

  234.             {{352, 4, 28, 48, 28}, dtype::Int32()},

  235.             {{48, 4, 28, 352, 28}, dtype::Int32()},

  236.             {{48, 28, 48, 28, 28}, dtype::Int32()},

  237.             {{352, 4, 48, 28, 28}, dtype::Int32()},

  238.             {{48, 4, 352, 28, 28}, dtype::Int32()},

  239.             {{48, 48, 28, 28, 28}, dtype::Int32()},

  240.             {{352, 48, 4, 28, 28}, dtype::Int32()},

  241.             {{48, 352, 4, 28, 28}, dtype::Int32()},

  242.             {{48, 28, 28, 28, 48}, dtype::Int32()},

  243.             {{352, 4, 28, 28, 48}, dtype::Int32()},

  244.             {{48, 4, 28, 28, 352}, dtype::Int32()},

  245.             {{16, 32, 15, 32, 15, 15}, dtype::Int32()},

  246.             {{48, 10, 15, 32, 15, 15}, dtype::Int32()},

  247.             {{16, 10, 15, 103, 15, 15}, dtype::Int32()},

  248.             {{32, 15, 15, 32, 15, 15}, dtype::Int32()},

  249.             {{112, 5, 15, 32, 15, 15}, dtype::Int32()},

  250.             {{32, 5, 15, 112, 15, 15}, dtype::Int32()},

  251.             {{32, 15, 32, 15, 15, 15}, dtype::Int32()},

  252.             {{112, 5, 32, 15, 15, 15}, dtype::Int32()},

  253.             {{32, 5, 112, 15, 15, 15}, dtype::Int32()},

  254.             {{32, 15, 15, 32, 15, 15}, dtype::Int32()},

  255.             {{112, 5, 15, 32, 15, 15}, dtype::Int32()},

  256.             {{32, 5, 15, 112, 15, 15}, dtype::Int32()},

  257.             {{32, 15, 15, 15, 15, 32}, dtype::Int32()},

  258.             {{112, 5, 15, 15, 15, 32}, dtype::Int32()},

  259.             {{32, 5, 15, 15, 15, 112}, dtype::Int32()},

  260.     };

  261. 

  262.     std::vector<std::vector<size_t>> permutations = {

  263.             std::vector<size_t>{1, 0},

  264.             std::vector<size_t>{1, 0},

  265.             std::vector<size_t>{1, 0},

  266.             std::vector<size_t>{0, 2, 1},

  267.             std::vector<size_t>{0, 2, 1},

  268.             std::vector<size_t>{0, 2, 1},

  269.             std::vector<size_t>{1, 0, 2},

  270.             std::vector<size_t>{1, 0, 2},

  271.             std::vector<size_t>{1, 0, 2},

  272.             std::vector<size_t>{2, 1, 0},

  273.             std::vector<size_t>{2, 1, 0},

  274.             std::vector<size_t>{2, 1, 0},

  275.             std::vector<size_t>{0, 3, 2, 1},

  276.             std::vector<size_t>{0, 3, 2, 1},

  277.             std::vector<size_t>{0, 3, 2, 1},

  278.             std::vector<size_t>{2, 1, 3, 0},

  279.             std::vector<size_t>{2, 1, 3, 0},

  280.             std::vector<size_t>{2, 1, 3, 0},

  281.             std::vector<size_t>{2, 0, 3, 1},

  282.             std::vector<size_t>{2, 0, 3, 1},

  283.             std::vector<size_t>{2, 0, 3, 1},

  284.             std::vector<size_t>{1, 0, 3, 2},

  285.             std::vector<size_t>{1, 0, 3, 2},

  286.             std::vector<size_t>{1, 0, 3, 2},

  287.             std::vector<size_t>{3, 2, 1, 0},

  288.             std::vector<size_t>{3, 2, 1, 0},

  289.             std::vector<size_t>{3, 2, 1, 0},

  290.             std::vector<size_t>{0, 4, 2, 1, 3},

  291.             std::vector<size_t>{0, 4, 2, 1, 3},

  292.             std::vector<size_t>{0, 4, 2, 1, 3},

  293.             std::vector<size_t>{3, 2, 1, 4, 0},

  294.             std::vector<size_t>{3, 2, 1, 4, 0},

  295.             std::vector<size_t>{3, 2, 1, 4, 0},

  296.             std::vector<size_t>{2, 0, 4, 1, 3},

  297.             std::vector<size_t>{2, 0, 4, 1, 3},

  298.             std::vector<size_t>{2, 0, 4, 1, 3},

  299.             std::vector<size_t>{1, 3, 0, 4, 2},

  300.             std::vector<size_t>{1, 3, 0, 4, 2},

  301.             std::vector<size_t>{1, 3, 0, 4, 2},

  302.             std::vector<size_t>{4, 3, 2, 1, 0},

  303.             std::vector<size_t>{4, 3, 2, 1, 0},

  304.             std::vector<size_t>{4, 3, 2, 1, 0},

  305.             std::vector<size_t>{0, 3, 2, 5, 4, 1},

  306.             std::vector<size_t>{0, 3, 2, 5, 4, 1},

  307.             std::vector<size_t>{0, 3, 2, 5, 4, 1},

  308.             std::vector<size_t>{3, 2, 0, 5, 1, 4},

  309.             std::vector<size_t>{3, 2, 0, 5, 1, 4},

  310.             std::vector<size_t>{3, 2, 0, 5, 1, 4},

  311.             std::vector<size_t>{2, 0, 4, 1, 5, 3},

  312.             std::vector<size_t>{2, 0, 4, 1, 5, 3},

  313.             std::vector<size_t>{2, 0, 4, 1, 5, 3},

  314.             std::vector<size_t>{3, 2, 5, 1, 0, 4},

  315.             std::vector<size_t>{3, 2, 5, 1, 0, 4},

  316.             std::vector<size_t>{3, 2, 5, 1, 0, 4},

  317.             std::vector<size_t>{5, 4, 3, 2, 1, 0},

  318.             std::vector<size_t>{5, 4, 3, 2, 1, 0},

  319.             std::vector<size_t>{5, 4, 3, 2, 1, 0}};

  320.     run(layouts, permutations);

  321. }

  322. 

  323. TEST_F(CUDA, BENCHMARK_RELAYOUT_7) {

  324.     static constexpr size_t RUNS = 3;

  325. 

  326.     auto isTrivial = [&](std::vector<size_t>& permutation) {

  327.         for (size_t i = 0; i < permutation.size(); i++) {

  328.             if (permutation[i] != i)

  329.                 return false;

  330.         }

  331.         return true;

  332.     };

  333.     auto run = [&](TensorLayout layout, std::vector<size_t> per) {

  334.         Benchmarker<Relayout> benchmarker(handle_cuda());

  335. 

  336.         benchmarker.set_times(RUNS);

  337. 

  338.         TensorLayout src = layout.dimshuffle(per);

  339.         TensorLayout dst = layout;

  340.         std::swap(dst.shape[0], dst.shape[1]);

  341.         dst.init_contiguous_stride();

  342.         auto used = benchmarker.execl({src, dst});

  343.         Checker<Relayout> checker(handle_cuda());

  344.         checker.exec(TensorLayoutArray{src, dst});

  345.         printf("layout: %s bandwith: %f gbps/s\n", layout.to_string().c_str(),

  346.                2 * layout.total_nr_elems() * layout.dtype.size() * RUNS / used *

  347.                        1000 / (1024 * 1024 * 1024));

  348.     };

  349. 

  350.     std::vector<size_t> _dim = {5, 3, 2, 4, 35, 33, 37};

  351.     std::vector<size_t> permutation(7);

  352.     // Inverse

  353.     for (size_t r = 0; r < _dim.size(); r++) {

  354.         size_t size = _dim.size();

  355.         permutation[r] = size - 1 - r;

  356.     }

  357.     run({{_dim[0], _dim[1], _dim[2], _dim[3], _dim[4], _dim[5], _dim[6]},

  358.          dtype::Int32()},

  359.         permutation);

  360.     // Random

  361.     for (size_t r = 0; r < _dim.size(); r++)

  362.         permutation[r] = r;

  363.     for (int nsample = 0; nsample < 50; nsample++) {

  364.         COMPAT_RANDOM(_dim.begin(), _dim.end());

  365.         COMPAT_RANDOM(permutation.begin(), permutation.end());

  366.         if (!isTrivial(permutation)) {

  367.             run({{_dim[0], _dim[1], _dim[2], _dim[3], _dim[4], _dim[5],

  368.                   _dim[6]},

  369.                  dtype::Int32()},

  370.                 permutation);

  371.         }

  372.     }

  373. }

  374. 

  375. TEST_F(CUDA, BENCHMARK_RELAYOUT_5) {

  376.     static constexpr size_t RUNS = 10;

  377. 

  378.     auto isTrivial = [&](std::vector<size_t>& permutation) {

  379.         for (size_t i = 0; i < permutation.size(); i++) {

  380.             if (permutation[i] != i)

  381.                 return false;

  382.         }

  383.         return true;

  384.     };

  385.     auto run = [&](TensorLayout layout, std::vector<size_t> per) {

  386.         CUBenchmarker<Relayout> benchmarker(handle_cuda());

  387. 

  388.         benchmarker.set_times(RUNS);

  389. 

  390.         TensorLayout src = layout.dimshuffle(per);

  391.         TensorLayout dst = layout;

  392.         // std::swap(dst.shape[0], dst.shape[1]);

  393.         dst.init_contiguous_stride();

  394.         auto used = benchmarker.execl({src, dst});

  395.         Checker<Relayout> checker(handle_cuda());

  396.         checker.exec(TensorLayoutArray{src, dst});

  397.         printf("layout: %s bandwith: %f gbps/s\n", layout.to_string().c_str(),

  398.                2 * layout.total_nr_elems() * layout.dtype.size() * RUNS / used *

  399.                        1000 / (1024 * 1024 * 1024));

  400.     };

  401. 

  402.     size_t two = 2;

  403.     int ratio = 5;

  404.     int numElemAvg = 1000000 * 200;

  405.     UniformFloatRNG numElem_dist((double)numElemAvg, (double)numElemAvg*0.2);

  406.     for (int rank = 5; rank <= 5; rank++) {

  407.         for (int iter = 0; iter < 20; iter++) {

  408.             int numElem = (int)numElem_dist.gen_single_val();

  409. 

  410.             std::vector<size_t> dim(rank);

  411.             std::vector<size_t> permutation(rank);

  412.             std::vector<double> dimf(rank);

  413.             double volf = 1.0;

  414.             for (int r = 0; r < rank; r++) {

  415.                 permutation[r] = (size_t)r;

  416.                 dimf[r] = 1.0 + (double)r * (ratio - 1.0) / (double)(rank - 1);

  417.                 volf *= dimf[r];

  418.             }

  419.             // fprintf(stderr, "volf %lf\n", volf);

  420.             double scale = pow((double)numElem / volf, 1.0 / (double)rank);

  421.             // fprintf(stderr, "scale %lf\n", scale);

  422.             int vol = 1;

  423.             for (int r = 0; r < rank; r++) {

  424.                 if (r == rank - 1) {

  425.                     dim[r] = ratio * dim[0];

  426.                 } else {

  427.                     dim[r] = (size_t)round(dimf[r] * scale);

  428.                 }

  429.                 dim[r] = std::max(two, dim[r]);

  430.                 vol *= dim[r];

  431.             }

  432.             // fprintf(stderr, "dim[0] %lf\n", dim[0]);

  433.             double cur_ratio = (double)dim[rank - 1] / (double)dim[0];

  434.             double vol_re = fabs((double)(vol - numElem) / (double)numElem);

  435.             // Fix dimensions if volume is off by more than 5%

  436.             if (vol_re > 0.05) {

  437.                 size_t d = (vol < numElem) ? 1 : -1;

  438.                 int r = 1;

  439.                 while (vol_re > 0.05 && r < rank) {

  440.                     size_t dim_plus_d = std::max(two, dim[r] + d);

  441.                     vol = (vol / dim[r]) * dim_plus_d;

  442.                     dim[r] = dim_plus_d;

  443.                     vol_re = fabs((double)(vol - numElem) / (double)numElem);

  444.                     r++;

  445.                 }

  446.             }

  447.             size_t minDim = *(std::min_element(dim.begin(), dim.end()));

  448.             size_t maxDim = *(std::max_element(dim.begin(), dim.end()));

  449.             cur_ratio = (double)maxDim / (double)minDim;

  450.             printf("vol %d cur_ratio %lf | %lf\n", vol, cur_ratio, vol_re);

  451.             // printVec(dim);

  452. 

  453.             COMPAT_RANDOM(dim.begin(), dim.end());

  454. 

  455.             while (isTrivial(permutation)) {

  456.                 COMPAT_RANDOM(permutation.begin(), permutation.end());

  457.             }

  458. 

  459.             run({{dim[0], dim[1], dim[2], dim[3], dim[4]}, dtype::Int32()},

  460.                 permutation);

  461.             // if (!bench_tensor<T>(dim, permutation)) return false;

  462.         }

  463.     }

  464. }

  465. 

  466. TEST_F(CUDA, BENCHMARK_RELAYOUT_NCHW_NCHW4) {

  467.     static constexpr size_t RUNS = 10;

  468. 

  469.     auto run = [&](TensorLayout layout, std::vector<size_t> per) {

  470.         CUBenchmarker<Relayout> benchmarker(handle_cuda());

  471. 

  472.         benchmarker.set_times(RUNS);

  473. 

  474.         TensorLayout src = layout.dimshuffle(per);

  475.         TensorLayout dst = layout;

  476.         dst.init_contiguous_stride();

  477.         auto used = benchmarker.execl({src, dst});

  478.         Checker<Relayout> checker(handle_cuda());

  479.         checker.exec(TensorLayoutArray{src, dst});

  480. 

  481.         printf("layout: %s bandwith: %f gbps/s\n", layout.to_string().c_str(),

  482.                2 * layout.total_nr_elems() * layout.dtype.size() * RUNS / used *

  483.                        1000 / (1024 * 1024 * 1024));

  484.     };

  485.     UniformIntRNG u(2,100);

  486.     printf("NCHW->NCHW4\n");

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

  488.         int d1 = u.gen_single_val();

  489.         int d2 = (u.gen_single_val() / 4 + 1) * 4;

  490.         int d3 = 4;

  491.         // int d4=(u.gen_single_val()/4+1)*4;

  492.         int d4 = (u.gen_single_val());

  493.         int d5 = (u.gen_single_val());

  494.         // int d5=(u.gen_single_val()/4+1)*4;

  495. 

  496.         // int d5 = (u.gen_single_val())*2+1;

  497.         run({{(size_t)d1, (size_t)d2 / 4, (size_t)d3, (size_t)d4, (size_t)d5},

  498.              {d2 * d3 * d4 * d5 / 4, d3 * d4 * d5, d4 * d5, d5, 1},

  499.              dtype::Int8()},

  500.             {0, 1, 3, 4, 2});

  501.     }

  502.     printf("\n\nNCHW4->NCHW\n");

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

  504.         int d1 = u.gen_single_val();

  505.         int d2 = (u.gen_single_val() / 4 + 1) * 4;

  506.         int d3 = u.gen_single_val();

  507.         // int d5=(u.gen_single_val()/4+1)*4;

  508.         int d4 = u.gen_single_val();

  509.         int d5 = 4;

  510.         run({{(size_t)d1, (size_t)d2 / 4, (size_t)d3, (size_t)d4, (size_t)d5},

  511.              {d2 * d3 * d4 * d5 / 4, d3 * d4 * d5, d4 * d5, d5, 1},

  512.              dtype::Int8()},

  513.             {0, 1, 4, 2, 3});

  514.     }

  515. }

  516. 

  517. TEST_F(CUDA, BENCHMARK_RELAYOUT_NCHW4_NCHW32) {

  518.     static constexpr size_t RUNS = 10;

  519.     auto run = [&](TensorLayout layout, std::vector<size_t> per) {

  520.         CUBenchmarker<Relayout> benchmarker(handle_cuda());

  521. 

  522.         benchmarker.set_times(RUNS);

  523. 

  524.         TensorLayout src = layout.dimshuffle(per);

  525.         TensorLayout dst = layout;

  526.         dst.init_contiguous_stride();

  527.         auto used = benchmarker.execl({src, dst});

  528. 

  529.         Checker<Relayout> checker(handle_cuda());

  530.         checker.exec(TensorLayoutArray{src, dst});

  531. 

  532.         printf("layout: %s bandwith: %f gbps/s\n", layout.to_string().c_str(),

  533.                2 * layout.total_nr_elems() * layout.dtype.size() * RUNS / used *

  534.                        1000 / (1024 * 1024 * 1024));

  535.     };

  536.     UniformIntRNG u(4,50);

  537.     printf("NCHW4 to NCHW32\n");

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

  539.         int d1 = u.gen_single_val();

  540.         int d2 = (u.gen_single_val() / 8 + 1) * 8;

  541.         int d3 = 8;

  542.         int d4 = u.gen_single_val();

  543.         int d5 = u.gen_single_val();

  544.         int d6 = 4;

  545.         run({{(size_t)d1, (size_t)d2 / 8, (size_t)d3, (size_t)d4, (size_t)d5,

  546.               (size_t)d6},

  547.              {d2 * d3 * d4 * d5 * d6 / 8, d3 * d4 * d5 * d6, d4 * d5 * d6,

  548.               d5 * d6, d6, 1},

  549.              dtype::Int8()},

  550.             {0, 1, 3, 4, 2, 5});

  551.     }

  552.     printf("\n\nNCHW32 to NCHW4\n");

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

  554.         int d1 = u.gen_single_val();

  555.         int d2 = (u.gen_single_val() / 8 + 1) * 8;

  556.         int d3 = u.gen_single_val();

  557.         int d4 = u.gen_single_val();

  558.         int d5 = 8;

  559.         int d6 = 4;

  560.         run({{(size_t)d1, (size_t)d2 / 8, (size_t)d3, (size_t)d4, (size_t)d5,

  561.               (size_t)d6},

  562.              {d2 * d3 * d4 * d5 * d6 / 8, d3 * d4 * d5 * d6, d4 * d5 * d6,

  563.               d5 * d6, d6, 1},

  564.              dtype::Int8()},

  565.             {0, 1, 4, 2, 3, 5});

  566.     }

  567. }

  568. 

  569. TEST_F(CUDA, BENCHMARK_LAST_CONTIG_ALIGN_TEST) {

  570.     static constexpr size_t RUNS = 10;

  571. 

  572.     auto run = [&](TensorLayout layout, std::vector<size_t> per) {

  573.         CUBenchmarker<Relayout> benchmarker(handle_cuda());

  574.         benchmarker.set_times(RUNS);

  575. 

  576.         TensorLayout src = layout.dimshuffle(per);

  577.         TensorLayout dst = layout;

  578.         // std::swap(dst.shape[0], dst.shape[1]);

  579.         dst.init_contiguous_stride();

  580.         auto used = benchmarker.execl({src, dst});

  581.         Checker<Relayout> checker(handle_cuda());

  582.         checker.exec(TensorLayoutArray{src, dst});

  583.         printf("layout: %s bandwith: %f gbps/s\n", layout.to_string().c_str(),

  584.                2 * layout.total_nr_elems() * layout.dtype.size() * RUNS / used *

  585.                        1000 / (1024 * 1024 * 1024));

  586.     };

  587.     UniformIntRNG u(4,50);

  588.     std::vector<size_t> _dim(6);

  589.     std::vector<size_t> permutation(_dim.size());

  590.     for (size_t r = 0; r < _dim.size(); r++) {

  591.         size_t size = _dim.size();

  592.         permutation[r] = size - 1 - r;

  593.     }

  594.     _dim[0] = u.gen_single_val();

  595.     _dim[1] = u.gen_single_val();

  596.     _dim[2] = u.gen_single_val();

  597.     _dim[3] = u.gen_single_val();

  598.     _dim[4] = u.gen_single_val();

  599.     _dim[5] = (u.gen_single_val() / 4 + 1) * 4;

  600.     run({{_dim[0], _dim[1], _dim[2], _dim[3], _dim[4], _dim[5]}, dtype::Int8()},

  601.         permutation);

  602.     // Random

  603.     for (size_t r = 0; r < _dim.size(); r++)

  604.         permutation[r] = r;

  605.     for (int nsample = 0; nsample < 20; nsample++) {

  606.         COMPAT_RANDOM(_dim.begin(), _dim.end() - 1);

  607. 

  608.         COMPAT_RANDOM(permutation.begin(), permutation.end() - 1);

  609. 

  610.         if (nsample < 5)

  611.             _dim[5] = (u.gen_single_val() / 4 + 1) * 4;

  612.         else

  613.             _dim[5] = u.gen_single_val();

  614. 

  615.         run({{_dim[0], _dim[1], _dim[2], _dim[3], _dim[4], _dim[5]},

  616.              dtype::Int8()},

  617.             permutation);

  618.     }

  619. }

  620. #endif

  621. 

  622. TEST_F(CUDA, RELAYOUT) {

  623.     struct Arg {

  624.         TensorLayout src, dst;

  625.         Arg(TensorLayout src, TensorLayout dst) : src(src), dst(dst) {}

  626.     };

  627.     std::vector<Arg> args;

  628.     {

  629.         // contiguous stride

  630.         args.emplace_back(TensorLayout({4, 3, 2}, {2, 8, 1}, dtype::Float16()),

  631.                           TensorLayout({4, 3, 2}, {6, 2, 1}, dtype::Float16()));

  632.         args.emplace_back(TensorLayout({4, 3, 2}, {6, 2, 1}, dtype::Float16()),

  633.                           TensorLayout({4, 3, 2}, {2, 8, 1}, dtype::Float16()));

  634.         args.emplace_back(

  635.                 TensorLayout({2, 4, 3, 5}, {60, 5, 20, 1}, dtype::Float16()),

  636.                 TensorLayout({2, 4, 3, 5}, {60, 15, 5, 1}, dtype::Float16()));

  637.     }

  638.     args.emplace_back(

  639.             TensorLayout({2, 3, 4, 5}, {60, 20, 5, 1}, dtype::Float16()),

  640.             TensorLayout({2, 3, 4, 5}, {120, 40, 10, 2}, dtype::Float16()));

  641.     args.emplace_back(

  642.             TensorLayout({2, 3, 4, 5}, {120, 40, 10, 2}, dtype::Float16()),

  643.             TensorLayout({2, 3, 4, 5}, {60, 20, 5, 1}, dtype::Float16()));

  644.     args.emplace_back(

  645.             TensorLayout({2, 3, 4, 5}, {120, 40, 10, 2}, dtype::Float16()),

  646.             TensorLayout({2, 3, 4, 5}, {180, 60, 15, 3}, dtype::Float16()));

  647.     args.emplace_back(

  648.             TensorLayout({2, 3, 4, 5}, {60, 20, 5, 1}, dtype::Int32()),

  649.             TensorLayout({2, 3, 4, 5}, {120, 40, 10, 2}, dtype::Int32()));

  650.     args.emplace_back(

  651.             TensorLayout({2, 3, 4, 5}, {120, 40, 10, 2}, dtype::Int32()),

  652.             TensorLayout({2, 3, 4, 5}, {60, 20, 5, 1}, dtype::Int32()));

  653.     args.emplace_back(

  654.             TensorLayout({2, 3, 4, 5}, {120, 40, 10, 2}, dtype::Int32()),

  655.             TensorLayout({2, 3, 4, 5}, {180, 60, 15, 3}, dtype::Int32()));

  656.     args.emplace_back(

  657.             TensorLayout({16, 128, 128}, {49152, 384, 3}, dtype::Float32()),

  658.             TensorLayout({16, 128, 128}, {16384, 128, 1}, dtype::Float32()));

  659. 

  660.     {

  661.         // 1d

  662.         size_t n = 10000;

  663.         args.emplace_back(TensorLayout({n}, {1}, dtype::Int32()),

  664.                           TensorLayout({n}, {1}, dtype::Int32()));

  665.         args.emplace_back(TensorLayout({n}, {1}, dtype::Int32()),

  666.                           TensorLayout({n}, {2}, dtype::Int32()));

  667.         args.emplace_back(TensorLayout({n}, {2}, dtype::Int32()),

  668.                           TensorLayout({n}, {1}, dtype::Int32()));

  669.         args.emplace_back(TensorLayout({n}, {2}, dtype::Int32()),

  670.                           TensorLayout({n}, {2}, dtype::Int32()));

  671.     }

  672.     {

  673.         // 2d

  674.         size_t m = 200, n = 300, k = 400;

  675.         ptrdiff_t k2 = k * 2;

  676.         args.emplace_back(TensorLayout({m, n}, {k2, 2}, dtype::Int32()),

  677.                           TensorLayout({m, n}, {k2 + 1, 2}, dtype::Int32()));

  678.         args.emplace_back(TensorLayout({m, n}, {2, k2}, dtype::Int32()),

  679.                           TensorLayout({m, n}, {2, k2 + 1}, dtype::Int32()));

  680.         args.emplace_back(TensorLayout({m, n}, {2, k2}, dtype::Int32()),

  681.                           TensorLayout({m, n}, {k2 + 1, 2}, dtype::Int32()));

  682.         args.emplace_back(TensorLayout({m, n}, {k2, 2}, dtype::Int32()),

  683.                           TensorLayout({m, n}, {2, k2 + 1}, dtype::Int32()));

  684.         args.emplace_back(TensorLayout({m, n}, {k2, 1}, dtype::Int32()),

  685.                           TensorLayout({m, n}, {k2 + 1, 1}, dtype::Int32()));

  686.         args.emplace_back(TensorLayout({m, n}, {1, k2}, dtype::Int32()),

  687.                           TensorLayout({m, n}, {1, k2 + 1}, dtype::Int32()));

  688.         args.emplace_back(TensorLayout({m, n}, {1, k2}, dtype::Int32()),

  689.                           TensorLayout({m, n}, {k2 + 1, 1}, dtype::Int32()));

  690.         args.emplace_back(TensorLayout({m, n}, {k2, 1}, dtype::Int32()),

  691.                           TensorLayout({m, n}, {1, k2 + 1}, dtype::Int32()));

  692.     }

  693.     {

  694.         // 3d

  695.         size_t m = 20, n = 30, k = 40;

  696.         ptrdiff_t k2 = k;

  697.         args.emplace_back(

  698.                 TensorLayout({m, n, k}, {k2 * k2 * 4, k2 * 3, 2},

  699.                              dtype::Int32()),

  700.                 TensorLayout({m, n, k}, {2 * k2 * k2 * k2 * 4, k2 * 3, 2},

  701.                              dtype::Int32()));

  702.     }

  703.     {

  704.         // simplify_layout

  705.         // 234..56

  706.         // 2..3456

  707.         args.emplace_back(

  708.                 TensorLayout(

  709.                         {2, 3, 4, 5, 6},

  710.                         {2 * 3 * 4 * 5 * 6, 2 * 4 * 5 * 6, 2 * 5 * 6, 6, 1},

  711.                         dtype::Int32()),

  712.                 TensorLayout({2, 3, 4, 5, 6},

  713.                              {4 * 3 * 4 * 5 * 6, 4 * 5 * 6, 5 * 6, 6, 1},

  714.                              dtype::Int32()));

  715.     }

  716. 

  717.     Checker<Relayout> checker(handle_cuda());

  718.     for (auto&& arg : args) {

  719.         checker.exec(TensorLayoutArray{arg.src, arg.dst});

  720.     }

  721. }

  722. 

  723. TEST_F(CUDA, TRANSPOSE_INT8) {

  724.     auto run = [&](TensorLayout layout, std::vector<size_t> per) {

  725.         TensorLayout src = layout.dimshuffle(per);

  726.         TensorLayout dst = layout;

  727.         dst.init_contiguous_stride();

  728. 

  729.         Checker<Relayout> checker(handle_cuda());

  730.         checker.exec(TensorLayoutArray{src, dst});

  731.     };

  732.     //! for last contig(NCHW4<->NCHW32)

  733.     run({{5, 8, 4, 3, 8}, dtype::Int8()}, {1, 3, 0, 2, 4});

  734.     run({{5, 8, 4, 3, 5}, dtype::Int8()}, {1, 3, 0, 2, 4});

  735.     run({{5, 8, 4, 3, 64}, dtype::Int8()}, {1, 3, 0, 2, 4});

  736.     //! for last no contig(NCHW->NCHW4)

  737.     run({{7, 4, 32}, dtype::Int8()}, {2, 0, 1});

  738.     run({{7, 4, 64}, dtype::Int8()}, {2, 0, 1});

  739.     run({{7, 4, 7}, dtype::Int8()}, {2, 0, 1});

  740.     //! for copy

  741.     run({{2, 3, 4, 5, 6},

  742.          {2 * 3 * 4 * 5 * 6, 2 * 4 * 5 * 6, 2 * 5 * 6, 6, 1},

  743.          dtype::Int8()},

  744.         {0, 1, 2, 3, 4});

  745. }

  746. 

  747. TEST_F(CUDA, RELAYOUT_INT8) {

  748.     struct Arg {

  749.         TensorLayout src, dst;

  750.         Arg(TensorLayout src, TensorLayout dst) : src(src), dst(dst) {}

  751.     };

  752.     std::vector<Arg> args;

  753.     {

  754.         // contiguous stride

  755.         args.emplace_back(TensorLayout({4, 3, 2}, {2, 8, 1}, dtype::Int8()),

  756.                           TensorLayout({4, 3, 2}, {6, 2, 1}, dtype::Int8()));

  757.         args.emplace_back(TensorLayout({4, 3, 2}, {6, 2, 1}, dtype::Int8()),

  758.                           TensorLayout({4, 3, 2}, {2, 8, 1}, dtype::Int8()));

  759.         args.emplace_back(

  760.                 TensorLayout({2, 4, 3, 5}, {60, 5, 20, 1}, dtype::Int8()),

  761.                 TensorLayout({2, 4, 3, 5}, {60, 15, 5, 1}, dtype::Int8()));

  762.     }

  763.     args.emplace_back(

  764.             TensorLayout({2, 3, 4, 5}, {60, 20, 5, 1}, dtype::Int8()),

  765.             TensorLayout({2, 3, 4, 5}, {120, 40, 10, 2}, dtype::Int8()));

  766.     args.emplace_back(

  767.             TensorLayout({2, 3, 4, 5}, {120, 40, 10, 2}, dtype::Int8()),

  768.             TensorLayout({2, 3, 4, 5}, {60, 20, 5, 1}, dtype::Int8()));

  769.     args.emplace_back(

  770.             TensorLayout({2, 3, 4, 5}, {120, 40, 10, 2}, dtype::Int8()),

  771.             TensorLayout({2, 3, 4, 5}, {180, 60, 15, 3}, dtype::Int8()));

  772.     args.emplace_back(

  773.             TensorLayout({2, 3, 4, 5}, {60, 20, 5, 1}, dtype::Int8()),

  774.             TensorLayout({2, 3, 4, 5}, {120, 40, 10, 2}, dtype::Int8()));

  775.     args.emplace_back(

  776.             TensorLayout({2, 3, 4, 5}, {120, 40, 10, 2}, dtype::Int8()),

  777.             TensorLayout({2, 3, 4, 5}, {60, 20, 5, 1}, dtype::Int8()));

  778.     args.emplace_back(

  779.             TensorLayout({2, 3, 4, 5}, {120, 40, 10, 2}, dtype::Int8()),

  780.             TensorLayout({2, 3, 4, 5}, {180, 60, 15, 3}, dtype::Int8()));

  781.     args.emplace_back(

  782.             TensorLayout({16, 128, 128}, {49152, 384, 3}, dtype::Int8()),

  783.             TensorLayout({16, 128, 128}, {16384, 128, 1}, dtype::Int8()));

  784. 

  785.     {

  786.         // 1d

  787.         size_t n = 10000;

  788.         args.emplace_back(TensorLayout({n}, {1}, dtype::Int8()),

  789.                           TensorLayout({n}, {1}, dtype::Int8()));

  790.         args.emplace_back(TensorLayout({n}, {1}, dtype::Int8()),

  791.                           TensorLayout({n}, {2}, dtype::Int8()));

  792.         args.emplace_back(TensorLayout({n}, {2}, dtype::Int8()),

  793.                           TensorLayout({n}, {1}, dtype::Int8()));

  794.         args.emplace_back(TensorLayout({n}, {2}, dtype::Int8()),

  795.                           TensorLayout({n}, {2}, dtype::Int8()));

  796.     }

  797.     {

  798.         // 2d

  799.         size_t m = 200, n = 300, k = 400;

  800.         ptrdiff_t k2 = k * 2;

  801.         args.emplace_back(TensorLayout({m, n}, {k2, 2}, dtype::Int8()),

  802.                           TensorLayout({m, n}, {k2 + 1, 2}, dtype::Int8()));

  803.         args.emplace_back(TensorLayout({m, n}, {2, k2}, dtype::Int8()),

  804.                           TensorLayout({m, n}, {2, k2 + 1}, dtype::Int8()));

  805.         args.emplace_back(TensorLayout({m, n}, {2, k2}, dtype::Int8()),

  806.                           TensorLayout({m, n}, {k2 + 1, 2}, dtype::Int8()));

  807.         args.emplace_back(TensorLayout({m, n}, {k2, 2}, dtype::Int8()),

  808.                           TensorLayout({m, n}, {2, k2 + 1}, dtype::Int8()));

  809.         args.emplace_back(TensorLayout({m, n}, {k2, 1}, dtype::Int8()),

  810.                           TensorLayout({m, n}, {k2 + 1, 1}, dtype::Int8()));

  811.         args.emplace_back(TensorLayout({m, n}, {1, k2}, dtype::Int8()),

  812.                           TensorLayout({m, n}, {1, k2 + 1}, dtype::Int8()));

  813.         args.emplace_back(TensorLayout({m, n}, {1, k2}, dtype::Int8()),

  814.                           TensorLayout({m, n}, {k2 + 1, 1}, dtype::Int8()));

  815.         args.emplace_back(TensorLayout({m, n}, {k2, 1}, dtype::Int8()),

  816.                           TensorLayout({m, n}, {1, k2 + 1}, dtype::Int8()));

  817.     }

  818.     {

  819.         // 3d

  820.         size_t m = 20, n = 30, k = 40;

  821.         ptrdiff_t k2 = k;

  822.         args.emplace_back(

  823.                 TensorLayout({m, n, k}, {k2 * k2 * 4, k2 * 3, 2},

  824.                              dtype::Int8()),

  825.                 TensorLayout({m, n, k}, {2 * k2 * k2 * k2 * 4, k2 * 3, 2},

  826.                              dtype::Int8()));

  827.     }

  828.     {

  829.         // simplify_layout

  830.         // 234..56

  831.         // 2..3456

  832.         args.emplace_back(

  833.                 TensorLayout(

  834.                         {2, 3, 4, 5, 6},

  835.                         {2 * 3 * 4 * 5 * 6, 2 * 4 * 5 * 6, 2 * 5 * 6, 6, 1},

  836.                         dtype::Int8()),

  837.                 TensorLayout({2, 3, 4, 5, 6},

  838.                              {4 * 3 * 4 * 5 * 6, 4 * 5 * 6, 5 * 6, 6, 1},

  839.                              dtype::Int8()));

  840. 

  841.         args.emplace_back(

  842.                 TensorLayout(

  843.                         {2, 3, 4, 5, 6},

  844.                         {4 * 3 * 4 * 5 * 6, 4 * 4 * 5 * 6, 2 * 5 * 6, 6, 1},

  845.                         dtype::Int8()),

  846.                 TensorLayout({2, 3, 4, 5, 6},

  847.                              {4 * 3 * 4 * 5 * 6, 4 * 5 * 6, 5 * 6, 6, 1},

  848.                              dtype::Int8()));

  849.     }

  850. 

  851.     Checker<Relayout> checker(handle_cuda());

  852.     for (auto&& arg : args) {

  853.         checker.exec(TensorLayoutArray{arg.src, arg.dst});

  854.     }

  855. }

  856. 

  857. TEST_F(CUDA, RELAYOUT_TEST) {

  858.     struct Arg {

  859.         TensorLayout src, dst;

  860.         Arg(TensorLayout src, TensorLayout dst) : src(src), dst(dst) {}

  861.     };

  862.     std::vector<Arg> args;

  863.     //! dst contig

  864.     args.emplace_back(TensorLayout({5, 32, 9}, {288, 1, 32}, dtype::Int8()),

  865.                       TensorLayout({5, 9, 32}, {288, 32, 1}, dtype::Int8()));

  866.     args.emplace_back(TensorLayout({5, 9, 32}, {288, 1, 9}, dtype::Int8()),

  867.                       TensorLayout({5, 32, 9}, {288, 9, 1}, dtype::Int8()));

  868. 

  869.     args.emplace_back(TensorLayout({5, 4, 9}, {36, 1, 4}, dtype::Int8()),

  870.                       TensorLayout({5, 9, 4}, {36, 4, 1}, dtype::Int8()));

  871.     args.emplace_back(TensorLayout({5, 9, 4}, {36, 1, 9}, dtype::Int8()),

  872.                       TensorLayout({5, 4, 9}, {36, 9, 1}, dtype::Int8()));

  873. 

  874.     args.emplace_back(TensorLayout({5, 32, 4}, {128, 1, 32}, dtype::Int8()),

  875.                       TensorLayout({5, 4, 32}, {128, 32, 1}, dtype::Int8()));

  876.     args.emplace_back(TensorLayout({5, 4, 32}, {128, 1, 4}, dtype::Int8()),

  877.                       TensorLayout({5, 32, 4}, {128, 4, 1}, dtype::Int8()));

  878. 

  879.     args.emplace_back(TensorLayout({5, 7, 5}, {35, 1, 7}, dtype::Int8()),

  880.                       TensorLayout({5, 5, 7}, {35, 7, 1}, dtype::Int8()));

  881.     args.emplace_back(TensorLayout({5, 5, 7}, {35, 1, 5}, dtype::Int8()),

  882.                       TensorLayout({5, 7, 5}, {35, 5, 1}, dtype::Int8()));

  883.     //! src contig

  884.     args.emplace_back(TensorLayout({5, 9, 32}, {288, 32, 1}, dtype::Int8()),

  885.                       TensorLayout({5, 32, 9}, {288, 1, 32}, dtype::Int8()));

  886.     args.emplace_back(TensorLayout({5, 32, 9}, {288, 9, 1}, dtype::Int8()),

  887.                       TensorLayout({5, 9, 32}, {288, 1, 9}, dtype::Int8()));

  888. 

  889.     args.emplace_back(TensorLayout({5, 9, 4}, {36, 4, 1}, dtype::Int8()),

  890.                       TensorLayout({5, 4, 9}, {36, 1, 4}, dtype::Int8()));

  891.     args.emplace_back(TensorLayout({5, 4, 9}, {36, 9, 1}, dtype::Int8()),

  892.                       TensorLayout({5, 9, 4}, {36, 1, 9}, dtype::Int8()));

  893. 

  894.     args.emplace_back(TensorLayout({5, 4, 32}, {128, 32, 1}, dtype::Int8()),

  895.                       TensorLayout({5, 32, 4}, {128, 1, 32}, dtype::Int8()));

  896.     args.emplace_back(TensorLayout({5, 32, 4}, {128, 4, 1}, dtype::Int8()),

  897.                       TensorLayout({5, 4, 32}, {128, 1, 4}, dtype::Int8()));

  898. 

  899.     args.emplace_back(TensorLayout({5, 5, 7}, {35, 7, 1}, dtype::Int8()),

  900.                       TensorLayout({5, 7, 5}, {35, 1, 7}, dtype::Int8()));

  901.     args.emplace_back(TensorLayout({5, 7, 5}, {35, 5, 1}, dtype::Int8()),

  902.                       TensorLayout({5, 5, 7}, {35, 1, 5}, dtype::Int8()));

  903.     //! cross

  904.     args.emplace_back(

  905.             TensorLayout({5, 9, 32}, {288 * 4, 32 * 3, 1}, dtype::Int8()),

  906.             TensorLayout({5, 32, 9}, {288 * 4, 1, 32 * 3}, dtype::Int8()));

  907.     args.emplace_back(

  908.             TensorLayout({5, 32, 9}, {288 * 3, 9 * 2, 1}, dtype::Int8()),

  909.             TensorLayout({5, 9, 32}, {288 * 3, 1, 9 * 2}, dtype::Int8()));

  910. 

  911.     args.emplace_back(

  912.             TensorLayout({5, 9, 4}, {36 * 10, 4 * 7, 1}, dtype::Int8()),

  913.             TensorLayout({5, 4, 9}, {36 * 10, 1, 4 * 7}, dtype::Int8()));

  914. 

  915.     Checker<Relayout> checker(handle_cuda());

  916.     for (auto&& arg : args) {

  917.         checker.exec(TensorLayoutArray{arg.src, arg.dst});

  918.     }

  919. }

  920. // vim: syntax=cpp.doxygen