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

1138 lines
45 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/test/cuda/local_share.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 "megdnn/oprs/nn.h"

  13. 

  14. #include "src/common/utils.h"

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

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

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

  18. #include "test/common/workspace_wrapper.h"

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

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

  21. #include "test/cuda/utils.h"

  22. 

  23. using namespace megdnn;

  24. using namespace test;

  25. 

  26. namespace {

  27. struct LocalShareArgs {

  28.     size_t b, c, f, p, s, h, w, sg;

  29. };

  30. 

  31. std::vector<LocalShareArgs> get_local_share_conv_1x1_args_lar_bs() {

  32.     std::vector<LocalShareArgs> ret;

  33.     // clang-format off

  34.     for (size_t b : {32, 64}) {

  35.     for (size_t c : {32, 16, 8}) {

  36.     for (size_t f : {1}) {

  37.     for (int p : {0}) {

  38.     for (size_t s : {1, 2}) {

  39.     for (size_t h : {8, 16}) {

  40.     for (size_t w : {2, 3, 4, 5, 6, 7, 8, 9, 10, 16, 24, 32, 33}) {

  41.     for (size_t sg : {3, 2}) {

  42.         size_t ho = infer_conv_shape(h, f, s, p);

  43.         size_t wo = infer_conv_shape(w, f, s, p);

  44.         if (ho % sg != 0 || wo % sg != 0)

  45.             continue;

  46.         ret.emplace_back(LocalShareArgs{b, c, f, static_cast<size_t>(p),

  47.                                         s, h, w, sg});

  48.     } } } } } } } }

  49.     // clang-format on

  50.     return ret;

  51. }

  52. 

  53. std::vector<LocalShareArgs> get_local_share_conv_3x3_args_lar_bs() {

  54.     std::vector<LocalShareArgs> ret;

  55.     // clang-format off

  56.     for (size_t b : {32, 64}) {

  57.     for (size_t c : {32, 16, 8}) {

  58.     for (size_t f : {3}) {

  59.     for (int p : {static_cast<int>(f / 2), 0}) {

  60.     for (size_t s : {1, 2}) {

  61.     for (size_t h : {8, 16}) {

  62.     for (size_t w : {3, 4, 5, 6, 7, 8, 9, 10, 16, 24, 32, 33}) {

  63.     for (size_t sg : {3, 2}) {

  64.         size_t ho = infer_conv_shape(h, f, s, p);

  65.         size_t wo = infer_conv_shape(w, f, s, p);

  66.         if (ho % sg != 0 || wo % sg != 0)

  67.             continue;

  68.         ret.emplace_back(LocalShareArgs{b, c, f, static_cast<size_t>(p),

  69.                                         s, h, w, sg});

  70.     } } } } } } } }

  71.     // clang-format on

  72.     return ret;

  73. }

  74. 

  75. std::vector<LocalShareArgs> get_local_share_conv_5x5_args_lar_bs() {

  76.     std::vector<LocalShareArgs> ret;

  77.     // clang-format off

  78.     for (size_t b : {32, 64}) {

  79.     for (size_t c : {32, 16, 8}) {

  80.     for (size_t f : {5}) {

  81.     for (int p : {static_cast<int>(f / 2), 0}) {

  82.     for (size_t s : {1, 2}) {

  83.     for (size_t h : {8, 16}) {

  84.     for (size_t w : {8, 9, 10, 16, 24, 32, 33}) {

  85.     for (size_t sg : {3, 2}) {

  86.         size_t ho = infer_conv_shape(h, f, s, p);

  87.         size_t wo = infer_conv_shape(w, f, s, p);

  88.         if (ho % sg != 0 || wo % sg != 0)

  89.             continue;

  90.         ret.emplace_back(LocalShareArgs{b, c, f, static_cast<size_t>(p), s,

  91.                                         h, w, sg});

  92.     } } } } } } } }

  93.     // clang-format on

  94.     return ret;

  95. }

  96. 

  97. std::vector<LocalShareArgs> get_local_share_conv_7x7_args_lar_bs() {

  98.     std::vector<LocalShareArgs> ret;

  99.     // clang-format off

  100.     for (size_t b : {32, 64}) {

  101.     for (size_t c : {32, 16, 8}) {

  102.     for (size_t f : {7}) {

  103.     for (int p : {static_cast<int>(f / 2), 0}) {

  104.     for (size_t s : {1, 2}) {

  105.     for (size_t h : {8, 16}) {

  106.     for (size_t w : {8, 9, 10, 16, 24, 32, 33}) {

  107.     for (size_t sg : {3, 2}) {

  108.         size_t ho = infer_conv_shape(h, f, s, p);

  109.         size_t wo = infer_conv_shape(w, f, s, p);

  110.         if (ho % sg != 0 || wo % sg != 0)

  111.             continue;

  112.         ret.emplace_back(LocalShareArgs{b, c, f, static_cast<size_t>(p), s,

  113.                                         h, w, sg});

  114.     } } } } } } } }

  115.     // clang-format on

  116.     return ret;

  117. }

  118. 

  119. std::vector<LocalShareArgs> get_local_share_conv_small_image(size_t kernel_size) {

  120.     size_t f = kernel_size;

  121.     std::vector<LocalShareArgs> ret;

  122.     // clang-format off

  123.     for (size_t b : {8, 16, 32, 48, 64}) {

  124.     for (size_t c : {8, 16, 32, 48, 64, 96, 128}) {

  125.     for (int p : {static_cast<int>(f / 2), 0}) {

  126.     for (size_t s : {1, 2}) {

  127.     for (size_t h : {12}) {

  128.     for (size_t w : {12}) {

  129.     for (size_t sg : {3, 2}) {

  130.         size_t ho = infer_conv_shape(h, f, s, p);

  131.         size_t wo = infer_conv_shape(w, f, s, p);

  132.         if (ho % sg != 0 || wo % sg != 0)

  133.             continue;

  134.         ret.emplace_back(LocalShareArgs{b, c, f, static_cast<size_t>(p), s,

  135.                                         h, w, sg});

  136.     } } } } } } }

  137.     // clang-format on

  138.     return ret;

  139. }

  140. 

  141. std::vector<LocalShareArgs> get_local_share_conv_small_image() {

  142.     std::vector<LocalShareArgs> ret = get_local_share_conv_small_image(3);

  143.     auto ret1 = get_local_share_conv_small_image(5);

  144.     auto ret2 = get_local_share_conv_small_image(7);

  145.     ret.insert(ret.begin(), ret1.begin(), ret1.end());

  146.     ret.insert(ret.begin(), ret2.begin(), ret2.end());

  147.     return ret;

  148. }

  149. 

  150. void test_local_share_bwd_data_implicit_gemm(size_t kernel_size, Handle* handle) {

  151.     Checker<LocalShareBackwardData> checker(handle);

  152.     bool require_algo = false;

  153.     checker.set_before_exec_callback(AlgoChecker<LocalShareBackwardData>(

  154.             "LOCAL_SHARE_IMPLICIT_GEMM", &require_algo));

  155.     using Param = LocalShare::Param;

  156.     ConstValue const_0{0};

  157.     auto args = get_local_share_conv_small_image(kernel_size);

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

  159.         static_cast<void>(arg);

  160.         size_t b = arg.b, c = arg.c, f = arg.f, p = arg.p, s = arg.s, h = arg.h,

  161.                w = arg.w, sg = arg.sg;

  162.         size_t ho = infer_conv_shape(h, f, s, p), wo = infer_conv_shape(w, f, s, p);

  163.         Param param;

  164.         param.stride_h = param.stride_w = s;

  165.         param.pad_h = param.pad_w = p;

  166.         param.spatial_groups_h = param.spatial_groups_w = sg;

  167.         checker.set_param(param);

  168.         checker.set_rng(2, &const_0);

  169.         TensorShape diff{b, c, ho, wo}, filter{sg, sg, 4, f, f, c}, grad{b, 4, h, w};

  170.         checker.execs({filter, diff, grad});

  171.         diff = TensorShape{b, c, ho, wo}, filter = TensorShape{sg, sg, 8, f, f, c};

  172.         grad = {b, 8, h, w};

  173.         checker.exec({filter, diff, grad});

  174.     }

  175. }

  176. }  // namespace

  177. 

  178. TEST_F(CUDA, LOCAL_SHARE_FORWARD_1x1_LAR_BS) {

  179.     require_compute_capability(6, 0);

  180.     Checker<LocalShare> checker(handle_cuda());

  181.     bool require_algo = false;

  182.     checker.set_before_exec_callback(AlgoChecker<LocalShare>(

  183.             "LOCAL_SHARE_CHWN_BATCH_SIZE_AWARE", &require_algo));

  184.     using Param = LocalShare::Param;

  185.     auto args = get_local_share_conv_1x1_args_lar_bs();

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

  187.         size_t b = arg.b, c = arg.c, f = arg.f, p = arg.p, s = arg.s, h = arg.h,

  188.                w = arg.w, sg = arg.sg;

  189.         Param param;

  190.         param.stride_h = param.stride_w = s;

  191.         param.pad_h = param.pad_w = p;

  192.         param.spatial_groups_h = param.spatial_groups_w = sg;

  193.         checker.set_param(param);

  194.         TensorShape src{b, 4, h, w}, filter{sg, sg, 4, f, f, c};

  195.         checker.execs({src, filter, {}});

  196.         src = TensorShape{b, 8, h, w}, filter = TensorShape{sg, sg, 8, f, f, c};

  197.         checker.exec({src, filter, {}});

  198.     }

  199. }

  200. 

  201. TEST_F(CUDA, LOCAL_SHARE_FORWARD_3x3_LAR_BS) {

  202.     require_compute_capability(6, 0);

  203.     Checker<LocalShare> checker(handle_cuda());

  204.     bool require_algo = false;

  205.     checker.set_before_exec_callback(AlgoChecker<LocalShare>(

  206.             "LOCAL_SHARE_CHWN_BATCH_SIZE_AWARE", &require_algo));

  207.     using Param = LocalShare::Param;

  208.     auto args = get_local_share_conv_3x3_args_lar_bs();

  209.     ConstValue const_1{1};

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

  211.         size_t b = arg.b, c = arg.c, f = arg.f, p = arg.p, s = arg.s, h = arg.h,

  212.                w = arg.w, sg = arg.sg;

  213.         Param param;

  214.         param.stride_h = param.stride_w = s;

  215.         param.pad_h = param.pad_w = p;

  216.         param.spatial_groups_h = param.spatial_groups_w = sg;

  217.         checker.set_param(param);

  218.         TensorShape src{b, 4, h, w}, filter{sg, sg, 4, f, f, c};

  219.         checker.execs({src, filter, {}});

  220.         src = TensorShape{b, 8, h, w}, filter = TensorShape{sg, sg, 8, f, f, c};

  221.         checker.exec({src, filter, {}});

  222.     }

  223. }

  224. 

  225. TEST_F(CUDA, LOCAL_SHARE_FORWARD_5x5_LAR_BS) {

  226.     require_compute_capability(6, 0);

  227.     Checker<LocalShare> checker(handle_cuda());

  228.     bool require_algo = false;

  229.     checker.set_before_exec_callback(AlgoChecker<LocalShare>(

  230.             "LOCAL_SHARE_CHWN_BATCH_SIZE_AWARE", &require_algo));

  231.     using Param = LocalShare::Param;

  232.     auto args = get_local_share_conv_5x5_args_lar_bs();

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

  234.         size_t b = arg.b, c = arg.c, f = arg.f, p = arg.p, s = arg.s, h = arg.h,

  235.                w = arg.w, sg = arg.sg;

  236.         Param param;

  237.         param.stride_h = param.stride_w = s;

  238.         param.pad_h = param.pad_w = p;

  239.         param.spatial_groups_h = param.spatial_groups_w = sg;

  240.         checker.set_param(param);

  241.         TensorShape src{b, 4, h, w}, filter{sg, sg, 4, f, f, c};

  242.         checker.execs({src, filter, {}});

  243.         src = TensorShape{b, 8, h, w}, filter = TensorShape{sg, sg, 8, f, f, c};

  244.         checker.exec({src, filter, {}});

  245.     }

  246. }

  247. 

  248. TEST_F(CUDA, LOCAL_SHARE_FORWARD_7x7_LAR_BS) {

  249.     require_compute_capability(6, 0);

  250.     Checker<LocalShare> checker(handle_cuda());

  251.     bool require_algo = false;

  252.     checker.set_before_exec_callback(AlgoChecker<LocalShare>(

  253.             "LOCAL_SHARE_CHWN_BATCH_SIZE_AWARE", &require_algo));

  254.     using Param = LocalShare::Param;

  255.     auto args = get_local_share_conv_7x7_args_lar_bs();

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

  257.         size_t b = arg.b, c = arg.c, f = arg.f, p = arg.p, s = arg.s, h = arg.h,

  258.                w = arg.w, sg = arg.sg;

  259.         Param param;

  260.         param.stride_h = param.stride_w = s;

  261.         param.pad_h = param.pad_w = p;

  262.         param.spatial_groups_h = param.spatial_groups_w = sg;

  263.         checker.set_param(param);

  264.         TensorShape src{b, 4, h, w}, filter{sg, sg, 4, f, f, c};

  265.         checker.execs({src, filter, {}});

  266.         src = TensorShape{b, 8, h, w}, filter = TensorShape{sg, sg, 8, f, f, c};

  267.         checker.exec({src, filter, {}});

  268.     }

  269. }

  270. 

  271. TEST_F(CUDA, LOCAL_SHARE_BATCHED_MATMUL) {

  272.     Checker<LocalShare> checker(handle_cuda());

  273.     bool require_algo = false;

  274.     checker.set_before_exec_callback(

  275.             AlgoChecker<LocalShare>("LOCAL_SHARE_BATCHED_MATMUL", &require_algo));

  276.     using Param = LocalShare::Param;

  277.     auto args = convolution::get_args();

  278.     for (size_t sg : {2, 3}) {

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

  280.             if (arg.param.sparse != LocalShare::Param::Sparse::DENSE)

  281.                 continue;

  282.             if (arg.param.format != LocalShare::Param::Format::NCHW)

  283.                 continue;

  284.             if (arg.param.dilate_h != 1 || arg.param.dilate_w != 1)

  285.                 continue;

  286.             Param param;

  287.             param.sparse = arg.param.sparse;

  288.             param.stride_h = arg.param.stride_h, param.stride_w = arg.param.stride_w;

  289.             param.pad_h = arg.param.pad_h, param.pad_w = arg.param.pad_w;

  290.             param.dilate_h = arg.param.dilate_h, param.dilate_w = arg.param.dilate_w;

  291.             param.spatial_groups_h = param.spatial_groups_w = sg;

  292.             size_t ho = infer_conv_shape(

  293.                     arg.src[2], arg.filter[2], param.stride_h, param.pad_h);

  294.             size_t wo = infer_conv_shape(

  295.                     arg.src[3], arg.filter[3], param.stride_w, param.pad_w);

  296.             if (ho % sg != 0 || wo % sg != 0)

  297.                 continue;

  298.             TensorShape filter{

  299.                     sg, sg, arg.filter[1], arg.filter[2], arg.filter[3], arg.filter[0]};

  300.             checker.set_param(param);

  301.             checker.exec({arg.src, filter, {}});

  302.         }

  303.     }

  304. }

  305. 

  306. TEST_F(CUDA, GROUP_LOCAL_SHARE_BATCHED_MATMUL) {

  307.     Checker<LocalShare> checker(handle_cuda());

  308.     bool require_algo = false;

  309.     checker.set_before_exec_callback(

  310.             AlgoChecker<LocalShare>("LOCAL_SHARE_BATCHED_MATMUL", &require_algo));

  311.     using Param = LocalShare::Param;

  312.     auto args = convolution::get_args();

  313.     for (size_t sg : {2, 3}) {

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

  315.             if (arg.param.sparse != LocalShare::Param::Sparse::DENSE)

  316.                 continue;

  317.             if (arg.param.format != LocalShare::Param::Format::NCHW)

  318.                 continue;

  319.             if (arg.param.dilate_h != 1 || arg.param.dilate_w != 1)

  320.                 continue;

  321.             if (arg.filter.ndim != 4)

  322.                 continue;

  323.             Param param;

  324.             param.sparse = Param::Sparse::GROUP;

  325.             param.stride_h = arg.param.stride_h, param.stride_w = arg.param.stride_w;

  326.             param.pad_h = arg.param.pad_h, param.pad_w = arg.param.pad_w;

  327.             param.dilate_h = arg.param.dilate_h, param.dilate_w = arg.param.dilate_w;

  328.             param.spatial_groups_h = param.spatial_groups_w = sg;

  329.             size_t ho = infer_conv_shape(

  330.                     arg.src[2], arg.filter[2], param.stride_h, param.pad_h);

  331.             size_t wo = infer_conv_shape(

  332.                     arg.src[3], arg.filter[3], param.stride_w, param.pad_w);

  333.             if (ho % sg != 0 || wo % sg != 0)

  334.                 continue;

  335.             size_t nr_groups = 3;

  336.             TensorShape filter{

  337.                     nr_groups,     sg,           sg, arg.filter[1], arg.filter[2],

  338.                     arg.filter[3], arg.filter[0]};

  339.             TensorShape src{arg.src[0], arg.src[1] * nr_groups, arg.src[2], arg.src[3]};

  340.             checker.set_param(param);

  341.             checker.exec({src, filter, {}});

  342.         }

  343.     }

  344. }

  345. 

  346. TEST_F(CUDA, LOCAL_SHARE_FORWARD_SMALL_IMAGE_GENERAL) {

  347.     require_compute_capability(6, 0);

  348.     Checker<LocalShare> checker(handle_cuda());

  349.     bool require_algo = false;

  350.     checker.set_before_exec_callback(AlgoChecker<LocalShare>(

  351.             "LOCAL_SHARE_CHWN_BATCH_SIZE_AWARE_SMALL_IMAGE", &require_algo));

  352.     using Param = LocalShare::Param;

  353.     auto args = convolution::get_args();

  354.     for (size_t sg : {2, 3}) {

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

  356.             if (arg.param.sparse != LocalShare::Param::Sparse::DENSE)

  357.                 continue;

  358.             if (arg.param.format != LocalShare::Param::Format::NCHW)

  359.                 continue;

  360.             if (arg.param.dilate_h != 1 || arg.param.dilate_w != 1)

  361.                 continue;

  362.             Param param;

  363.             param.stride_h = arg.param.stride_h, param.stride_w = arg.param.stride_w;

  364.             param.pad_h = arg.param.pad_h, param.pad_w = arg.param.pad_w;

  365.             param.dilate_h = arg.param.dilate_h, param.dilate_w = arg.param.dilate_w;

  366.             param.spatial_groups_h = param.spatial_groups_w = sg;

  367.             size_t ho = infer_conv_shape(

  368.                     arg.src[2], arg.filter[2], param.stride_h, param.pad_h);

  369.             size_t wo = infer_conv_shape(

  370.                     arg.src[3], arg.filter[3], param.stride_w, param.pad_w);

  371.             if (ho % sg != 0 || wo % sg != 0)

  372.                 continue;

  373.             arg.filter[1] = arg.filter[1] + (4 - arg.filter[1] % 4);

  374.             arg.src[1] = arg.filter[1];

  375.             TensorShape filter{

  376.                     sg, sg, arg.filter[1], arg.filter[2], arg.filter[3], arg.filter[0]};

  377.             checker.set_param(param);

  378.             checker.exec({arg.src, filter, {}});

  379.         }

  380.     }

  381. }

  382. 

  383. TEST_F(CUDA, LOCAL_SHARE_FORWARD_SMALL_IMAGE_SPECIAL) {

  384.     require_compute_capability(6, 0);

  385.     Checker<LocalShare> checker(handle_cuda());

  386.     bool require_algo = false;

  387.     checker.set_before_exec_callback(AlgoChecker<LocalShare>(

  388.             "LOCAL_SHARE_CHWN_BATCH_SIZE_AWARE_SMALL_IMAGE", &require_algo));

  389.     using Param = LocalShare::Param;

  390.     auto args = get_local_share_conv_small_image();

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

  392.         size_t b = arg.b, c = arg.c, f = arg.f, p = arg.p, s = arg.s, h = arg.h,

  393.                w = arg.w, sg = arg.sg;

  394.         Param param;

  395.         param.stride_h = param.stride_w = s;

  396.         param.pad_h = param.pad_w = p;

  397.         param.spatial_groups_h = param.spatial_groups_w = sg;

  398.         checker.set_param(param);

  399.         TensorShape src{b, 4, h, w}, filter{sg, sg, 4, f, f, c};

  400.         checker.execs({src, filter, {}});

  401.         src = TensorShape{b, 8, h, w}, filter = TensorShape{sg, sg, 8, f, f, c};

  402.         checker.exec({src, filter, {}});

  403.     }

  404. }

  405. 

  406. TEST_F(CUDA, LOCAL_SHARE_BWD_DATA_IMPLICIT_GEMM_GENERAL) {

  407.     require_compute_capability(6, 0);

  408.     Checker<LocalShareBackwardData> checker(handle_cuda());

  409.     bool require_algo = false;

  410.     checker.set_before_exec_callback(AlgoChecker<LocalShareBackwardData>(

  411.             "LOCAL_SHARE_IMPLICIT_GEMM", &require_algo));

  412.     using Param = LocalShare::Param;

  413.     auto args = convolution::get_args();

  414.     ConstValue const_0{0};

  415.     for (size_t sg : {2, 3}) {

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

  417.             if (arg.param.sparse != LocalShare::Param::Sparse::DENSE)

  418.                 continue;

  419.             if (arg.param.format != LocalShare::Param::Format::NCHW)

  420.                 continue;

  421.             if (arg.param.dilate_h != 1 || arg.param.dilate_w != 1)

  422.                 continue;

  423.             Param param;

  424.             param.stride_h = arg.param.stride_h, param.stride_w = arg.param.stride_w;

  425.             param.pad_h = arg.param.pad_h, param.pad_w = arg.param.pad_w;

  426.             param.dilate_h = arg.param.dilate_h, param.dilate_w = arg.param.dilate_w;

  427.             param.spatial_groups_h = param.spatial_groups_w = sg;

  428.             size_t ho = infer_conv_shape(

  429.                     arg.src[2], arg.filter[2], param.stride_h, param.pad_h);

  430.             size_t wo = infer_conv_shape(

  431.                     arg.src[3], arg.filter[3], param.stride_w, param.pad_w);

  432.             if (ho % sg != 0 || wo % sg != 0)

  433.                 continue;

  434.             arg.filter[0] = arg.filter[0] + (4 - arg.filter[0] % 4);

  435.             TensorShape filter{

  436.                     sg, sg, arg.filter[1], arg.filter[2], arg.filter[3], arg.filter[0]};

  437.             TensorShape diff{arg.src[0], arg.filter[0], ho, wo};

  438.             checker.set_param(param);

  439.             checker.set_rng(2, &const_0);

  440.             checker.exec({filter, diff, arg.src});

  441.         }

  442.     }

  443. }

  444. 

  445. TEST_F(CUDA, LOCAL_SHARE_BWD_DATA_IMPLICIT_GEMM_SPECIAL_PART1) {

  446.     require_compute_capability(6, 0);

  447.     test_local_share_bwd_data_implicit_gemm(3, handle_cuda());

  448. }

  449. 

  450. TEST_F(CUDA, LOCAL_SHARE_BWD_DATA_IMPLICIT_GEMM_SPECIAL_PART2) {

  451.     require_compute_capability(6, 0);

  452.     test_local_share_bwd_data_implicit_gemm(5, handle_cuda());

  453. }

  454. 

  455. TEST_F(CUDA, LOCAL_SHARE_BWD_DATA_IMPLICIT_GEMM_SPECIAL_PART3) {

  456.     require_compute_capability(6, 0);

  457.     test_local_share_bwd_data_implicit_gemm(7, handle_cuda());

  458. }

  459. 

  460. TEST_F(CUDA, LOCAL_SHARE_BWD_DATA_BATCHED_MATMUL) {

  461.     Checker<LocalShareBackwardData> checker(handle_cuda());

  462.     bool require_algo = false;

  463.     checker.set_before_exec_callback(AlgoChecker<LocalShareBackwardData>(

  464.             "LOCAL_SHARE_BATCHED_MATMUL", &require_algo));

  465.     using Param = LocalShare::Param;

  466.     auto args = convolution::get_args();

  467.     ConstValue const_0{0};

  468.     for (size_t sg : {2, 3}) {

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

  470.             if (arg.param.sparse != LocalShare::Param::Sparse::DENSE)

  471.                 continue;

  472.             if (arg.param.format != LocalShare::Param::Format::NCHW)

  473.                 continue;

  474.             if (arg.param.dilate_h != 1 || arg.param.dilate_w != 1)

  475.                 continue;

  476.             Param param;

  477.             param.stride_h = arg.param.stride_h, param.stride_w = arg.param.stride_w;

  478.             param.pad_h = arg.param.pad_h, param.pad_w = arg.param.pad_w;

  479.             param.dilate_h = arg.param.dilate_h, param.dilate_w = arg.param.dilate_w;

  480.             param.spatial_groups_h = param.spatial_groups_w = sg;

  481.             size_t ho = infer_conv_shape(

  482.                     arg.src[2], arg.filter[2], param.stride_h, param.pad_h);

  483.             size_t wo = infer_conv_shape(

  484.                     arg.src[3], arg.filter[3], param.stride_w, param.pad_w);

  485.             if (ho % sg != 0 || wo % sg != 0)

  486.                 continue;

  487.             TensorShape filter{

  488.                     sg, sg, arg.filter[1], arg.filter[2], arg.filter[3], arg.filter[0]};

  489.             TensorShape diff{arg.src[0], arg.filter[0], ho, wo};

  490.             checker.set_rng(2, &const_0);

  491.             checker.set_param(param);

  492.             checker.exec({filter, diff, arg.src});

  493.         }

  494.     }

  495. }

  496. 

  497. TEST_F(CUDA, GROUP_LOCAL_SHARE_BWD_DATA_BATCHED_MATMUL) {

  498.     Checker<LocalShareBackwardData> checker(handle_cuda());

  499.     bool require_algo = false;

  500.     checker.set_before_exec_callback(AlgoChecker<LocalShareBackwardData>(

  501.             "LOCAL_SHARE_BATCHED_MATMUL", &require_algo));

  502.     using Param = LocalShare::Param;

  503.     auto args = convolution::get_args();

  504.     ConstValue const_0{0};

  505.     for (size_t sg : {2, 3}) {

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

  507.             if (arg.param.sparse != LocalShare::Param::Sparse::DENSE)

  508.                 continue;

  509.             if (arg.param.format != LocalShare::Param::Format::NCHW)

  510.                 continue;

  511.             if (arg.param.dilate_h != 1 || arg.param.dilate_w != 1)

  512.                 continue;

  513.             Param param;

  514.             param.sparse = Param::Sparse::GROUP;

  515.             param.stride_h = arg.param.stride_h, param.stride_w = arg.param.stride_w;

  516.             param.pad_h = arg.param.pad_h, param.pad_w = arg.param.pad_w;

  517.             param.dilate_h = arg.param.dilate_h, param.dilate_w = arg.param.dilate_w;

  518.             param.spatial_groups_h = param.spatial_groups_w = sg;

  519.             size_t ho = infer_conv_shape(

  520.                     arg.src[2], arg.filter[2], param.stride_h, param.pad_h);

  521.             size_t wo = infer_conv_shape(

  522.                     arg.src[3], arg.filter[3], param.stride_w, param.pad_w);

  523.             if (ho % sg != 0 || wo % sg != 0)

  524.                 continue;

  525.             size_t nr_groups = 3;

  526.             TensorShape filter{

  527.                     nr_groups,     sg,           sg, arg.filter[1], arg.filter[2],

  528.                     arg.filter[3], arg.filter[0]};

  529.             TensorShape diff{arg.src[0], arg.filter[0] * nr_groups, ho, wo};

  530.             TensorShape grad{

  531.                     arg.src[0], arg.src[1] * nr_groups, arg.src[2], arg.src[3]};

  532.             checker.set_rng(2, &const_0);

  533.             checker.set_param(param);

  534.             checker.exec({filter, diff, grad});

  535.         }

  536.     }

  537. }

  538. 

  539. TEST_F(CUDA, LOCAL_SHARE_BWD_FILTER_IMPLICIT_GEMM_GENERAL) {

  540.     require_compute_capability(6, 0);

  541.     Checker<LocalShareBackwardFilter> checker(handle_cuda());

  542.     bool require_algo = false;

  543.     checker.set_before_exec_callback(AlgoChecker<LocalShareBackwardFilter>(

  544.             "LOCAL_SHARE_IMPLICIT_GEMM", &require_algo));

  545.     using Param = LocalShare::Param;

  546.     auto args = convolution::get_args();

  547.     ConstValue const_0{0};

  548.     for (size_t sg : {2, 3}) {

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

  550.             if (arg.param.sparse != LocalShare::Param::Sparse::DENSE)

  551.                 continue;

  552.             if (arg.param.format != LocalShare::Param::Format::NCHW)

  553.                 continue;

  554.             if (arg.param.dilate_h != 1 || arg.param.dilate_w != 1)

  555.                 continue;

  556.             Param param;

  557.             param.stride_h = arg.param.stride_h, param.stride_w = arg.param.stride_w;

  558.             param.pad_h = arg.param.pad_h, param.pad_w = arg.param.pad_w;

  559.             param.dilate_h = arg.param.dilate_h, param.dilate_w = arg.param.dilate_w;

  560.             param.spatial_groups_h = param.spatial_groups_w = sg;

  561.             size_t ho = infer_conv_shape(

  562.                     arg.src[2], arg.filter[2], param.stride_h, param.pad_h);

  563.             size_t wo = infer_conv_shape(

  564.                     arg.src[3], arg.filter[3], param.stride_w, param.pad_w);

  565.             if (ho % sg != 0 || wo % sg != 0)

  566.                 continue;

  567.             arg.src[0] = arg.src[0] + (4 - arg.src[0] % 4);

  568.             TensorShape grad{

  569.                     sg, sg, arg.filter[1], arg.filter[2], arg.filter[3], arg.filter[0]};

  570.             TensorShape diff{arg.src[0], arg.filter[0], ho, wo};

  571.             checker.set_param(param);

  572.             checker.set_rng(2, &const_0);

  573.             checker.exec({arg.src, diff, grad});

  574.         }

  575.     }

  576. }

  577. 

  578. TEST_F(CUDA, LOCAL_SHARE_BWD_FILTER_IMPLICIT_GEMM_SPECIAL) {

  579.     require_compute_capability(6, 0);

  580.     Checker<LocalShareBackwardFilter> checker(handle_cuda());

  581.     bool require_algo = false;

  582.     checker.set_before_exec_callback(AlgoChecker<LocalShareBackwardFilter>(

  583.             "LOCAL_SHARE_IMPLICIT_GEMM", &require_algo));

  584.     using Param = LocalShare::Param;

  585.     ConstValue const_0{0};

  586.     auto args = get_local_share_conv_small_image();

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

  588.         static_cast<void>(arg);

  589.         size_t b = arg.b, c = arg.c, f = arg.f, p = arg.p, s = arg.s, h = arg.h,

  590.                w = arg.w, sg = arg.sg;

  591.         size_t ho = infer_conv_shape(h, f, s, p), wo = infer_conv_shape(w, f, s, p);

  592.         Param param;

  593.         param.stride_h = param.stride_w = s;

  594.         param.pad_h = param.pad_w = p;

  595.         param.spatial_groups_h = param.spatial_groups_w = sg;

  596.         checker.set_param(param);

  597.         checker.set_rng(2, &const_0);

  598.         TensorShape diff{b, c, ho, wo}, grad{sg, sg, 4, f, f, c}, src{b, 4, h, w};

  599.         checker.execs({src, diff, grad});

  600.         src = {b, 8, h, w};

  601.         diff = TensorShape{b, c, ho, wo}, grad = TensorShape{sg, sg, 8, f, f, c};

  602.         checker.exec({src, diff, grad});

  603.     }

  604. }

  605. 

  606. TEST_F(CUDA, LOCAL_SHARE_BWD_FILTER_BATCHED_MATMUL) {

  607.     Checker<LocalShareBackwardFilter> checker(handle_cuda());

  608.     bool require_algo = false;

  609.     checker.set_before_exec_callback(AlgoChecker<LocalShareBackwardFilter>(

  610.             "LOCAL_SHARE_BATCHED_MATMUL", &require_algo));

  611.     using Param = LocalShare::Param;

  612.     auto args = convolution::get_args();

  613.     ConstValue const_0{0};

  614.     for (size_t sg : {2, 3}) {

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

  616.             if (arg.param.sparse != LocalShare::Param::Sparse::DENSE)

  617.                 continue;

  618.             if (arg.param.format != LocalShare::Param::Format::NCHW)

  619.                 continue;

  620.             if (arg.param.dilate_h != 1 || arg.param.dilate_w != 1)

  621.                 continue;

  622.             Param param;

  623.             param.stride_h = arg.param.stride_h, param.stride_w = arg.param.stride_w;

  624.             param.pad_h = arg.param.pad_h, param.pad_w = arg.param.pad_w;

  625.             param.dilate_h = arg.param.dilate_h, param.dilate_w = arg.param.dilate_w;

  626.             param.spatial_groups_h = param.spatial_groups_w = sg;

  627.             size_t ho = infer_conv_shape(

  628.                     arg.src[2], arg.filter[2], param.stride_h, param.pad_h);

  629.             size_t wo = infer_conv_shape(

  630.                     arg.src[3], arg.filter[3], param.stride_w, param.pad_w);

  631.             if (ho % sg != 0 || wo % sg != 0)

  632.                 continue;

  633.             TensorShape grad{

  634.                     sg, sg, arg.filter[1], arg.filter[2], arg.filter[3], arg.filter[0]};

  635.             TensorShape diff{arg.src[0], arg.filter[0], ho, wo};

  636.             checker.set_rng(2, &const_0);

  637.             checker.set_param(param);

  638.             checker.exec({arg.src, diff, grad});

  639.         }

  640.     }

  641. }

  642. 

  643. TEST_F(CUDA, GROUP_LOCAL_SHARE_BWD_FILTER_BATCHED_MATMUL) {

  644.     Checker<LocalShareBackwardFilter> checker(handle_cuda());

  645.     bool require_algo = false;

  646.     checker.set_before_exec_callback(AlgoChecker<LocalShareBackwardFilter>(

  647.             "LOCAL_SHARE_BATCHED_MATMUL", &require_algo));

  648.     using Param = LocalShare::Param;

  649.     auto args = convolution::get_args();

  650.     ConstValue const_0{0};

  651.     for (size_t sg : {2, 3}) {

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

  653.             if (arg.param.sparse != LocalShare::Param::Sparse::DENSE)

  654.                 continue;

  655.             if (arg.param.format != LocalShare::Param::Format::NCHW)

  656.                 continue;

  657.             if (arg.param.dilate_h != 1 || arg.param.dilate_w != 1)

  658.                 continue;

  659.             Param param;

  660.             param.sparse = Param::Sparse::GROUP;

  661.             param.stride_h = arg.param.stride_h, param.stride_w = arg.param.stride_w;

  662.             param.pad_h = arg.param.pad_h, param.pad_w = arg.param.pad_w;

  663.             param.dilate_h = arg.param.dilate_h, param.dilate_w = arg.param.dilate_w;

  664.             param.spatial_groups_h = param.spatial_groups_w = sg;

  665.             size_t ho = infer_conv_shape(

  666.                     arg.src[2], arg.filter[2], param.stride_h, param.pad_h);

  667.             size_t wo = infer_conv_shape(

  668.                     arg.src[3], arg.filter[3], param.stride_w, param.pad_w);

  669.             if (ho % sg != 0 || wo % sg != 0)

  670.                 continue;

  671.             size_t nr_groups = 3;

  672.             TensorShape grad{

  673.                     nr_groups,     sg,           sg, arg.filter[1], arg.filter[2],

  674.                     arg.filter[3], arg.filter[0]};

  675.             TensorShape diff{arg.src[0], arg.filter[0] * nr_groups, ho, wo};

  676.             TensorShape src{arg.src[0], arg.src[1] * nr_groups, arg.src[2], arg.src[3]};

  677.             checker.set_rng(2, &const_0);

  678.             checker.set_param(param);

  679.             checker.exec({src, diff, grad});

  680.         }

  681.     }

  682. }

  683. 

  684. #if MEGDNN_WITH_BENCHMARK

  685. TEST_F(CUDA, BENCHMARK_LOCAL_SHARE_BWD_FILTER) {

  686.     CUBenchmarker<LocalShareBackwardFilter> bencher(handle_cuda());

  687.     size_t RUNS = 1000;

  688.     bencher.set_display(false).set_times(RUNS);

  689.     std::unique_ptr<OprProxy<LocalShareBackwardFilter>> proxy{

  690.             new OprProxy<LocalShareBackwardFilter>{true}};

  691.     bencher.set_proxy(proxy);

  692. 

  693.     LocalShare::Param param;

  694.     NormalRNG rng;

  695. 

  696.     auto run = [&](size_t batch, size_t ic, size_t ih, size_t iw, size_t oc, size_t f,

  697.                    size_t s, size_t sg) {

  698.         param.pad_h = f / 2;

  699.         param.pad_w = f / 2;

  700.         param.stride_h = s;

  701.         param.stride_w = s;

  702.         param.spatial_groups_h = sg;

  703.         param.spatial_groups_w = sg;

  704. 

  705.         TensorShape src = {batch, ic, ih, iw}, grad = {sg, sg, ic, f, f, oc};

  706.         size_t ho = infer_conv_shape(ih, f, s, f / 2);

  707.         size_t wo = infer_conv_shape(iw, f, s, f / 2);

  708.         TensorShape diff = {batch, oc, ho, wo};

  709. 

  710.         float flo = 2.0 * batch * oc * ho * wo * ic * f * f / (1e12);

  711. 

  712.         bencher.set_param(param)

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

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

  715.                 .set_dtype(2, dtype::Float32())

  716.                 .set_rng(0, &rng)

  717.                 .set_rng(1, &rng);

  718.         bencher.proxy()->target_execution_policy.algo.reset();

  719.         auto time_in_ms = bencher.execs({src, diff, grad}) / RUNS;

  720. 

  721.         printf("src=%s, diff=%s, grad=%s, float32: %.2fms "

  722.                "%.2fTFlops\n",

  723.                src.to_string().c_str(), diff.to_string().c_str(),

  724.                grad.to_string().c_str(), time_in_ms, (flo / (time_in_ms * 1e-3)));

  725.     };

  726.     // stride = 1

  727.     run(32, 128, 24, 24, 128, 1, 1, 3);

  728.     run(32, 256, 12, 12, 256, 1, 1, 3);

  729. 

  730.     // stride = 2

  731.     run(32, 256, 12, 12, 512, 1, 2, 3);

  732.     run(32, 512, 6, 6, 1024, 1, 2, 3);

  733. 

  734.     // stride = 1

  735.     run(32, 128, 24, 24, 128, 3, 1, 3);

  736.     run(32, 256, 12, 12, 256, 3, 1, 3);

  737. 

  738.     // stride = 2

  739.     run(32, 128, 24, 24, 256, 3, 2, 3);

  740.     run(32, 256, 12, 12, 512, 3, 2, 3);

  741. 

  742.     // stride = 1

  743.     run(64, 128, 24, 24, 128, 1, 1, 3);

  744.     run(64, 256, 12, 12, 256, 1, 1, 3);

  745. 

  746.     // stride = 2

  747.     run(64, 256, 12, 12, 512, 1, 2, 3);

  748.     run(64, 512, 6, 6, 1024, 1, 2, 3);

  749. 

  750.     // stride = 1

  751.     run(64, 128, 24, 24, 128, 3, 1, 3);

  752.     run(64, 256, 12, 12, 256, 3, 1, 3);

  753. 

  754.     // stride = 2

  755.     run(64, 128, 24, 24, 256, 3, 2, 3);

  756.     run(64, 256, 12, 12, 512, 3, 2, 3);

  757. }

  758. 

  759. TEST_F(CUDA, BENCHMARK_GROUP_LOCAL_SHARE_FORWARD) {

  760.     CUBenchmarker<LocalShare> bencher(handle_cuda());

  761.     size_t RUNS = 1000;

  762.     bencher.set_display(false).set_times(RUNS);

  763.     std::unique_ptr<OprProxy<LocalShareForward>> proxy{

  764.             new OprProxy<LocalShareForward>{true}};

  765.     bencher.set_proxy(proxy);

  766. 

  767.     LocalShare::Param param;

  768.     NormalRNG rng;

  769. 

  770.     auto run = [&](size_t batch, size_t ic, size_t ih, size_t iw, size_t oc, size_t f,

  771.                    size_t s, size_t sg) {

  772.         param.pad_h = f / 2;

  773.         param.pad_w = f / 2;

  774.         param.stride_h = s;

  775.         param.stride_w = s;

  776.         param.spatial_groups_h = sg;

  777.         param.spatial_groups_w = sg;

  778.         param.sparse = LocalShare::Param::Sparse::GROUP;

  779. 

  780.         TensorShape src = {1, batch * ic, ih, iw},

  781.                     filter = {batch, sg, sg, ic, f, f, oc};

  782.         size_t ho = infer_conv_shape(ih, f, s, f / 2);

  783.         size_t wo = infer_conv_shape(iw, f, s, f / 2);

  784. 

  785.         float flo = 2.0 * batch * oc * ho * wo * ic * f * f / (1e12);

  786. 

  787.         bencher.set_param(param)

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

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

  790.                 .set_dtype(2, dtype::Float32())

  791.                 .set_rng(0, &rng)

  792.                 .set_rng(1, &rng);

  793.         bencher.proxy()->target_execution_policy.algo.reset();

  794.         auto time_in_ms = bencher.execs({src, filter, {}}) / RUNS;

  795.         ;

  796. 

  797.         printf("src=%s, filter=%s, float32: %.2fms %.2fTFlops\n",

  798.                src.to_string().c_str(), filter.to_string().c_str(), time_in_ms,

  799.                (flo / (time_in_ms * 1e-3)));

  800.     };

  801.     // stride = 1

  802.     run(32, 128, 24, 24, 128, 1, 1, 3);

  803.     run(32, 256, 12, 12, 256, 1, 1, 3);

  804. 

  805.     // stride = 2

  806.     run(32, 256, 12, 12, 512, 1, 2, 3);

  807.     run(32, 512, 6, 6, 1024, 1, 2, 3);

  808. 

  809.     // stride = 1

  810.     run(64, 128, 24, 24, 128, 1, 1, 3);

  811.     run(64, 256, 12, 12, 256, 1, 1, 3);

  812. 

  813.     // stride = 2

  814.     run(64, 256, 12, 12, 512, 1, 2, 3);

  815.     run(64, 512, 6, 6, 1024, 1, 2, 3);

  816. }

  817. 

  818. TEST_F(CUDA, BENCHMARK_LOCAL_SHARE_BWD_DATA) {

  819.     CUBenchmarker<LocalShareBackwardData> bencher(handle_cuda());

  820.     size_t RUNS = 1000;

  821.     bencher.set_display(false).set_times(RUNS);

  822.     std::unique_ptr<OprProxy<LocalShareBackwardData>> proxy{

  823.             new OprProxy<LocalShareBackwardData>{true}};

  824.     bencher.set_proxy(proxy);

  825. 

  826.     LocalShare::Param param;

  827.     NormalRNG rng;

  828. 

  829.     auto run = [&](size_t batch, size_t ic, size_t ih, size_t iw, size_t oc, size_t f,

  830.                    size_t s, size_t sg) {

  831.         param.pad_h = f / 2;

  832.         param.pad_w = f / 2;

  833.         param.stride_h = s;

  834.         param.stride_w = s;

  835.         param.spatial_groups_h = sg;

  836.         param.spatial_groups_w = sg;

  837. 

  838.         TensorShape grad = {batch, ic, ih, iw}, filter = {sg, sg, ic, f, f, oc};

  839.         size_t ho = infer_conv_shape(ih, f, s, f / 2);

  840.         size_t wo = infer_conv_shape(iw, f, s, f / 2);

  841.         TensorShape diff = {batch, oc, ho, wo};

  842. 

  843.         float flo = 2.0 * batch * oc * ho * wo * ic * f * f / (1e12);

  844. 

  845.         bencher.set_param(param)

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

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

  848.                 .set_dtype(2, dtype::Float32())

  849.                 .set_rng(0, &rng)

  850.                 .set_rng(1, &rng);

  851.         bencher.proxy()->target_execution_policy.algo.reset();

  852.         auto time_in_ms = bencher.execs({filter, diff, grad}) / RUNS;

  853. 

  854.         printf("filter=%s, diff=%s, grad=%s, float32: %.2fms "

  855.                "%.2fTFlops\n",

  856.                filter.to_string().c_str(), diff.to_string().c_str(),

  857.                grad.to_string().c_str(), time_in_ms, (flo / (time_in_ms * 1e-3)));

  858.     };

  859.     // stride = 1

  860.     run(32, 128, 24, 24, 128, 1, 1, 3);

  861.     run(32, 256, 12, 12, 256, 1, 1, 3);

  862. 

  863.     // stride = 2

  864.     run(32, 256, 12, 12, 512, 1, 2, 3);

  865.     run(32, 512, 6, 6, 1024, 1, 2, 3);

  866. 

  867.     // stride = 1

  868.     run(32, 128, 24, 24, 128, 3, 1, 3);

  869.     run(32, 256, 12, 12, 256, 3, 1, 3);

  870. 

  871.     // stride = 2

  872.     run(32, 128, 24, 24, 256, 3, 2, 3);

  873.     run(32, 256, 12, 12, 512, 3, 2, 3);

  874. 

  875.     // stride = 1

  876.     run(64, 128, 24, 24, 128, 1, 1, 3);

  877.     run(64, 256, 12, 12, 256, 1, 1, 3);

  878. 

  879.     // stride = 2

  880.     run(64, 256, 12, 12, 512, 1, 2, 3);

  881.     run(64, 512, 6, 6, 1024, 1, 2, 3);

  882. 

  883.     // stride = 1

  884.     run(64, 128, 24, 24, 128, 3, 1, 3);

  885.     run(64, 256, 12, 12, 256, 3, 1, 3);

  886. 

  887.     // stride = 2

  888.     run(64, 128, 24, 24, 256, 3, 2, 3);

  889.     run(64, 256, 12, 12, 512, 3, 2, 3);

  890. }

  891. 

  892. TEST_F(CUDA, BENCHMARK_LOCAL_SHARE_FORWARD_BOTTLENECK) {

  893.     CUBenchmarker<LocalShare> bencher(handle_cuda());

  894.     CUBenchmarker<Convolution> bencher_conv(handle_cuda());

  895.     size_t RUNS = 1000;

  896.     bencher.set_display(false).set_times(RUNS);

  897.     std::unique_ptr<OprProxy<LocalShareForward>> proxy{

  898.             new OprProxy<LocalShareForward>{true}};

  899.     bencher.set_proxy(proxy);

  900. 

  901.     bencher_conv.set_display(false).set_times(RUNS);

  902.     std::unique_ptr<OprProxy<Convolution>> conv_proxy{new OprProxy<Convolution>{true}};

  903.     bencher_conv.set_proxy(conv_proxy);

  904. 

  905.     LocalShare::Param param;

  906.     Convolution::Param conv_param;

  907.     NormalRNG rng;

  908. 

  909.     auto run = [&](size_t batch, size_t ic, size_t ih, size_t iw, size_t oc, size_t f,

  910.                    size_t s, size_t sg) {

  911.         param.pad_h = f / 2;

  912.         param.pad_w = f / 2;

  913.         param.stride_h = s;

  914.         param.stride_w = s;

  915.         param.spatial_groups_h = sg;

  916.         param.spatial_groups_w = sg;

  917. 

  918.         conv_param.pad_h = f / 2;

  919.         conv_param.pad_w = f / 2;

  920.         conv_param.stride_h = s;

  921.         conv_param.stride_w = s;

  922. 

  923.         TensorShape src = {batch, ic, ih, iw}, filter = {sg, sg, ic, f, f, oc};

  924.         size_t ho = infer_conv_shape(ih, f, s, f / 2);

  925.         size_t wo = infer_conv_shape(iw, f, s, f / 2);

  926. 

  927.         float flo = 2.0 * batch * oc * ho * wo * ic * f * f / (1e12);

  928. 

  929.         bencher.set_param(param)

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

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

  932.                 .set_dtype(2, dtype::Float32())

  933.                 .set_rng(0, &rng)

  934.                 .set_rng(1, &rng);

  935.         bencher.proxy()->target_execution_policy.algo.reset();

  936.         auto time_in_ms = bencher.execs({src, filter, {}}) / RUNS;

  937. 

  938.         bencher_conv.set_param(conv_param);

  939.         bencher_conv.proxy()->target_execution_policy.algo.reset();

  940.         auto time_in_ms_conv = bencher_conv.execs({src, {oc, ic, f, f}, {}}) / RUNS;

  941. 

  942.         printf("src=%s, filter=%s, float32: %.2fms %.2fTFlops, "

  943.                "conv(float32): %.2fms %.2fTFlops, local_share/conv=%.2f\n",

  944.                src.to_string().c_str(), filter.to_string().c_str(), time_in_ms,

  945.                (flo / (time_in_ms * 1e-3)), time_in_ms_conv,

  946.                (flo / (time_in_ms_conv * 1e-3)), time_in_ms / time_in_ms_conv);

  947.     };

  948.     // stride = 1

  949.     run(32, 128, 24, 24, 128, 1, 1, 3);

  950.     run(32, 256, 12, 12, 256, 1, 1, 3);

  951. 

  952.     // stride = 2

  953.     run(32, 256, 12, 12, 512, 1, 2, 3);

  954.     run(32, 512, 6, 6, 1024, 1, 2, 3);

  955. 

  956.     // stride = 1

  957.     run(32, 128, 24, 24, 128, 3, 1, 3);

  958.     run(32, 256, 12, 12, 256, 3, 1, 3);

  959. 

  960.     // stride = 2

  961.     run(32, 128, 24, 24, 256, 3, 2, 3);

  962.     run(32, 256, 12, 12, 512, 3, 2, 3);

  963. 

  964.     // stride = 1

  965.     run(64, 128, 24, 24, 128, 1, 1, 3);

  966.     run(64, 256, 12, 12, 256, 1, 1, 3);

  967. 

  968.     // stride = 2

  969.     run(64, 256, 12, 12, 512, 1, 2, 3);

  970.     run(64, 512, 6, 6, 1024, 1, 2, 3);

  971. 

  972.     // stride = 1

  973.     run(64, 128, 24, 24, 128, 3, 1, 3);

  974.     run(64, 256, 12, 12, 256, 3, 1, 3);

  975. 

  976.     // stride = 2

  977.     run(64, 128, 24, 24, 256, 3, 2, 3);

  978.     run(64, 256, 12, 12, 512, 3, 2, 3);

  979. }

  980. 

  981. TEST_F(CUDA, BENCHMARK_LOCAL_SHARE_FORWARD_FROM_RESEARCH) {

  982.     CUBenchmarker<LocalShare> bencher(handle_cuda());

  983.     CUBenchmarker<Convolution> bencher_conv(handle_cuda());

  984.     size_t RUNS = 1000;

  985.     bencher.set_display(false).set_times(RUNS);

  986.     std::unique_ptr<OprProxy<LocalShareForward>> proxy{

  987.             new OprProxy<LocalShareForward>{true}};

  988.     bencher.set_proxy(proxy);

  989. 

  990.     bencher_conv.set_display(false).set_times(RUNS);

  991.     std::unique_ptr<OprProxy<Convolution>> conv_proxy{new OprProxy<Convolution>{true}};

  992.     bencher_conv.set_proxy(conv_proxy);

  993. 

  994.     LocalShare::Param param;

  995.     Convolution::Param conv_param;

  996.     NormalRNG rng;

  997. 

  998.     auto run = [&](size_t batch, size_t ic, size_t ih, size_t iw, size_t oc, size_t f,

  999.                    size_t s, size_t sg) {

  1000.         param.pad_h = f / 2;

  1001.         param.pad_w = f / 2;

  1002.         param.stride_h = s;

  1003.         param.stride_w = s;

  1004.         param.spatial_groups_h = sg;

  1005.         param.spatial_groups_w = sg;

  1006. 

  1007.         conv_param.pad_h = f / 2;

  1008.         conv_param.pad_w = f / 2;

  1009.         conv_param.stride_h = s;

  1010.         conv_param.stride_w = s;

  1011. 

  1012.         TensorShape src = {batch, ic, ih, iw}, filter = {sg, sg, ic, f, f, oc};

  1013.         size_t ho = infer_conv_shape(ih, f, s, f / 2);

  1014.         size_t wo = infer_conv_shape(iw, f, s, f / 2);

  1015. 

  1016.         float flo = 2.0 * batch * oc * ho * wo * ic * f * f / (1e12);

  1017. 

  1018.         bencher.set_param(param)

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

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

  1021.                 .set_dtype(2, dtype::Float32())

  1022.                 .set_rng(0, &rng)

  1023.                 .set_rng(1, &rng);

  1024.         bencher.proxy()->target_execution_policy.algo.reset();

  1025.         auto time_in_ms = bencher.execs({src, filter, {}}) / RUNS;

  1026. 

  1027.         bencher_conv.set_param(conv_param);

  1028.         bencher_conv.proxy()->target_execution_policy.algo.reset();

  1029.         auto time_in_ms_conv = bencher_conv.execs({src, {oc, ic, f, f}, {}}) / RUNS;

  1030. 

  1031.         printf("src=%s, filter=%s, float32: %.2fms %.2fTFlops, "

  1032.                "conv(float32): %.2fms %.2fTFlops, local_share/conv=%.2f\n",

  1033.                src.to_string().c_str(), filter.to_string().c_str(), time_in_ms,

  1034.                (flo / (time_in_ms * 1e-3)), time_in_ms_conv,

  1035.                (flo / (time_in_ms_conv * 1e-3)), time_in_ms / time_in_ms_conv);

  1036.     };

  1037.     // stride = 1

  1038.     run(64, 128, 24, 24, 128, 1, 1, 3);

  1039.     run(64, 256, 12, 12, 256, 1, 1, 3);

  1040.     run(64, 512, 6, 6, 512, 1, 1, 3);

  1041.     run(64, 1024, 3, 3, 1024, 1, 1, 3);

  1042. 

  1043.     // stride = 2

  1044.     run(64, 128, 24, 24, 256, 1, 2, 3);

  1045.     run(64, 256, 12, 12, 512, 1, 2, 3);

  1046.     run(64, 512, 6, 6, 1024, 1, 2, 3);

  1047. 

  1048.     // stride = 1

  1049.     run(64, 128, 24, 24, 128, 3, 1, 3);

  1050.     run(64, 256, 12, 12, 256, 3, 1, 3);

  1051.     run(64, 512, 6, 6, 512, 3, 1, 3);

  1052.     run(64, 1024, 3, 3, 1024, 3, 1, 3);

  1053. 

  1054.     // stride = 2

  1055.     run(64, 128, 24, 24, 256, 3, 2, 3);

  1056.     run(64, 256, 12, 12, 512, 3, 2, 3);

  1057.     run(64, 512, 6, 6, 1024, 3, 2, 3);

  1058. }

  1059. 

  1060. TEST_F(CUDA, BENCHMARK_LOCAL_SHARE_FORWARD) {

  1061.     require_compute_capability(6, 0);

  1062.     CUBenchmarker<LocalShare> bencher(handle_cuda());

  1063.     CUBenchmarker<Convolution> bencher_conv(handle_cuda());

  1064.     size_t RUNS = 200;

  1065.     bencher.set_display(false).set_times(RUNS);

  1066.     std::unique_ptr<OprProxy<LocalShareForward>> proxy{

  1067.             new OprProxy<LocalShareForward>{true}};

  1068.     bencher.set_proxy(proxy);

  1069. 

  1070.     bencher_conv.set_display(false).set_times(RUNS);

  1071.     std::unique_ptr<OprProxy<Convolution>> conv_proxy{new OprProxy<Convolution>{true}};

  1072.     bencher_conv.set_proxy(conv_proxy);

  1073. 

  1074.     LocalShare::Param param;

  1075.     Convolution::Param conv_param;

  1076.     NormalRNG rng;

  1077. 

  1078.     auto run = [&](size_t batch, size_t ic, size_t ih, size_t iw, size_t oc, size_t f,

  1079.                    size_t s, size_t sg) {

  1080.         param.pad_h = f / 2;

  1081.         param.pad_w = f / 2;

  1082.         param.stride_h = s;

  1083.         param.stride_w = s;

  1084.         param.spatial_groups_h = sg;

  1085.         param.spatial_groups_w = sg;

  1086. 

  1087.         conv_param.pad_h = f / 2;

  1088.         conv_param.pad_w = f / 2;

  1089.         conv_param.stride_h = s;

  1090.         conv_param.stride_w = s;

  1091. 

  1092.         TensorShape src = {batch, ic, ih, iw}, filter = {sg, sg, ic, f, f, oc};

  1093.         size_t ho = infer_conv_shape(ih, f, s, f / 2);

  1094.         size_t wo = infer_conv_shape(iw, f, s, f / 2);

  1095. 

  1096.         float flo = 2.0 * batch * oc * ho * wo * ic * f * f / (1e12);

  1097. 

  1098.         bencher.set_param(param)

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

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

  1101.                 .set_dtype(2, dtype::Float32())

  1102.                 .set_rng(0, &rng)

  1103.                 .set_rng(1, &rng);

  1104.         bencher.proxy()->target_execution_policy.algo.reset();

  1105.         auto time_in_ms = bencher.execs({src, filter, {}}) / RUNS;

  1106. 

  1107.         bencher_conv.set_param(conv_param);

  1108.         bencher_conv.proxy()->target_execution_policy.algo.reset();

  1109.         auto time_in_ms_conv = bencher_conv.execs({src, {oc, ic, f, f}, {}}) / RUNS;

  1110. 

  1111.         printf("src=%s, filter=%s, float32: %.2fms %.2fTFlops, "

  1112.                "conv(float32): %.2fms %.2fTFlops, local_share/conv=%.2f\n",

  1113.                src.to_string().c_str(), filter.to_string().c_str(), time_in_ms,

  1114.                (flo / (time_in_ms * 1e-3)), time_in_ms_conv,

  1115.                (flo / (time_in_ms_conv * 1e-3)), time_in_ms / time_in_ms_conv);

  1116.     };

  1117.     run(64, 256, 48, 48, 256, 7, 1, 3);

  1118.     run(64, 128, 24, 24, 128, 7, 1, 3);

  1119.     run(64, 256, 12, 12, 256, 7, 1, 3);

  1120.     run(64, 512, 6, 6, 512, 7, 1, 3);

  1121. 

  1122.     run(64, 256, 48, 48, 256, 5, 1, 3);

  1123.     run(64, 128, 24, 24, 128, 5, 1, 3);

  1124.     run(64, 256, 12, 12, 256, 5, 1, 3);

  1125.     run(64, 512, 6, 6, 512, 5, 1, 3);

  1126. 

  1127.     run(32, 64, 96, 96, 256, 7, 2, 3);

  1128.     run(32, 128, 24, 24, 128, 7, 2, 3);

  1129.     run(32, 256, 12, 12, 256, 7, 2, 3);

  1130. 

  1131.     run(32, 64, 96, 96, 256, 5, 2, 3);

  1132.     run(32, 128, 24, 24, 128, 5, 2, 3);

  1133.     run(32, 256, 12, 12, 256, 5, 2, 3);

  1134. }

  1135. #endif

  1136. 

  1137. // vim: syntax=cpp.doxygen