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

1036 lines
45 kB
Raw Blame History 

  1. #include "megdnn/dtype.h"

  2. #include "megdnn/opr_param_defs.h"

  3. #include "megdnn/oprs.h"

  4. #include "megdnn/oprs/nn.h"

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

  6. #include "test/common/conv_bias.h"

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

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

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

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

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

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

  13. 

  14. #include <cudnn.h>

  15. #include <gtest/gtest.h>

  16. 

  17. #define V1(x) #x

  18. #define V(x)  V1(x)

  19. #define CUDNN_VERSION_STRING \

  20.     "v" V(CUDNN_MAJOR) "." V(CUDNN_MINOR) "." V(CUDNN_PATCHLEVEL)

  21. 

  22. namespace megdnn {

  23. namespace test {

  24. 

  25. TEST_F(CUDA, REGION_RESTRICTED_CONV_FORWARD_LARGE_FILTER) {

  26.     Checker<RegionRestrictedConvolutionForward> checker(handle_cuda());

  27.     auto opr = handle_cuda()->create_operator<ConvolutionForward>();

  28.     for (auto dt : std::vector<DType>{dtype::Int32(), dtype::Uint8()}) {

  29.         auto run = [&checker, &dt, &opr](

  30.                            size_t n, size_t g, size_t h, size_t fh, size_t padding,

  31.                            size_t stride) {

  32.             RegionRestrictedConvolution::Param cur_param;

  33.             cur_param.mode =

  34.                     RegionRestrictedConvolution::Param::Mode::CROSS_CORRELATION;

  35.             cur_param.sparse = RegionRestrictedConvolution::Param::Sparse::GROUP;

  36.             checker.set_dtype(2, dt).set_dtype(3, dt);

  37.             float scale = 64.f / sqrt(fh * fh);

  38.             UniformFloatRNG rng(scale, 2 * scale);

  39.             UniformIntRNG r_rng{0, 2};

  40.             checker.set_rng(0, &rng).set_rng(1, &rng).set_rng(2, &r_rng).set_rng(

  41.                     3, &r_rng);

  42. 

  43.             cur_param.pad_h = cur_param.pad_w = padding;

  44.             cur_param.stride_h = cur_param.stride_w = stride;

  45. 

  46.             size_t ho = infer_conv_shape(h, fh, stride, padding);

  47. 

  48.             checker.set_param(cur_param).execs(

  49.                     {{n, g, h, h}, {g, 1, 1, fh, fh}, {n, h, h}, {n, ho, ho}, {}});

  50.         };

  51.         run(1, 1, 3, 2, 1, 1);

  52.         run(1, 1, 5, 2, 1, 1);

  53.         run(1, 1, 6, 2, 1, 1);

  54.         run(1, 1, 7, 2, 1, 1);

  55.         run(1, 1, 9, 2, 1, 1);

  56.         run(1, 1, 10, 2, 1, 1);

  57.         run(1, 1, 11, 2, 1, 1);

  58.         run(1, 1, 13, 2, 1, 1);

  59.         run(1, 1, 14, 2, 1, 1);

  60.         run(1, 1, 15, 2, 1, 1);

  61.         run(1, 1, 17, 2, 1, 1);

  62.         run(1, 1, 18, 2, 1, 1);

  63.         run(1, 1, 19, 2, 1, 1);

  64.         run(1, 1, 21, 2, 1, 1);

  65.         run(1, 1, 22, 2, 1, 1);

  66.         run(1, 1, 23, 2, 1, 1);

  67.         run(1, 1, 25, 2, 1, 1);

  68.         run(1, 1, 26, 2, 1, 1);

  69.         run(1, 1, 27, 2, 1, 1);

  70.         run(1, 1, 29, 2, 1, 1);

  71.         run(1, 1, 30, 2, 1, 1);

  72.         run(1, 1, 31, 2, 1, 1);

  73.         run(4, 8, 32, 3, 3 / 2, 1);

  74.         run(4, 8, 32, 5, 5 / 2, 1);

  75.         run(4, 8, 32, 7, 7 / 2, 1);

  76.         run(4, 8, 32, 9, 9 / 2, 1);

  77.         run(4, 8, 32, 11, 11 / 2, 1);

  78.         run(4, 8, 32, 13, 13 / 2, 1);

  79.         run(4, 8, 32, 15, 15 / 2, 1);

  80.         run(4, 8, 32, 17, 17 / 2, 1);

  81.         run(4, 8, 32, 19, 19 / 2, 1);

  82.         run(4, 8, 32, 21, 21 / 2, 1);

  83.         run(4, 8, 32, 23, 23 / 2, 1);

  84.         run(4, 8, 32, 25, 25 / 2, 1);

  85.         run(4, 8, 32, 27, 27 / 2, 1);

  86.         run(4, 8, 32, 29, 29 / 2, 1);

  87.         run(4, 8, 32, 31, 31 / 2, 1);

  88.         run(4, 8, 31, 3, 3 / 2, 1);

  89.         run(4, 8, 31, 5, 5 / 2, 1);

  90.         run(4, 8, 31, 7, 7 / 2, 1);

  91.         run(4, 8, 31, 9, 9 / 2, 1);

  92.         run(4, 8, 31, 11, 11 / 2, 1);

  93.         run(4, 8, 31, 13, 13 / 2, 1);

  94.         run(4, 8, 31, 15, 15 / 2, 1);

  95.         run(4, 8, 31, 17, 17 / 2, 1);

  96.         run(4, 8, 31, 19, 19 / 2, 1);

  97.         run(4, 8, 31, 21, 21 / 2, 1);

  98.         run(4, 8, 31, 23, 23 / 2, 1);

  99.         run(4, 8, 31, 25, 25 / 2, 1);

  100.         run(4, 8, 31, 27, 27 / 2, 1);

  101.         run(4, 8, 31, 29, 29 / 2, 1);

  102.         run(4, 8, 31, 31, 31 / 2, 1);

  103.     }

  104. }

  105. 

  106. #if MEGDNN_WITH_BENCHMARK

  107. 

  108. TEST_F(CUDA, BENCHMARK_REGION_RESTRICTED_CONV_FORWARD_LARGE_FILTER_FP32_INT32) {

  109.     require_compute_capability(7, 5);

  110.     Benchmarker<ConvBiasForward> bencher(handle_cuda());

  111.     bencher.set_display(false);

  112.     bencher.set_before_exec_callback(conv_bias::ConvBiasAlgoChecker<ConvBiasForward>(

  113.             ConvBiasForward::algo_name<ConvBiasForward::DirectParam>(

  114.                     "DEPTHWISE_LARGE_FILTER", {})

  115.                     .c_str()));

  116. 

  117.     Benchmarker<RegionRestrictedConvolutionForward> rr_bencher(handle_cuda());

  118.     rr_bencher.set_display(false);

  119. 

  120.     ConvBias::Param param;

  121.     param.format = ConvBias::Param::Format::NCHW;

  122.     using NonlineMode = ConvBias::Param::NonlineMode;

  123.     param.nonlineMode = NonlineMode::IDENTITY;

  124.     param.sparse = ConvBias::Param::Sparse::GROUP;

  125. 

  126.     RegionRestrictedConvolutionForward::Param rr_param;

  127.     rr_param.format = RegionRestrictedConvolutionForward::Param::Format::NCHW;

  128.     rr_param.sparse = RegionRestrictedConvolutionForward::Param::Sparse::GROUP;

  129. 

  130.     UniformIntRNG r_rng{0, 2};

  131. 

  132.     auto run_bench = [&](size_t batch, size_t g, size_t hi, size_t wi, size_t fh,

  133.                          size_t fw, size_t sh, size_t sw, size_t nr_times) {

  134.         param.pad_h = fh / 2;

  135.         param.pad_w = fw / 2;

  136.         param.stride_h = sh;

  137.         param.stride_w = sw;

  138. 

  139.         rr_param.pad_h = fh / 2;

  140.         rr_param.pad_w = fw / 2;

  141.         rr_param.stride_h = sh;

  142.         rr_param.stride_w = sw;

  143. 

  144.         bencher.set_param(param)

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

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

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

  148.                 .set_dtype(4, dtype::Float32());

  149.         bencher.set_times(nr_times);

  150. 

  151.         rr_bencher.set_param(rr_param)

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

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

  154.                 .set_dtype(2, dtype::Int32())

  155.                 .set_dtype(3, dtype::Int32());

  156.         rr_bencher.set_rng(2, &r_rng).set_rng(3, &r_rng);

  157.         rr_bencher.set_times(nr_times);

  158. 

  159.         size_t ho = infer_conv_shape(hi, fh, sh, param.pad_h);

  160.         size_t wo = infer_conv_shape(wi, fw, sw, param.pad_w);

  161.         TensorShape inp{batch, g, hi, wi}, kern{g, 1, 1, fh, fw}, rin{batch, hi, wi},

  162.                 rout{batch, ho, wo}, out{batch, g, ho, wo};

  163. 

  164.         float bandwith = static_cast<float>(

  165.                                  inp.total_nr_elems() + kern.total_nr_elems() +

  166.                                  out.total_nr_elems()) /

  167.                          (1024 * 1024 * 1024) * 1e3;

  168. 

  169.         float rr_bandwith = static_cast<float>(

  170.                                     inp.total_nr_elems() + kern.total_nr_elems() +

  171.                                     rin.total_nr_elems() + rout.total_nr_elems() +

  172.                                     out.total_nr_elems()) /

  173.                             (1024 * 1024 * 1024) * 1e3;

  174. 

  175.         auto time_in_ms = bencher.execs({inp, kern, {}, {}, out}) / nr_times;

  176.         auto ops = 2.0 * batch * g * ho * wo * fh * fw / (time_in_ms * 1e-3) * 1e-12;

  177. 

  178.         auto rr_time_in_ms = rr_bencher.execs({inp, kern, rin, rout, out}) / nr_times;

  179.         auto rr_ops =

  180.                 2.0 * batch * g * ho * wo * fh * fw / (rr_time_in_ms * 1e-3) * 1e-12;

  181.         printf("RegionRestrictedDepthwiseLargeFilter vs DepthwiseLargeFilter: inp=%s, "

  182.                "kern=%s, out=%s\n"

  183.                "time: %.2f ms, time(rr): %.2f ms, perf: %.2fTops, perf(rr): %.2f Tops\n"

  184.                "bandwidth: %.2fGB/s, bandwidth(rr): %.2fGB/s, speedup: %.2f.\n",

  185.                inp.to_string().c_str(), kern.to_string().c_str(),

  186.                out.to_string().c_str(), time_in_ms, rr_time_in_ms, ops, rr_ops,

  187.                bandwith * 4 / time_in_ms, rr_bandwith * 4 / rr_time_in_ms,

  188.                time_in_ms / rr_time_in_ms);

  189.     };

  190. 

  191.     run_bench(64, 384, 32, 32, 3, 3, 1, 1, 1000);

  192.     run_bench(64, 384, 32, 32, 5, 5, 1, 1, 1000);

  193.     run_bench(64, 384, 32, 32, 7, 7, 1, 1, 1000);

  194.     run_bench(64, 384, 32, 32, 9, 9, 1, 1, 1000);

  195.     run_bench(64, 384, 32, 32, 11, 11, 1, 1, 1000);

  196.     run_bench(64, 384, 32, 32, 13, 13, 1, 1, 1000);

  197.     run_bench(64, 384, 32, 32, 15, 15, 1, 1, 1000);

  198.     run_bench(64, 384, 32, 32, 17, 17, 1, 1, 1000);

  199.     run_bench(64, 384, 32, 32, 19, 19, 1, 1, 1000);

  200.     run_bench(64, 384, 32, 32, 21, 21, 1, 1, 1000);

  201.     run_bench(64, 384, 32, 32, 23, 23, 1, 1, 1000);

  202.     run_bench(64, 384, 32, 32, 25, 25, 1, 1, 1000);

  203.     run_bench(64, 384, 32, 32, 27, 27, 1, 1, 1000);

  204.     run_bench(64, 384, 32, 32, 29, 29, 1, 1, 1000);

  205.     run_bench(64, 384, 32, 32, 31, 31, 1, 1, 1000);

  206. }

  207. 

  208. TEST_F(CUDA, BENCHMARK_REGION_RESTRICTED_CONV_BACKWARD_DATA_FP32_INT32) {

  209.     require_compute_capability(7, 5);

  210.     Benchmarker<ConvolutionBackwardData> bencher(handle_cuda());

  211.     bencher.set_display(false);

  212.     bencher.set_before_exec_callback(

  213.             AlgoChecker<ConvolutionBackwardData>("DEPTHWISE_LARGE_FILTER"));

  214. 

  215.     Benchmarker<RegionRestrictedConvolutionBackwardData> rr_bencher(handle_cuda());

  216.     rr_bencher.set_display(false);

  217. 

  218.     ConvolutionBackwardData::Param param;

  219.     param.format = ConvolutionBackwardData::Param::Format::NCHW;

  220.     param.sparse = ConvolutionBackwardData::Param::Sparse::GROUP;

  221. 

  222.     RegionRestrictedConvolutionBackwardData::Param rr_param;

  223.     rr_param.format = RegionRestrictedConvolutionBackwardData::Param::Format::NCHW;

  224.     rr_param.sparse = RegionRestrictedConvolutionBackwardData::Param::Sparse::GROUP;

  225. 

  226.     UniformIntRNG r_rng{1, 3};

  227. 

  228.     auto run_bench = [&](size_t batch, size_t g, size_t hi, size_t wi, size_t fh,

  229.                          size_t fw, size_t sh, size_t sw, size_t nr_times) {

  230.         param.pad_h = fh / 2;

  231.         param.pad_w = fw / 2;

  232.         param.stride_h = sh;

  233.         param.stride_w = sw;

  234. 

  235.         rr_param.pad_h = fh / 2;

  236.         rr_param.pad_w = fw / 2;

  237.         rr_param.stride_h = sh;

  238.         rr_param.stride_w = sw;

  239. 

  240.         bencher.set_param(param)

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

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

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

  244.                 .set_dtype(4, dtype::Float32());

  245.         bencher.set_times(nr_times);

  246. 

  247.         rr_bencher.set_param(rr_param)

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

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

  250.                 .set_dtype(2, dtype::Int32())

  251.                 .set_dtype(3, dtype::Int32());

  252.         rr_bencher.set_rng(2, &r_rng).set_rng(3, &r_rng);

  253.         rr_bencher.set_times(nr_times);

  254. 

  255.         size_t ho = infer_conv_shape(hi, fh, sh, param.pad_h);

  256.         size_t wo = infer_conv_shape(wi, fw, sw, param.pad_w);

  257.         TensorShape inp{batch, g, hi, wi} /*src*/, kern{g, 1, 1, fh, fw} /*filter*/,

  258.                 rin{batch, hi, wi}, rout{batch, ho, wo},

  259.                 out{batch, g, ho, wo} /*output*/;

  260. 

  261.         float bandwith = static_cast<float>(

  262.                                  inp.total_nr_elems() + kern.total_nr_elems() +

  263.                                  out.total_nr_elems()) /

  264.                          (1024 * 1024 * 1024) * 1e3;

  265. 

  266.         float rr_bandwith = static_cast<float>(

  267.                                     inp.total_nr_elems() + kern.total_nr_elems() +

  268.                                     rin.total_nr_elems() + rout.total_nr_elems() +

  269.                                     out.total_nr_elems()) /

  270.                             (1024 * 1024 * 1024) * 1e3;

  271. 

  272.         auto time_in_ms = bencher.execs({kern, out, inp}) / nr_times;

  273.         auto ops = 2.0 * batch * g * ho * wo * fh * fw / (time_in_ms * 1e-3) * 1e-12;

  274. 

  275.         auto rr_time_in_ms = rr_bencher.execs({kern, out, rin, rout, inp}) / nr_times;

  276.         auto rr_ops =

  277.                 2.0 * batch * g * ho * wo * fh * fw / (rr_time_in_ms * 1e-3) * 1e-12;

  278.         printf("[DGRAD]RegionRestrictedDepthwiseLargeFilter vs DepthwiseLargeFilter: "

  279.                "grad=%s, "

  280.                "kern=%s, diff=%s\n"

  281.                "time: %.2f ms, time(rr): %.2f ms, perf: %.2fTops, perf(rr): %.2f Tops\n"

  282.                "bandwidth: %.2fGB/s, bandwidth(rr): %.2fGB/s, speedup: %.2f.\n",

  283.                inp.to_string().c_str(), kern.to_string().c_str(),

  284.                out.to_string().c_str(), time_in_ms, rr_time_in_ms, ops, rr_ops,

  285.                bandwith * 4 / time_in_ms, rr_bandwith * 4 / rr_time_in_ms,

  286.                time_in_ms / rr_time_in_ms);

  287.     };

  288. 

  289.     run_bench(64, 384, 32, 32, 3, 3, 1, 1, 1000);

  290.     run_bench(64, 384, 32, 32, 5, 5, 1, 1, 1000);

  291.     run_bench(64, 384, 32, 32, 7, 7, 1, 1, 1000);

  292.     run_bench(64, 384, 32, 32, 9, 9, 1, 1, 1000);

  293.     run_bench(64, 384, 32, 32, 11, 11, 1, 1, 1000);

  294.     run_bench(64, 384, 32, 32, 13, 13, 1, 1, 1000);

  295.     run_bench(64, 384, 32, 32, 15, 15, 1, 1, 1000);

  296.     run_bench(64, 384, 32, 32, 17, 17, 1, 1, 1000);

  297.     run_bench(64, 384, 32, 32, 19, 19, 1, 1, 1000);

  298.     run_bench(64, 384, 32, 32, 21, 21, 1, 1, 1000);

  299.     run_bench(64, 384, 32, 32, 23, 23, 1, 1, 1000);

  300.     run_bench(64, 384, 32, 32, 25, 25, 1, 1, 1000);

  301.     run_bench(64, 384, 32, 32, 27, 27, 1, 1, 1000);

  302.     run_bench(64, 384, 32, 32, 29, 29, 1, 1, 1000);

  303.     run_bench(64, 384, 32, 32, 31, 31, 1, 1, 1000);

  304. }

  305. 

  306. TEST_F(CUDA, BENCHMARK_REGION_RESTRICTED_CONV_BACKWARD_DATA_FP32_UINT8) {

  307.     require_compute_capability(7, 5);

  308.     Benchmarker<ConvolutionBackwardData> bencher(handle_cuda());

  309.     bencher.set_display(false);

  310.     bencher.set_before_exec_callback(

  311.             AlgoChecker<ConvolutionBackwardData>("DEPTHWISE_LARGE_FILTER"));

  312. 

  313.     Benchmarker<RegionRestrictedConvolutionBackwardData> rr_bencher(handle_cuda());

  314.     rr_bencher.set_display(false);

  315. 

  316.     ConvolutionBackwardData::Param param;

  317.     param.format = ConvolutionBackwardData::Param::Format::NCHW;

  318.     param.sparse = ConvolutionBackwardData::Param::Sparse::GROUP;

  319. 

  320.     RegionRestrictedConvolutionBackwardData::Param rr_param;

  321.     rr_param.format = RegionRestrictedConvolutionBackwardData::Param::Format::NCHW;

  322.     rr_param.sparse = RegionRestrictedConvolutionBackwardData::Param::Sparse::GROUP;

  323. 

  324.     UniformIntRNG r_rng{1, 3};

  325. 

  326.     auto run_bench = [&](size_t batch, size_t g, size_t hi, size_t wi, size_t fh,

  327.                          size_t fw, size_t sh, size_t sw, size_t nr_times) {

  328.         param.pad_h = fh / 2;

  329.         param.pad_w = fw / 2;

  330.         param.stride_h = sh;

  331.         param.stride_w = sw;

  332. 

  333.         rr_param.pad_h = fh / 2;

  334.         rr_param.pad_w = fw / 2;

  335.         rr_param.stride_h = sh;

  336.         rr_param.stride_w = sw;

  337. 

  338.         bencher.set_param(param)

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

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

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

  342.                 .set_dtype(4, dtype::Float32());

  343.         bencher.set_times(nr_times);

  344. 

  345.         rr_bencher.set_param(rr_param)

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

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

  348.                 .set_dtype(2, dtype::Uint8())

  349.                 .set_dtype(3, dtype::Uint8());

  350.         rr_bencher.set_rng(2, &r_rng).set_rng(3, &r_rng);

  351.         rr_bencher.set_times(nr_times);

  352. 

  353.         size_t ho = infer_conv_shape(hi, fh, sh, param.pad_h);

  354.         size_t wo = infer_conv_shape(wi, fw, sw, param.pad_w);

  355.         TensorShape inp{batch, g, hi, wi} /*src*/, kern{g, 1, 1, fh, fw} /*filter*/,

  356.                 rin{batch, hi, wi}, rout{batch, ho, wo},

  357.                 out{batch, g, ho, wo} /*output*/;

  358. 

  359.         float bandwith = static_cast<float>(

  360.                                  inp.total_nr_elems() + kern.total_nr_elems() +

  361.                                  out.total_nr_elems()) /

  362.                          (1024 * 1024 * 1024) * 1e3;

  363. 

  364.         float rr_bandwith = static_cast<float>(

  365.                                     inp.total_nr_elems() + kern.total_nr_elems() +

  366.                                     rin.total_nr_elems() + rout.total_nr_elems() +

  367.                                     out.total_nr_elems()) /

  368.                             (1024 * 1024 * 1024) * 1e3;

  369. 

  370.         auto time_in_ms = bencher.execs({kern, out, inp}) / nr_times;

  371.         auto ops = 2.0 * batch * g * ho * wo * fh * fw / (time_in_ms * 1e-3) * 1e-12;

  372. 

  373.         auto rr_time_in_ms = rr_bencher.execs({kern, out, rin, rout, inp}) / nr_times;

  374.         auto rr_ops =

  375.                 2.0 * batch * g * ho * wo * fh * fw / (rr_time_in_ms * 1e-3) * 1e-12;

  376.         printf("[DGRAD]RegionRestrictedDepthwiseLargeFilter vs DepthwiseLargeFilter: "

  377.                "grad=%s, "

  378.                "kern=%s, diff=%s\n"

  379.                "time: %.2f ms, time(rr): %.2f ms, perf: %.2fTops, perf(rr): %.2f Tops\n"

  380.                "bandwidth: %.2fGB/s, bandwidth(rr): %.2fGB/s, speedup: %.2f.\n",

  381.                inp.to_string().c_str(), kern.to_string().c_str(),

  382.                out.to_string().c_str(), time_in_ms, rr_time_in_ms, ops, rr_ops,

  383.                bandwith * 4 / time_in_ms, rr_bandwith * 4 / rr_time_in_ms,

  384.                time_in_ms / rr_time_in_ms);

  385.     };

  386. 

  387.     run_bench(64, 384, 32, 32, 3, 3, 1, 1, 1000);

  388.     run_bench(64, 384, 32, 32, 5, 5, 1, 1, 1000);

  389.     run_bench(64, 384, 32, 32, 7, 7, 1, 1, 1000);

  390.     run_bench(64, 384, 32, 32, 9, 9, 1, 1, 1000);

  391.     run_bench(64, 384, 32, 32, 11, 11, 1, 1, 1000);

  392.     run_bench(64, 384, 32, 32, 13, 13, 1, 1, 1000);

  393.     run_bench(64, 384, 32, 32, 15, 15, 1, 1, 1000);

  394.     run_bench(64, 384, 32, 32, 17, 17, 1, 1, 1000);

  395.     run_bench(64, 384, 32, 32, 19, 19, 1, 1, 1000);

  396.     run_bench(64, 384, 32, 32, 21, 21, 1, 1, 1000);

  397.     run_bench(64, 384, 32, 32, 23, 23, 1, 1, 1000);

  398.     run_bench(64, 384, 32, 32, 25, 25, 1, 1, 1000);

  399.     run_bench(64, 384, 32, 32, 27, 27, 1, 1, 1000);

  400.     run_bench(64, 384, 32, 32, 29, 29, 1, 1, 1000);

  401.     run_bench(64, 384, 32, 32, 31, 31, 1, 1, 1000);

  402.     run_bench(64, 384, 31, 31, 3, 3, 1, 1, 1000);

  403.     run_bench(64, 384, 31, 31, 5, 5, 1, 1, 1000);

  404.     run_bench(64, 384, 31, 31, 7, 7, 1, 1, 1000);

  405.     run_bench(64, 384, 31, 31, 9, 9, 1, 1, 1000);

  406.     run_bench(64, 384, 31, 31, 11, 11, 1, 1, 1000);

  407.     run_bench(64, 384, 31, 31, 13, 13, 1, 1, 1000);

  408.     run_bench(64, 384, 31, 31, 15, 15, 1, 1, 1000);

  409.     run_bench(64, 384, 31, 31, 17, 17, 1, 1, 1000);

  410.     run_bench(64, 384, 31, 31, 19, 19, 1, 1, 1000);

  411.     run_bench(64, 384, 31, 31, 21, 21, 1, 1, 1000);

  412.     run_bench(64, 384, 31, 31, 23, 23, 1, 1, 1000);

  413.     run_bench(64, 384, 31, 31, 25, 25, 1, 1, 1000);

  414.     run_bench(64, 384, 31, 31, 27, 27, 1, 1, 1000);

  415.     run_bench(64, 384, 31, 31, 29, 29, 1, 1, 1000);

  416.     run_bench(64, 384, 31, 31, 31, 31, 1, 1, 1000);

  417. }

  418. 

  419. TEST_F(CUDA, BENCHMARK_REGION_RESTRICTED_CONV_FORWARD_LARGE_FILTER_UINT8) {

  420.     require_compute_capability(7, 5);

  421.     Benchmarker<ConvBiasForward> bencher(handle_cuda());

  422.     bencher.set_display(false);

  423.     bencher.set_before_exec_callback(conv_bias::ConvBiasAlgoChecker<ConvBiasForward>(

  424.             ConvBiasForward::algo_name<ConvBiasForward::DirectParam>(

  425.                     "DEPTHWISE_LARGE_FILTER", {})

  426.                     .c_str()));

  427. 

  428.     Benchmarker<RegionRestrictedConvolutionForward> rr_bencher(handle_cuda());

  429.     rr_bencher.set_display(false);

  430. 

  431.     ConvBias::Param param;

  432.     param.format = ConvBias::Param::Format::NCHW;

  433.     using NonlineMode = ConvBias::Param::NonlineMode;

  434.     param.nonlineMode = NonlineMode::IDENTITY;

  435.     param.sparse = ConvBias::Param::Sparse::GROUP;

  436. 

  437.     RegionRestrictedConvolutionForward::Param rr_param;

  438.     rr_param.format = RegionRestrictedConvolutionForward::Param::Format::NCHW;

  439.     rr_param.sparse = RegionRestrictedConvolutionForward::Param::Sparse::GROUP;

  440. 

  441.     UniformIntRNG r_rng{0, 2};

  442. 

  443.     auto run_bench = [&](size_t batch, size_t g, size_t hi, size_t wi, size_t fh,

  444.                          size_t fw, size_t sh, size_t sw, size_t nr_times) {

  445.         param.pad_h = fh / 2;

  446.         param.pad_w = fw / 2;

  447.         param.stride_h = sh;

  448.         param.stride_w = sw;

  449. 

  450.         rr_param.pad_h = fh / 2;

  451.         rr_param.pad_w = fw / 2;

  452.         rr_param.stride_h = sh;

  453.         rr_param.stride_w = sw;

  454. 

  455.         bencher.set_param(param)

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

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

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

  459.                 .set_dtype(4, dtype::Float32());

  460.         bencher.set_times(nr_times);

  461. 

  462.         rr_bencher.set_param(rr_param)

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

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

  465.                 .set_dtype(2, dtype::Uint8())

  466.                 .set_dtype(3, dtype::Uint8());

  467.         rr_bencher.set_rng(2, &r_rng).set_rng(3, &r_rng).set_rng(0, &r_rng);

  468.         rr_bencher.set_times(nr_times);

  469. 

  470.         size_t ho = infer_conv_shape(hi, fh, sh, param.pad_h);

  471.         size_t wo = infer_conv_shape(wi, fw, sw, param.pad_w);

  472.         TensorShape inp{batch, g, hi, wi}, kern{g, 1, 1, fh, fw}, rin{batch, hi, wi},

  473.                 rout{batch, ho, wo}, out{batch, g, ho, wo};

  474. 

  475.         float bandwith = static_cast<float>(

  476.                                  inp.total_nr_elems() + kern.total_nr_elems() +

  477.                                  out.total_nr_elems()) /

  478.                          (1024 * 1024 * 1024) * 1e3;

  479. 

  480.         float rr_bandwith = static_cast<float>(

  481.                                     inp.total_nr_elems() + kern.total_nr_elems() +

  482.                                     rin.total_nr_elems() + rout.total_nr_elems() +

  483.                                     out.total_nr_elems()) /

  484.                             (1024 * 1024 * 1024) * 1e3;

  485. 

  486.         auto time_in_ms = bencher.execs({inp, kern, {}, {}, out}) / nr_times;

  487.         auto ops = 2.0 * batch * g * ho * wo * fh * fw / (time_in_ms * 1e-3) * 1e-12;

  488. 

  489.         auto rr_time_in_ms = rr_bencher.execs({inp, kern, rin, rout, out}) / nr_times;

  490.         auto rr_ops =

  491.                 2.0 * batch * g * ho * wo * fh * fw / (rr_time_in_ms * 1e-3) * 1e-12;

  492.         printf("RegionRestrictedDepthwiseLargeFilter vs DepthwiseLargeFilter: inp=%s, "

  493.                "kern=%s, out=%s\n"

  494.                "time: %.2f ms, time(rr): %.2f ms, perf: %.2fTops, perf(rr): %.2f Tops\n"

  495.                "bandwidth: %.2fGB/s, bandwidth(rr): %.2fGB/s, speedup: %.2f.\n",

  496.                inp.to_string().c_str(), kern.to_string().c_str(),

  497.                out.to_string().c_str(), time_in_ms, rr_time_in_ms, ops, rr_ops,

  498.                bandwith * 4 / time_in_ms, rr_bandwith * 4 / rr_time_in_ms,

  499.                time_in_ms / rr_time_in_ms);

  500.     };

  501. 

  502.     run_bench(64, 384, 32, 32, 3, 3, 1, 1, 1000);

  503.     run_bench(64, 384, 32, 32, 5, 5, 1, 1, 1000);

  504.     run_bench(64, 384, 32, 32, 7, 7, 1, 1, 1000);

  505.     run_bench(64, 384, 32, 32, 9, 9, 1, 1, 1000);

  506.     run_bench(64, 384, 32, 32, 11, 11, 1, 1, 1000);

  507.     run_bench(64, 384, 32, 32, 13, 13, 1, 1, 1000);

  508.     run_bench(64, 384, 32, 32, 15, 15, 1, 1, 1000);

  509.     run_bench(64, 384, 32, 32, 17, 17, 1, 1, 1000);

  510.     run_bench(64, 384, 32, 32, 19, 19, 1, 1, 1000);

  511.     run_bench(64, 384, 32, 32, 21, 21, 1, 1, 1000);

  512.     run_bench(64, 384, 32, 32, 23, 23, 1, 1, 1000);

  513.     run_bench(64, 384, 32, 32, 25, 25, 1, 1, 1000);

  514.     run_bench(64, 384, 32, 32, 27, 27, 1, 1, 1000);

  515.     run_bench(64, 384, 32, 32, 29, 29, 1, 1, 1000);

  516.     run_bench(64, 384, 32, 32, 31, 31, 1, 1, 1000);

  517.     run_bench(64, 384, 31, 31, 3, 3, 1, 1, 1000);

  518.     run_bench(64, 384, 31, 31, 5, 5, 1, 1, 1000);

  519.     run_bench(64, 384, 31, 31, 7, 7, 1, 1, 1000);

  520.     run_bench(64, 384, 31, 31, 9, 9, 1, 1, 1000);

  521.     run_bench(64, 384, 31, 31, 11, 11, 1, 1, 1000);

  522.     run_bench(64, 384, 31, 31, 13, 13, 1, 1, 1000);

  523.     run_bench(64, 384, 31, 31, 15, 15, 1, 1, 1000);

  524.     run_bench(64, 384, 31, 31, 17, 17, 1, 1, 1000);

  525.     run_bench(64, 384, 31, 31, 19, 19, 1, 1, 1000);

  526.     run_bench(64, 384, 31, 31, 21, 21, 1, 1, 1000);

  527.     run_bench(64, 384, 31, 31, 23, 23, 1, 1, 1000);

  528.     run_bench(64, 384, 31, 31, 25, 25, 1, 1, 1000);

  529.     run_bench(64, 384, 31, 31, 27, 27, 1, 1, 1000);

  530.     run_bench(64, 384, 31, 31, 29, 29, 1, 1, 1000);

  531.     run_bench(64, 384, 31, 31, 31, 31, 1, 1, 1000);

  532. }

  533. 

  534. TEST_F(CUDA, BENCHMARK_REGION_RESTRICTED_CONV_BACKWARD_FILTER_FP32) {

  535.     require_compute_capability(7, 5);

  536. 

  537.     Benchmarker<ConvolutionBackwardFilter> bencher(handle_cuda());

  538. 

  539.     bencher.set_display(false);

  540.     bencher.set_before_exec_callback(AlgoChecker<ConvolutionBackwardFilter>(

  541.             "FLOAT32_NCHW_FMA_IMPLICIT_BATCHED_GEMM_128X128X8_32X64X8_2stage"));

  542. 

  543.     Benchmarker<RegionRestrictedConvolutionBackwardFilter> rr_bencher(handle_cuda());

  544.     rr_bencher.set_display(false);

  545. 

  546.     ConvolutionBackwardFilter::Param param;

  547.     param.format = ConvolutionBackwardFilter::Param::Format::NCHW;

  548.     param.sparse = ConvolutionBackwardFilter::Param::Sparse::GROUP;

  549. 

  550.     RegionRestrictedConvolutionBackwardFilter::Param rr_param;

  551.     rr_param.format = RegionRestrictedConvolutionBackwardFilter::Param::Format::NCHW;

  552.     rr_param.sparse = RegionRestrictedConvolutionBackwardFilter::Param::Sparse::GROUP;

  553. 

  554.     UniformIntRNG r_rng{1, 3};

  555. 

  556.     auto run_bench = [&](size_t batch, size_t g, size_t hi, size_t wi, size_t fh,

  557.                          size_t fw, size_t sh, size_t sw, size_t nr_times) {

  558.         param.pad_h = fh / 2;

  559.         param.pad_w = fw / 2;

  560.         param.stride_h = sh;

  561.         param.stride_w = sw;

  562. 

  563.         rr_param.pad_h = fh / 2;

  564.         rr_param.pad_w = fw / 2;

  565.         rr_param.stride_h = sh;

  566.         rr_param.stride_w = sw;

  567. 

  568.         bencher.set_param(param)

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

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

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

  572.                 .set_dtype(4, dtype::Float32());

  573.         bencher.proxy()->target_execution_policy = {};

  574.         bencher.set_times(nr_times);

  575. 

  576.         rr_bencher.set_param(rr_param)

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

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

  579.                 .set_dtype(2, dtype::Int32())

  580.                 .set_dtype(3, dtype::Int32());

  581.         rr_bencher.set_rng(2, &r_rng).set_rng(3, &r_rng);

  582.         rr_bencher.set_times(nr_times);

  583. 

  584.         size_t ho = infer_conv_shape(hi, fh, sh, param.pad_h);

  585.         size_t wo = infer_conv_shape(wi, fw, sw, param.pad_w);

  586.         TensorShape src{batch, g, hi, wi}, diff{batch, g, ho, wo}, rin{batch, hi, wi},

  587.                 rout{batch, ho, wo}, grad{g, 1, 1, fh, fw};

  588. 

  589.         float bandwith = static_cast<float>(

  590.                                  src.total_nr_elems() + diff.total_nr_elems() +

  591.                                  grad.total_nr_elems()) /

  592.                          (1024 * 1024 * 1024) * 1e3;

  593. 

  594.         float rr_bandwith = static_cast<float>(

  595.                                     src.total_nr_elems() + diff.total_nr_elems() +

  596.                                     rin.total_nr_elems() + rout.total_nr_elems() +

  597.                                     grad.total_nr_elems()) /

  598.                             (1024 * 1024 * 1024) * 1e3;

  599. 

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

  601.         auto ops = 2.0 * batch * g * hi * wi * fh * fw / (time_in_ms * 1e-3) * 1e-12;

  602. 

  603.         auto rr_time_in_ms = rr_bencher.execs({src, diff, rin, rout, grad}) / nr_times;

  604.         auto rr_ops =

  605.                 2.0 * batch * g * hi * wi * fh * fw / (rr_time_in_ms * 1e-3) * 1e-12;

  606.         printf("[WGRAD]RegionRestrictedDepthwiseLargeFilter vs DepthwiseLargeFilter: "

  607.                "src=%s, "

  608.                "diff=%s, grad=%s\n"

  609.                "time: %.2f ms, time(rr): %.2f ms, perf: %.2fTops, perf(rr): %.2f Tops\n"

  610.                "bandwidth: %.2fGB/s, bandwidth(rr): %.2fGB/s, speedup: %.2f.\n",

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

  612.                grad.to_string().c_str(), time_in_ms, rr_time_in_ms, ops, rr_ops,

  613.                bandwith * 4 / time_in_ms, rr_bandwith * 4 / rr_time_in_ms,

  614.                time_in_ms / rr_time_in_ms);

  615.     };

  616. 

  617.     run_bench(64, 384, 32, 32, 3, 3, 1, 1, 1000);

  618.     run_bench(64, 384, 32, 32, 5, 5, 1, 1, 1000);

  619.     run_bench(64, 384, 32, 32, 7, 7, 1, 1, 1000);

  620.     run_bench(64, 384, 32, 32, 9, 9, 1, 1, 1000);

  621.     run_bench(64, 384, 32, 32, 11, 11, 1, 1, 1000);

  622.     run_bench(64, 384, 32, 32, 13, 13, 1, 1, 1000);

  623.     run_bench(64, 384, 32, 32, 15, 15, 1, 1, 1000);

  624.     run_bench(64, 384, 32, 32, 17, 17, 1, 1, 1000);

  625.     run_bench(64, 384, 32, 32, 19, 19, 1, 1, 1000);

  626.     run_bench(64, 384, 32, 32, 21, 21, 1, 1, 1000);

  627.     run_bench(64, 384, 32, 32, 23, 23, 1, 1, 1000);

  628.     run_bench(64, 384, 32, 32, 25, 25, 1, 1, 1000);

  629.     run_bench(64, 384, 32, 32, 27, 27, 1, 1, 1000);

  630.     run_bench(64, 384, 32, 32, 29, 29, 1, 1, 1000);

  631.     run_bench(64, 384, 32, 32, 31, 31, 1, 1, 1000);

  632. }

  633. 

  634. TEST_F(CUDA, BENCHMARK_REGION_RESTRICTED_CONV_BACKWARD_FILTER_FP32_RINT8) {

  635.     require_compute_capability(7, 5);

  636. 

  637.     Benchmarker<ConvolutionBackwardFilter> bencher(handle_cuda());

  638. 

  639.     bencher.set_display(false);

  640.     bencher.set_before_exec_callback(AlgoChecker<ConvolutionBackwardFilter>(

  641.             "FLOAT32_NCHW_FMA_IMPLICIT_BATCHED_GEMM_128X128X8_32X64X8_2stage"));

  642. 

  643.     Benchmarker<RegionRestrictedConvolutionBackwardFilter> rr_bencher(handle_cuda());

  644.     rr_bencher.set_display(false);

  645. 

  646.     ConvolutionBackwardFilter::Param param;

  647.     param.format = ConvolutionBackwardFilter::Param::Format::NCHW;

  648.     param.sparse = ConvolutionBackwardFilter::Param::Sparse::GROUP;

  649. 

  650.     RegionRestrictedConvolutionBackwardFilter::Param rr_param;

  651.     rr_param.format = RegionRestrictedConvolutionBackwardFilter::Param::Format::NCHW;

  652.     rr_param.sparse = RegionRestrictedConvolutionBackwardFilter::Param::Sparse::GROUP;

  653. 

  654.     UniformIntRNG r_rng{1, 3};

  655. 

  656.     auto run_bench = [&](size_t batch, size_t g, size_t hi, size_t wi, size_t fh,

  657.                          size_t fw, size_t sh, size_t sw, size_t nr_times) {

  658.         param.pad_h = fh / 2;

  659.         param.pad_w = fw / 2;

  660.         param.stride_h = sh;

  661.         param.stride_w = sw;

  662. 

  663.         rr_param.pad_h = fh / 2;

  664.         rr_param.pad_w = fw / 2;

  665.         rr_param.stride_h = sh;

  666.         rr_param.stride_w = sw;

  667. 

  668.         bencher.set_param(param)

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

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

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

  672.                 .set_dtype(4, dtype::Float32());

  673.         bencher.proxy()->target_execution_policy = {};

  674.         bencher.set_times(nr_times);

  675. 

  676.         rr_bencher.set_param(rr_param)

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

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

  679.                 .set_dtype(2, dtype::Uint8())

  680.                 .set_dtype(3, dtype::Uint8());

  681.         rr_bencher.set_rng(2, &r_rng).set_rng(3, &r_rng);

  682.         rr_bencher.set_times(nr_times);

  683. 

  684.         size_t ho = infer_conv_shape(hi, fh, sh, param.pad_h);

  685.         size_t wo = infer_conv_shape(wi, fw, sw, param.pad_w);

  686.         TensorShape src{batch, g, hi, wi}, diff{batch, g, ho, wo}, rin{batch, hi, wi},

  687.                 rout{batch, ho, wo}, grad{g, 1, 1, fh, fw};

  688. 

  689.         float bandwith = static_cast<float>(

  690.                                  src.total_nr_elems() + diff.total_nr_elems() +

  691.                                  grad.total_nr_elems()) /

  692.                          (1024 * 1024 * 1024) * 1e3;

  693. 

  694.         float rr_bandwith = static_cast<float>(

  695.                                     src.total_nr_elems() + diff.total_nr_elems() +

  696.                                     rin.total_nr_elems() + rout.total_nr_elems() +

  697.                                     grad.total_nr_elems()) /

  698.                             (1024 * 1024 * 1024) * 1e3;

  699. 

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

  701.         auto ops = 2.0 * batch * g * hi * wi * fh * fw / (time_in_ms * 1e-3) * 1e-12;

  702. 

  703.         auto rr_time_in_ms = rr_bencher.execs({src, diff, rin, rout, grad}) / nr_times;

  704.         auto rr_ops =

  705.                 2.0 * batch * g * hi * wi * fh * fw / (rr_time_in_ms * 1e-3) * 1e-12;

  706.         printf("[WGRAD]RegionRestrictedDepthwiseLargeFilter vs DepthwiseLargeFilter: "

  707.                "src=%s, "

  708.                "diff=%s, grad=%s\n"

  709.                "time: %.2f ms, time(rr): %.2f ms, perf: %.2fTops, perf(rr): %.2f Tops\n"

  710.                "bandwidth: %.2fGB/s, bandwidth(rr): %.2fGB/s, speedup: %.2f.\n",

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

  712.                grad.to_string().c_str(), time_in_ms, rr_time_in_ms, ops, rr_ops,

  713.                bandwith * 4 / time_in_ms, rr_bandwith * 4 / rr_time_in_ms,

  714.                time_in_ms / rr_time_in_ms);

  715.     };

  716. 

  717.     run_bench(64, 384, 32, 32, 3, 3, 1, 1, 1000);

  718.     run_bench(64, 384, 32, 32, 5, 5, 1, 1, 1000);

  719.     run_bench(64, 384, 32, 32, 7, 7, 1, 1, 1000);

  720.     run_bench(64, 384, 32, 32, 9, 9, 1, 1, 1000);

  721.     run_bench(64, 384, 32, 32, 11, 11, 1, 1, 1000);

  722.     run_bench(64, 384, 32, 32, 13, 13, 1, 1, 1000);

  723.     run_bench(64, 384, 32, 32, 15, 15, 1, 1, 1000);

  724.     run_bench(64, 384, 32, 32, 17, 17, 1, 1, 1000);

  725.     run_bench(64, 384, 32, 32, 19, 19, 1, 1, 1000);

  726.     run_bench(64, 384, 32, 32, 21, 21, 1, 1, 1000);

  727.     run_bench(64, 384, 32, 32, 23, 23, 1, 1, 1000);

  728.     run_bench(64, 384, 32, 32, 25, 25, 1, 1, 1000);

  729.     run_bench(64, 384, 32, 32, 27, 27, 1, 1, 1000);

  730.     run_bench(64, 384, 32, 32, 29, 29, 1, 1, 1000);

  731.     run_bench(64, 384, 32, 32, 31, 31, 1, 1, 1000);

  732. }

  733. 

  734. #endif

  735. 

  736. TEST_F(CUDA, REGION_RESTRICTED_CONV_BWD_DATA_FP32) {

  737.     Checker<RegionRestrictedConvolutionBackwardData> checker(handle_cuda());

  738. 

  739.     for (auto dt : std::vector<DType>{dtype::Int32(), dtype::Uint8()}) {

  740.         auto run = [&checker, &dt](

  741.                            size_t n, size_t g, size_t ih, size_t fh, size_t padding,

  742.                            size_t stride) {

  743.             RegionRestrictedConvolutionBackwardData::Param cur_param;

  744.             cur_param.mode = RegionRestrictedConvolutionBackwardData::Param::Mode::

  745.                     CROSS_CORRELATION;

  746.             cur_param.compute_mode = RegionRestrictedConvolutionBackwardData::Param::

  747.                     ComputeMode::DEFAULT;

  748.             cur_param.sparse =

  749.                     RegionRestrictedConvolutionBackwardData::Param::Sparse::GROUP;

  750.             checker.set_dtype(0, dtype::Float32())

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

  752.                     .set_dtype(2, dt)

  753.                     .set_dtype(3, dt);

  754.             float scale = 64.f / sqrt(fh * fh);

  755.             UniformFloatRNG rng(scale, 2 * scale);

  756.             UniformIntRNG r_rng{1, 2};

  757.             checker.set_rng(0, &rng).set_rng(1, &rng).set_rng(2, &r_rng).set_rng(

  758.                     3, &r_rng);

  759.             cur_param.pad_h = cur_param.pad_w = padding;

  760.             cur_param.stride_h = cur_param.stride_w = stride;

  761. 

  762.             size_t oh = (ih + 2 * padding - fh + 1) / stride;

  763.             checker.set_param(cur_param).execs({

  764.                     {g, 1, 1, fh, fh},   // filter

  765.                     {n, g * 1, oh, oh},  // diff

  766.                     {n, ih, ih},         // rin

  767.                     {n, oh, oh},         // rout

  768.                     {n, g * 1, ih, ih}   // grad

  769.             });

  770.         };

  771.         run(1, 1, 3, 2, 1, 1);

  772.         run(1, 1, 5, 2, 1, 1);

  773.         run(1, 1, 6, 2, 1, 1);

  774.         run(1, 1, 7, 2, 1, 1);

  775.         run(1, 1, 9, 2, 1, 1);

  776.         run(1, 1, 10, 2, 1, 1);

  777.         run(1, 1, 11, 2, 1, 1);

  778.         run(1, 1, 13, 2, 1, 1);

  779.         run(1, 1, 14, 2, 1, 1);

  780.         run(1, 1, 15, 2, 1, 1);

  781.         run(1, 1, 17, 2, 1, 1);

  782.         run(1, 1, 18, 2, 1, 1);

  783.         run(1, 1, 19, 2, 1, 1);

  784.         run(1, 1, 21, 2, 1, 1);

  785.         run(1, 1, 22, 2, 1, 1);

  786.         run(1, 1, 23, 2, 1, 1);

  787.         run(1, 1, 25, 2, 1, 1);

  788.         run(1, 1, 26, 2, 1, 1);

  789.         run(1, 1, 27, 2, 1, 1);

  790.         run(1, 1, 29, 2, 1, 1);

  791.         run(1, 1, 30, 2, 1, 1);

  792.         run(1, 1, 31, 2, 1, 1);

  793.         run(4, 8, 32, 3, 3 / 2, 1);

  794.         run(4, 8, 32, 5, 5 / 2, 1);

  795.         run(4, 8, 32, 7, 7 / 2, 1);

  796.         run(4, 8, 32, 9, 9 / 2, 1);

  797.         run(4, 8, 32, 11, 11 / 2, 1);

  798.         run(4, 8, 32, 13, 13 / 2, 1);

  799.         run(4, 8, 32, 15, 15 / 2, 1);

  800.         run(4, 8, 32, 17, 17 / 2, 1);

  801.         run(4, 8, 32, 19, 19 / 2, 1);

  802.         run(4, 8, 32, 21, 21 / 2, 1);

  803.         run(4, 8, 32, 23, 23 / 2, 1);

  804.         run(4, 8, 32, 25, 25 / 2, 1);

  805.         run(4, 8, 32, 27, 27 / 2, 1);

  806.         run(4, 8, 32, 29, 29 / 2, 1);

  807.         run(4, 8, 32, 31, 31 / 2, 1);

  808.         run(4, 8, 31, 3, 3 / 2, 1);

  809.         run(4, 8, 31, 5, 5 / 2, 1);

  810.         run(4, 8, 31, 7, 7 / 2, 1);

  811.         run(4, 8, 31, 9, 9 / 2, 1);

  812.         run(4, 8, 31, 11, 11 / 2, 1);

  813.         run(4, 8, 31, 13, 13 / 2, 1);

  814.         run(4, 8, 31, 15, 15 / 2, 1);

  815.         run(4, 8, 31, 17, 17 / 2, 1);

  816.         run(4, 8, 31, 19, 19 / 2, 1);

  817.         run(4, 8, 31, 21, 21 / 2, 1);

  818.         run(4, 8, 31, 23, 23 / 2, 1);

  819.         run(4, 8, 31, 25, 25 / 2, 1);

  820.         run(4, 8, 31, 27, 27 / 2, 1);

  821.         run(4, 8, 31, 29, 29 / 2, 1);

  822.         run(4, 8, 31, 31, 31 / 2, 1);

  823.     }

  824. }

  825. 

  826. TEST_F(CUDA, REGION_RESTRICTED_CONV_BWD_DATA_FP32_RIN_EQ_ROUT) {

  827.     Checker<RegionRestrictedConvolutionBackwardData> checker(handle_cuda());

  828. 

  829.     for (auto dt : std::vector<DType>{dtype::Int32()}) {

  830.         auto run = [&checker, &dt](

  831.                            size_t n, size_t g, size_t ih, size_t fh, size_t padding,

  832.                            size_t stride) {

  833.             RegionRestrictedConvolutionBackwardData::Param cur_param;

  834.             cur_param.mode = RegionRestrictedConvolutionBackwardData::Param::Mode::

  835.                     CROSS_CORRELATION;

  836.             cur_param.compute_mode = RegionRestrictedConvolutionBackwardData::Param::

  837.                     ComputeMode::DEFAULT;

  838.             cur_param.sparse =

  839.                     RegionRestrictedConvolutionBackwardData::Param::Sparse::GROUP;

  840.             checker.set_dtype(2, dt).set_dtype(3, dt);

  841.             float scale = 64.f / sqrt(fh * fh);

  842.             UniformFloatRNG rng(scale, 2 * scale);

  843.             // value 0 mask may cause unexpected behaviour.

  844.             UniformIntRNG r_rng{1, 1};

  845.             checker.set_rng(0, &rng).set_rng(1, &rng).set_rng(2, &r_rng).set_rng(

  846.                     3, &r_rng);

  847.             cur_param.pad_h = cur_param.pad_w = padding;

  848.             cur_param.stride_h = cur_param.stride_w = stride;

  849. 

  850.             size_t oh = (ih + 2 * padding - fh + 1) / stride;

  851.             checker.set_param(cur_param).execs(

  852.                     {/*filter*/ {g, 1, 1, fh, fh},

  853.                      /*diff*/ {n, g * 1, oh, oh},

  854.                      /*rin*/ {n, ih, ih},

  855.                      /*rout*/ {n, oh, oh},

  856.                      /*grad*/ {n, g * 1, ih, ih}});

  857.         };

  858.         run(1, 1, 3, 2, 1, 1);

  859.         run(1, 1, 5, 2, 1, 1);

  860.         run(1, 1, 6, 2, 1, 1);

  861.         run(1, 1, 7, 2, 1, 1);

  862.         run(1, 1, 9, 2, 1, 1);

  863.         run(1, 1, 10, 2, 1, 1);

  864.         run(1, 1, 11, 2, 1, 1);

  865.         run(1, 1, 13, 2, 1, 1);

  866.         run(1, 1, 14, 2, 1, 1);

  867.         run(1, 1, 15, 2, 1, 1);

  868.         run(1, 1, 17, 2, 1, 1);

  869.         run(1, 1, 18, 2, 1, 1);

  870.         run(1, 1, 19, 2, 1, 1);

  871.         run(1, 1, 21, 2, 1, 1);

  872.         run(1, 1, 22, 2, 1, 1);

  873.         run(1, 1, 23, 2, 1, 1);

  874.         run(1, 1, 25, 2, 1, 1);

  875.         run(1, 1, 26, 2, 1, 1);

  876.         run(1, 1, 27, 2, 1, 1);

  877.         run(1, 1, 29, 2, 1, 1);

  878.         run(1, 1, 30, 2, 1, 1);

  879.         run(1, 1, 31, 2, 1, 1);

  880.         run(4, 8, 32, 3, 3 / 2, 1);

  881.         run(4, 8, 32, 5, 5 / 2, 1);

  882.         run(4, 8, 32, 7, 7 / 2, 1);

  883.         run(4, 8, 32, 9, 9 / 2, 1);

  884.         run(4, 8, 32, 11, 11 / 2, 1);

  885.         run(4, 8, 32, 13, 13 / 2, 1);

  886.         run(4, 8, 32, 15, 15 / 2, 1);

  887.         run(4, 8, 32, 17, 17 / 2, 1);

  888.         run(4, 8, 32, 19, 19 / 2, 1);

  889.         run(4, 8, 32, 21, 21 / 2, 1);

  890.         run(4, 8, 32, 23, 23 / 2, 1);

  891.         run(4, 8, 32, 25, 25 / 2, 1);

  892.         run(4, 8, 32, 27, 27 / 2, 1);

  893.         run(4, 8, 32, 29, 29 / 2, 1);

  894.         run(4, 8, 32, 31, 31 / 2, 1);

  895.         run(4, 8, 31, 3, 3 / 2, 1);

  896.         run(4, 8, 31, 5, 5 / 2, 1);

  897.         run(4, 8, 31, 7, 7 / 2, 1);

  898.         run(4, 8, 31, 9, 9 / 2, 1);

  899.         run(4, 8, 31, 11, 11 / 2, 1);

  900.         run(4, 8, 31, 13, 13 / 2, 1);

  901.         run(4, 8, 31, 15, 15 / 2, 1);

  902.         run(4, 8, 31, 17, 17 / 2, 1);

  903.         run(4, 8, 31, 19, 19 / 2, 1);

  904.         run(4, 8, 31, 21, 21 / 2, 1);

  905.         run(4, 8, 31, 23, 23 / 2, 1);

  906.         run(4, 8, 31, 25, 25 / 2, 1);

  907.         run(4, 8, 31, 27, 27 / 2, 1);

  908.         run(4, 8, 31, 29, 29 / 2, 1);

  909.         run(4, 8, 31, 31, 31 / 2, 1);

  910.     }

  911. }

  912. 

  913. TEST_F(CUDA, REGION_RESTRICTED_CONV_BWD_FILTER_FP32) {

  914.     require_compute_capability(6, 1);

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

  916. 

  917.     for (auto dt : std::vector<DType>{dtype::Int32(), dtype::Uint8()}) {

  918.         auto run = [&checker, &dt](

  919.                            size_t n, size_t g, size_t ih, size_t fh, size_t padding,

  920.                            size_t stride) {

  921.             RegionRestrictedConvolutionBackwardFilter::Param cur_param;

  922.             cur_param.mode = RegionRestrictedConvolutionBackwardFilter::Param::Mode::

  923.                     CROSS_CORRELATION;

  924.             cur_param.compute_mode = RegionRestrictedConvolutionBackwardFilter::Param::

  925.                     ComputeMode::DEFAULT;

  926.             cur_param.sparse =

  927.                     RegionRestrictedConvolutionBackwardFilter::Param::Sparse::GROUP;

  928.             checker.set_dtype(0, dtype::Float32())

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

  930.                     .set_dtype(2, dt)

  931.                     .set_dtype(3, dt);

  932.             float scale = 64.f / sqrt(fh * fh);

  933.             UniformFloatRNG rng(scale, 2 * scale);

  934.             UniformIntRNG r_rng{1, 2};

  935.             checker.set_rng(0, &rng).set_rng(1, &rng).set_rng(2, &r_rng).set_rng(

  936.                     3, &r_rng);

  937.             cur_param.pad_h = cur_param.pad_w = padding;

  938.             cur_param.stride_h = cur_param.stride_w = stride;

  939. 

  940.             size_t oh = (ih + 2 * padding - fh + 1) / stride;

  941.             checker.set_param(cur_param).execs({

  942.                     {n, g * 1, ih, ih},  // src

  943.                     {n, g * 1, oh, oh},  // diff

  944.                     {n, ih, ih},         // rin

  945.                     {n, oh, oh},         // rout

  946.                     {g, 1, 1, fh, fh}    // grad

  947.             });

  948.         };

  949.         run(4, 8, 32, 5, 5 / 2, 1);

  950.         run(1, 2, 2, 2, 0, 1);

  951.         run(1, 2, 3, 3, 0, 1);

  952.         run(1, 2, 4, 4, 0, 1);

  953.         run(1, 2, 5, 5, 0, 1);

  954.         run(1, 2, 6, 6, 0, 1);

  955.         run(1, 2, 7, 7, 0, 1);

  956.         run(4, 8, 32, 7, 7 / 2, 1);

  957.         run(4, 8, 32, 9, 9 / 2, 1);

  958.         run(4, 8, 32, 11, 11 / 2, 1);

  959.         run(4, 8, 32, 13, 13 / 2, 1);

  960.         run(4, 8, 32, 15, 15 / 2, 1);

  961.         run(4, 8, 32, 17, 17 / 2, 1);

  962.         run(4, 8, 32, 19, 19 / 2, 1);

  963.         run(4, 8, 32, 21, 21 / 2, 1);

  964.         run(4, 8, 32, 23, 23 / 2, 1);

  965.         run(4, 8, 32, 25, 25 / 2, 1);

  966.         run(4, 8, 32, 27, 27 / 2, 1);

  967.         run(4, 1, 32, 27, 27 / 2, 1);

  968.         run(4, 8, 32, 29, 29 / 2, 1);

  969.         run(4, 8, 32, 31, 31 / 2, 1);

  970.     }

  971. }

  972. 

  973. TEST_F(CUDA, REGION_RESTRICTED_CONV_BWD_FILTER_FP32_RIN_EQ_ROUT) {

  974.     require_compute_capability(6, 1);

  975.     Checker<RegionRestrictedConvolutionBackwardFilter> checker(handle_cuda());

  976. 

  977.     for (auto dt : std::vector<DType>{dtype::Int32(), dtype::Uint8()}) {

  978.         auto run = [&checker, &dt](

  979.                            size_t n, size_t g, size_t ih, size_t fh, size_t padding,

  980.                            size_t stride) {

  981.             RegionRestrictedConvolutionBackwardFilter::Param cur_param;

  982.             cur_param.mode = RegionRestrictedConvolutionBackwardFilter::Param::Mode::

  983.                     CROSS_CORRELATION;

  984.             cur_param.compute_mode = RegionRestrictedConvolutionBackwardFilter::Param::

  985.                     ComputeMode::DEFAULT;

  986.             cur_param.sparse =

  987.                     RegionRestrictedConvolutionBackwardFilter::Param::Sparse::GROUP;

  988.             checker.set_dtype(0, dtype::Float32())

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

  990.                     .set_dtype(2, dt)

  991.                     .set_dtype(3, dt);

  992.             float scale = 64.f / sqrt(fh * fh);

  993.             UniformFloatRNG rng(scale, 2 * scale);

  994.             UniformIntRNG r_rng{1, 1};

  995.             checker.set_rng(0, &rng).set_rng(1, &rng).set_rng(2, &r_rng).set_rng(

  996.                     3, &r_rng);

  997.             cur_param.pad_h = cur_param.pad_w = padding;

  998.             cur_param.stride_h = cur_param.stride_w = stride;

  999. 

  1000.             size_t oh = (ih + 2 * padding - fh + 1) / stride;

  1001.             checker.set_param(cur_param).execs({

  1002.                     {n, g * 1, ih, ih},  // src

  1003.                     {n, g * 1, oh, oh},  // diff

  1004.                     {n, ih, ih},         // rin

  1005.                     {n, oh, oh},         // rout

  1006.                     {g, 1, 1, fh, fh}    // grad

  1007.             });

  1008.         };

  1009.         run(4, 8, 32, 5, 5 / 2, 1);

  1010.         run(1, 2, 2, 2, 0, 1);

  1011.         run(1, 2, 3, 3, 0, 1);

  1012.         run(1, 2, 4, 4, 0, 1);

  1013.         run(1, 2, 5, 5, 0, 1);

  1014.         run(1, 2, 6, 6, 0, 1);

  1015.         run(1, 2, 7, 7, 0, 1);

  1016.         run(4, 8, 32, 7, 7 / 2, 1);

  1017.         run(4, 8, 32, 9, 9 / 2, 1);

  1018.         run(4, 8, 32, 11, 11 / 2, 1);

  1019.         run(4, 8, 32, 13, 13 / 2, 1);

  1020.         run(4, 8, 32, 15, 15 / 2, 1);

  1021.         run(4, 8, 32, 17, 17 / 2, 1);

  1022.         run(4, 8, 32, 19, 19 / 2, 1);

  1023.         run(4, 8, 32, 21, 21 / 2, 1);

  1024.         run(4, 1, 32, 21, 21 / 2, 1);

  1025.         run(4, 8, 32, 23, 23 / 2, 1);

  1026.         run(4, 8, 32, 25, 25 / 2, 1);

  1027.         run(4, 8, 32, 27, 27 / 2, 1);

  1028.         run(4, 8, 32, 29, 29 / 2, 1);

  1029.         run(4, 8, 32, 31, 31 / 2, 1);

  1030.     }

  1031. }

  1032. }  // namespace test

  1033. }  // namespace megdnn

  1034. 

  1035. // vim: syntax=cpp.doxygen