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

244 lines
8.7 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/test/cuda/padding.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

  10.  * implied.

  11.  */

  12. 

  13. #include "test/common/padding.h"

  14. #include "megdnn/oprs.h"

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

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

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

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

  19. 

  20. using namespace megdnn;

  21. using namespace test;

  22. 

  23. TEST_F(CUDA, PADDING) {

  24.     std::vector<padding::TestArg> args = padding::get_args();

  25.     Checker<Padding> checker(handle_cuda());

  26.     UniformIntNonZeroRNG rng(1, 9);

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

  28.         checker.set_param(arg.param)

  29.                 .set_rng(0, &rng)

  30.                 .set_dtype(0, dtype::Int8())

  31.                 .set_dtype(1, dtype::Int8())

  32.                 .execs({arg.src, arg.dst});

  33.     }

  34. }

  35. 

  36. TEST_F(CUDA, PADDING_BACKWARD) {

  37.     std::vector<padding::TestArg> args = padding::get_args_backward();

  38.     Checker<PaddingBackward> checker(handle_cuda());

  39.     UniformFloatRNG rng(1, 9);

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

  41.         checker.set_param(arg.param)

  42.                 .set_rng(0, &rng)

  43.                 .set_dtype(0, dtype::Float32())

  44.                 .set_dtype(1, dtype::Float32())

  45.                 .execs({arg.src, arg.dst});

  46.     }

  47. }

  48. 

  49. TEST_F(CUDA, PADDING_REFLECT) {

  50.     Checker<Padding> checker(handle_cuda(), false);

  51.     param::Padding param;

  52.     param.padding_val = 10;

  53.     param.padding_mode = param::Padding::PaddingMode::REFLECT;

  54.     param.front_offset_dim0 = 2;

  55.     param.front_offset_dim1 = 0;

  56.     param.front_offset_dim2 = 0;

  57.     param.front_offset_dim3 = 0;

  58.     param.front_offset_dim4 = 0;

  59.     param.front_offset_dim5 = 0;

  60.     param.front_offset_dim6 = 0;

  61.     param.back_offset_dim0 = 3;

  62.     param.back_offset_dim1 = 0;

  63.     param.back_offset_dim2 = 0;

  64.     param.back_offset_dim3 = 0;

  65.     param.back_offset_dim4 = 0;

  66.     param.back_offset_dim5 = 0;

  67.     param.back_offset_dim6 = 0;

  68.     checker.set_param(param).exect(

  69.             Testcase{TensorValue({5}, dtype::Int8(), {1, 2, 3, 4, 5}), {}},

  70.             Testcase{

  71.                     {},

  72.                     TensorValue({10}, dtype::Int8(), {3, 2, 1, 2, 3, 4, 5, 4, 3, 2})});

  73. }

  74. 

  75. TEST_F(CUDA, PADDING_REFLECT2) {

  76.     Checker<Padding> checker(handle_cuda(), false);

  77.     param::Padding param;

  78.     param.padding_val = 10;

  79.     param.padding_mode = param::Padding::PaddingMode::REFLECT;

  80.     param.front_offset_dim0 = 1;

  81.     param.front_offset_dim1 = 2;

  82.     param.front_offset_dim2 = 0;

  83.     param.front_offset_dim3 = 0;

  84.     param.front_offset_dim4 = 0;

  85.     param.front_offset_dim5 = 0;

  86.     param.front_offset_dim6 = 0;

  87.     param.back_offset_dim0 = 1;

  88.     param.back_offset_dim1 = 2;

  89.     param.back_offset_dim2 = 0;

  90.     param.back_offset_dim3 = 0;

  91.     param.back_offset_dim4 = 0;

  92.     param.back_offset_dim5 = 0;

  93.     param.back_offset_dim6 = 0;

  94.     checker.set_param(param).exect(

  95.             Testcase{

  96.                     TensorValue({3, 3}, dtype::Int8(), {3, 5, 1, 3, 6, 1, 4, 7, 9}),

  97.                     {}},

  98.             Testcase{{}, TensorValue({5, 7}, dtype::Int8(), {1, 6, 3, 6, 1, 6, 3, 1, 5,

  99.                                                              3, 5, 1, 5, 3, 1, 6, 3, 6,

  100.                                                              1, 6, 3, 9, 7, 4, 7, 9, 7,

  101.                                                              4, 1, 6, 3, 6, 1, 6, 3})});

  102. }

  103. 

  104. TEST_F(CUDA, PADDING_REFLECT2_QUANTIZED) {

  105.     Checker<Padding> checker(handle_cuda(), false);

  106.     param::Padding param;

  107.     param.padding_mode = param::Padding::PaddingMode::REFLECT;

  108.     param.front_offset_dim0 = 2;

  109.     param.front_offset_dim1 = 1;

  110.     param.front_offset_dim2 = 0;

  111.     param.front_offset_dim3 = 0;

  112.     param.front_offset_dim4 = 0;

  113.     param.front_offset_dim5 = 0;

  114.     param.front_offset_dim6 = 0;

  115.     param.back_offset_dim0 = 0;

  116.     param.back_offset_dim1 = 2;

  117.     param.back_offset_dim2 = 0;

  118.     param.back_offset_dim3 = 0;

  119.     param.back_offset_dim4 = 0;

  120.     param.back_offset_dim5 = 0;

  121.     param.back_offset_dim6 = 0;

  122.     checker.set_param(param).exect(

  123.             Testcase{

  124.                     TensorValue(

  125.                             {3, 3}, dtype::QuantizedS8(), {1, 2, 3, 4, 5, 6, 7, 8, 9}),

  126.                     {}},

  127.             Testcase{{}, TensorValue({5, 6}, dtype::QuantizedS8(), {8, 7, 8, 9, 8, 7, 5,

  128.                                                                     4, 5, 6, 5, 4, 2, 1,

  129.                                                                     2, 3, 2, 1, 5, 4, 5,

  130.                                                                     6, 5, 4, 8, 7, 8, 9,

  131.                                                                     8, 7})});

  132. }

  133. 

  134. TEST_F(CUDA, PADDING_REPLICATE) {

  135.     Checker<Padding> checker(handle_cuda(), false);

  136.     param::Padding param;

  137.     param.padding_val = 10;

  138.     param.padding_mode = param::Padding::PaddingMode::REPLICATE;

  139.     param.front_offset_dim0 = 1;

  140.     param.front_offset_dim1 = 0;

  141.     param.front_offset_dim2 = 0;

  142.     param.front_offset_dim3 = 0;

  143.     param.front_offset_dim4 = 0;

  144.     param.front_offset_dim5 = 0;

  145.     param.front_offset_dim6 = 0;

  146.     param.back_offset_dim0 = 2;

  147.     param.back_offset_dim1 = 0;

  148.     param.back_offset_dim2 = 0;

  149.     param.back_offset_dim3 = 0;

  150.     param.back_offset_dim4 = 0;

  151.     param.back_offset_dim5 = 0;

  152.     param.back_offset_dim6 = 0;

  153.     checker.set_param(param).exect(

  154.             Testcase{TensorValue({9}, dtype::Int8(), {1, 2, 3, 4, 5, 6, 7, 8, 9}), {}},

  155.             Testcase{

  156.                     {},

  157.                     TensorValue(

  158.                             {12}, dtype::Int8(),

  159.                             {1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 9})});

  160. }

  161. 

  162. TEST_F(CUDA, PADDING_REPLICATE2) {

  163.     Checker<Padding> checker(handle_cuda(), false);

  164.     param::Padding param;

  165.     param.padding_val = 10;

  166.     param.padding_mode = param::Padding::PaddingMode::REPLICATE;

  167.     param.front_offset_dim0 = 2;

  168.     param.front_offset_dim1 = 1;

  169.     param.front_offset_dim2 = 0;

  170.     param.front_offset_dim3 = 0;

  171.     param.front_offset_dim4 = 0;

  172.     param.front_offset_dim5 = 0;

  173.     param.front_offset_dim6 = 0;

  174.     param.back_offset_dim0 = 0;

  175.     param.back_offset_dim1 = 3;

  176.     param.back_offset_dim2 = 0;

  177.     param.back_offset_dim3 = 0;

  178.     param.back_offset_dim4 = 0;

  179.     param.back_offset_dim5 = 0;

  180.     param.back_offset_dim6 = 0;

  181.     checker.set_param(param).exect(

  182.             Testcase{

  183.                     TensorValue({3, 3}, dtype::Int8(), {1, 2, 3, 4, 5, 6, 7, 8, 9}),

  184.                     {}},

  185.             Testcase{{}, TensorValue({5, 7}, dtype::Int8(), {1, 1, 2, 3, 3, 3, 3, 1, 1,

  186.                                                              2, 3, 3, 3, 3, 1, 1, 2, 3,

  187.                                                              3, 3, 3, 4, 4, 5, 6, 6, 6,

  188.                                                              6, 7, 7, 8, 9, 9, 9, 9})});

  189. }

  190. 

  191. // #if MEGDNN_WITH_BENCHMARK

  192. 

  193. TEST_F(CUDA, BENCHMARK_PADDING_CONSTANT) {

  194.     using Param = Padding::Param;

  195. 

  196.     auto run = [&](const TensorShapeArray& shapes, Param param) {

  197.         CUBenchmarker<PaddingForward> benchmarker(handle_cuda());

  198.         benchmarker.set_param(param);

  199.         benchmarker.set_dtype(0, dtype::Int8()).set_dtype(1, dtype::Int8());

  200. 

  201.         for (auto&& shape : shapes) {

  202.             double memaccess =

  203.                     double(TensorLayout(shape, dtype::Int8()).span().dist_byte()) *

  204.                     2e-6;

  205.             auto time_ms = benchmarker.execs({shape, {}});

  206.             printf("execute %s, time %.4f ms, %.4f GB/s\n", shape.to_string().c_str(),

  207.                    time_ms, memaccess / time_ms);

  208.         }

  209.     };

  210. 

  211.     printf("mode -> constant; dtype -> int8\n");

  212.     {

  213.         TensorShapeArray shapes = {

  214.                 {16, 3, 736, 1280},

  215.         };

  216.         Param param;

  217.         param.padding_mode = param::Padding::PaddingMode::CONSTANT;

  218.         param.front_offset_dim1 = 1;

  219.         run(shapes, param);

  220.     }

  221. 

  222.     printf("mode -> replicate; dtype -> int8\n");

  223.     {

  224.         TensorShapeArray shapes = {

  225.                 {16, 3, 736, 1280},

  226.         };

  227.         Param param;

  228.         param.padding_mode = param::Padding::PaddingMode::REPLICATE;

  229.         param.front_offset_dim1 = 1;

  230.         run(shapes, param);

  231.     }

  232.     printf("mode -> reflect; dtype -> int8\n");

  233.     {

  234.         TensorShapeArray shapes = {

  235.                 {16, 3, 736, 1280},

  236.         };

  237.         Param param;

  238.         param.padding_mode = param::Padding::PaddingMode::REFLECT;

  239.         param.front_offset_dim1 = 1;

  240.         run(shapes, param);

  241.     }

  242. }

  243. 

  244. // #endif