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

595 lines
25 kB
Raw Permalink Blame History 

  1. #include "test/arm_common/fixture.h"

  2. 

  3. #include "test/common/benchmarker.h"

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

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

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

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

  8. 

  9. namespace megdnn {

  10. namespace test {

  11. 

  12. TEST_F(ARM_COMMON, POOLING) {

  13.     using Param = param::Pooling;

  14.     // clang-format off

  15.     for (size_t ih: {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  16.     for (size_t iw: {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  17.     for (size_t p: {1, 2})

  18.     {

  19.         Param param;

  20.         param.mode = Param::Mode::MAX;

  21.         param.window_h = param.window_w = 3;

  22.         param.stride_h = param.stride_w = 2;

  23.         param.pad_h = param.pad_w = p;

  24.         Checker<Pooling> checker(handle());

  25.         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  26. 

  27.         param.mode = Param::Mode::AVERAGE;

  28.         param.window_h = param.window_w = 3;

  29.         param.stride_h = param.stride_w = 2;

  30.         param.pad_h = param.pad_w = p;

  31.         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  32. 

  33.         param.mode = Param::Mode::MAX;

  34.         param.window_h = param.window_w = 4;

  35.         param.stride_h = param.stride_w = 2;

  36.         param.pad_h = param.pad_w = p;

  37.         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  38. 

  39.         param.mode = Param::Mode::MAX;

  40.         param.window_h = param.window_w = 5;

  41.         param.stride_h = param.stride_w = 2;

  42.         param.pad_h = param.pad_w = p;

  43.         if (ih + p * 2 >= 5 && iw + p * 2 >= 5)

  44.             checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  45.     }

  46.     for (size_t ih: {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  47.     for (size_t iw: {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  48.     for (size_t p: {1, 2})

  49.     {

  50.         Param param;

  51.         param.mode = Param::Mode::AVERAGE_COUNT_EXCLUDE_PADDING;

  52.         param.window_h = param.window_w = 3;

  53.         param.stride_h = param.stride_w = 1;

  54.         param.pad_h = param.pad_w = p;

  55.         Checker<Pooling> checker(handle());

  56.         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  57.     }

  58.     // clang-format on

  59. }

  60. 

  61. TEST_F(ARM_COMMON, POOLING_RECORD) {

  62.     using Param = param::Pooling;

  63.     TaskRecordChecker<Pooling> checker(0);

  64.     // clang-format off

  65.     for (size_t ih: {2, 3, 5, 7, 11, 13, 17})

  66.     for (size_t iw: {2, 3, 5, 7, 11, 13, 17})

  67.     for (size_t p: {1, 2})

  68.     {

  69.         Param param;

  70.         param.mode = Param::Mode::MAX;

  71.         param.window_h = param.window_w = 3;

  72.         param.stride_h = param.stride_w = 2;

  73.         param.pad_h = param.pad_w = p;

  74.         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  75. 

  76.         param.mode = Param::Mode::AVERAGE;

  77.         param.window_h = param.window_w = 3;

  78.         param.stride_h = param.stride_w = 2;

  79.         param.pad_h = param.pad_w = p;

  80.         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  81. 

  82.         param.mode = Param::Mode::MAX;

  83.         param.window_h = param.window_w = 4;

  84.         param.stride_h = param.stride_w = 2;

  85.         param.pad_h = param.pad_w = p;

  86.         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  87. 

  88.         param.mode = Param::Mode::MAX;

  89.         param.window_h = param.window_w = 5;

  90.         param.stride_h = param.stride_w = 2;

  91.         param.pad_h = param.pad_w = p;

  92.         if (ih + p * 2 >= 5 && iw + p * 2 >= 5)

  93.             checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  94.     }

  95.     for (size_t ih: {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  96.     for (size_t iw: {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  97.     for (size_t p: {1, 2})

  98.     {

  99.         Param param;

  100.         param.mode = Param::Mode::AVERAGE_COUNT_EXCLUDE_PADDING;

  101.         param.window_h = param.window_w = 3;

  102.         param.stride_h = param.stride_w = 1;

  103.         param.pad_h = param.pad_w = p;

  104.         Checker<Pooling> checker(handle());

  105.         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  106.     }

  107.     // clang-format on

  108. }

  109. 

  110. TEST_F(ARM_COMMON, POOLING_INT8_W2x2_S2x2) {

  111.     // clang-format off

  112.     for (size_t ih: {2, 3, 7, 13, 52, 53, 54, 55})

  113.     for (size_t iw: {2, 3, 6, 14, 53, 54, 55, 56})

  114.     for (size_t ph: {0, 1})

  115.     for (size_t pw: {0, 1})

  116.     if (ih+2*ph >= 3 && iw+2*pw >= 3)

  117.     {

  118.         Checker<Pooling> checker(handle());

  119.         checker.set_dtype(0, dtype::Int8());

  120.         param::Pooling param;

  121.         param.mode = param::Pooling::Mode::MAX;

  122.         param.pad_h = ph;

  123.         param.pad_w = pw;

  124.         param.stride_h = param.stride_w = 2;

  125.         param.window_h = param.window_w = 2;

  126.         checker.set_param(param).exec(TensorShapeArray{{2, 3, ih, iw}, {}});

  127.     }

  128.     // clang-format on

  129. }

  130. 

  131. TEST_F(ARM_COMMON, POOLING_INT8_W3x3_S2x2) {

  132.     // clang-format off

  133.     for (size_t ih: {2, 3, 7, 13, 52, 53, 54, 55})

  134.     for (size_t iw: {2, 3, 6, 14, 53, 54, 55, 56})

  135.     for (size_t ph: {0, 1, 2})

  136.     for (size_t pw: {0, 1, 2})

  137.     if (ih+2*ph >= 3 && iw+2*pw >= 3)

  138.     {

  139.         Checker<Pooling> checker(handle());

  140.         checker.set_dtype(0, dtype::Int8());

  141.         param::Pooling param;

  142.         param.mode = param::Pooling::Mode::MAX;

  143.         param.pad_h = ph;

  144.         param.pad_w = pw;

  145.         param.stride_h = param.stride_w = 2;

  146.         param.window_h = param.window_w = 3;

  147.         checker.set_param(param).exec(TensorShapeArray{{2, 3, ih, iw}, {}});

  148.     }

  149.     // clang-format on

  150. }

  151. 

  152. #if __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

  153. TEST_F(ARM_COMMON, POOLING_FP16) {

  154.     Checker<Pooling> checker(handle());

  155.     checker.set_dtype(0, dtype::Float16{})

  156.             .set_dtype(1, dtype::Float16{})

  157.             .set_epsilon(3e-3);

  158. 

  159.     using Param = param::Pooling;

  160.     for (size_t ih : {2, 3, 5, 7, 11, 13, 17, 19, 23})

  161.         for (size_t iw : {2, 3, 5, 7, 11, 13, 17, 19, 23})

  162.             for (auto mode : {Param::Mode::AVERAGE, Param::Mode::MAX}) {

  163.                 for (size_t window : {2, 3}) {

  164.                     Param param;

  165.                     param.mode = mode;

  166.                     param.window_h = param.window_w = window;

  167.                     param.stride_h = param.stride_w = 1;

  168.                     param.pad_h = param.pad_w = window / 2;

  169.                     //! test for SH == 1 && SW == 1 && FH == FW (FH == 2 || FH

  170.                     //! == 3)

  171.                     checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  172. 

  173.                     //! test for SH = SW = 2 && FH = FW = 2

  174.                     param.stride_h = param.stride_w = 2;

  175.                     checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  176.                 }

  177.             }

  178. 

  179.     //! test for SH == 2 && SW == 2 && FH == FW == 3 max pooling

  180.     for (size_t ih : {2, 3, 7, 13, 52, 53, 54, 55})

  181.         for (size_t iw : {2, 3, 6, 14, 53, 54, 55, 56})

  182.             for (size_t ph : {0, 1, 2})

  183.                 for (size_t pw : {0, 1, 2})

  184.                     if (ih + 2 * ph >= 3 && iw + 2 * pw >= 3) {

  185.                         param::Pooling param;

  186.                         param.mode = param::Pooling::Mode::MAX;

  187.                         param.pad_h = ph;

  188.                         param.pad_w = pw;

  189.                         param.stride_h = param.stride_w = 2;

  190.                         param.window_h = param.window_w = 3;

  191.                         checker.set_param(param).exec(

  192.                                 TensorShapeArray{{2, 3, ih, iw}, {}});

  193.                     }

  194. 

  195.     //! test for SH == 2 && SW == 2 && FH = FW = 4 max pooling

  196.     for (size_t ih : {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  197.         for (size_t iw : {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  198.             for (size_t p : {1, 2}) {

  199.                 Param param;

  200.                 param.mode = Param::Mode::MAX;

  201.                 param.window_h = param.window_w = 4;

  202.                 param.stride_h = param.stride_w = 2;

  203.                 param.pad_h = param.pad_w = p;

  204.                 checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  205.             }

  206. 

  207.     //! test for SH == 2 && SW == 2 && FH = FW = 5 max pooling

  208.     for (size_t ih : {3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  209.         for (size_t iw : {3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  210.             for (size_t p : {1, 2}) {

  211.                 Param param;

  212.                 param.mode = Param::Mode::MAX;

  213.                 param.window_h = param.window_w = 5;

  214.                 param.stride_h = param.stride_w = 2;

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

  216.                 checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  217.             }

  218. }

  219. #endif

  220. 

  221. TEST_F(ARM_COMMON, POOLING_QUANTIZED) {

  222.     Checker<Pooling> checker(handle());

  223.     UniformIntRNG rng1{INT8_MIN >> 1, INT8_MAX >> 1};

  224.     UniformIntRNG rng2{0, UINT8_MAX >> 1};

  225. 

  226.     using Param = param::Pooling;

  227. 

  228.     for (auto type : std::vector<DType>{

  229.                  dtype::QuantizedS8(1.1f),

  230.                  dtype::Quantized8Asymm(1.1f, static_cast<uint8_t>(3))}) {

  231.         if (type.enumv() == DTypeEnum::QuantizedS8) {

  232.             checker.set_rng(0, &rng1);

  233.         } else {

  234.             megdnn_assert(type.enumv() == DTypeEnum::Quantized8Asymm);

  235.             checker.set_rng(0, &rng2);

  236.         }

  237.         for (size_t ih : {2, 3, 5, 7, 11, 13, 17, 19, 23, 33, 49})

  238.             for (size_t iw : {2, 3, 5, 7, 11, 13, 17, 19, 23, 33, 49})

  239.                 for (auto mode : {Param::Mode::AVERAGE, Param::Mode::MAX}) {

  240.                     for (size_t window : {2, 3}) {

  241.                         Param param;

  242.                         param.mode = mode;

  243.                         param.window_h = param.window_w = window;

  244.                         param.stride_h = param.stride_w = 1;

  245.                         param.pad_h = param.pad_w = window / 2;

  246.                         //! test for SH == 1 && SW == 1 && FH == FW (FH == 2 ||

  247.                         //! FH

  248.                         //! == 3)

  249.                         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  250. 

  251.                         //! test for SH = SW = 2 && FH = FW = 2

  252.                         param.stride_h = param.stride_w = 2;

  253.                         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  254.                     }

  255.                 }

  256. 

  257.         //! test for SH == 2 && SW == 2 && FH == FW == 3 max pooling

  258.         for (size_t ih : {2, 3, 7, 13, 52, 53, 54, 55})

  259.             for (size_t iw : {2, 3, 6, 14, 53, 54, 55, 56})

  260.                 for (size_t ph : {0, 1, 2})

  261.                     for (size_t pw : {0, 1, 2})

  262.                         if (ih + 2 * ph >= 3 && iw + 2 * pw >= 3) {

  263.                             param::Pooling param;

  264.                             param.mode = param::Pooling::Mode::MAX;

  265.                             param.pad_h = ph;

  266.                             param.pad_w = pw;

  267.                             param.window_h = param.window_w = 3;

  268.                             param.stride_h = param.stride_w = 2;

  269.                             checker.set_param(param).exec(

  270.                                     TensorShapeArray{{2, 3, ih, iw}, {}});

  271.                         }

  272. 

  273.         //! test for SH == 2 && SW == 2 && FH == FW == 4 max pooling

  274.         for (size_t ih : {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  275.             for (size_t iw :

  276.                  {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  277.                 for (size_t p : {1, 2}) {

  278.                     Param param;

  279.                     param.mode = Param::Mode::MAX;

  280.                     param.window_h = param.window_w = 4;

  281.                     param.stride_h = param.stride_w = 2;

  282.                     param.pad_h = param.pad_w = p;

  283.                     checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  284.                 }

  285. 

  286.         //! test for SH == 2 && SW == 2 && FH == FW == 5 max pooling

  287.         for (size_t ih : {3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  288.             for (size_t iw : {3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  289.                 for (size_t p : {1, 2}) {

  290.                     Param param;

  291.                     param.mode = Param::Mode::MAX;

  292.                     param.window_h = param.window_w = 5;

  293.                     param.stride_h = param.stride_w = 2;

  294.                     param.pad_h = param.pad_w = p;

  295.                     checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  296.                 }

  297.     }

  298. }

  299. 

  300. #if MEGDNN_WITH_BENCHMARK

  301. 

  302. void benchmark_nchw44_fp32(Handle* handle) {

  303.     using Param = param::Pooling;

  304.     auto run = [&](size_t n, size_t c, size_t h, size_t w, size_t filter, size_t stride,

  305.                    size_t pad, Param::Mode mode) {

  306.         Param param;

  307.         param.window_h = param.window_w = filter;

  308.         param.stride_h = param.stride_w = stride;

  309.         param.pad_h = param.pad_w = pad;

  310.         param.format = Param::Format::NCHW;

  311.         param.mode = mode;

  312.         TensorShape nchw_shape = {n, c, h, w};

  313.         TensorShape nchw44_shape = {n, c / 4, h, w, 4};

  314.         TensorLayout dst_layout;

  315.         auto opr = handle->create_operator<Pooling>();

  316.         opr->param() = param;

  317.         opr->deduce_layout({nchw_shape, dtype::Float32()}, dst_layout);

  318.         float calc_amount =

  319.                 dst_layout.total_nr_elems() * param.window_h * param.window_w;

  320. 

  321.         Benchmarker<Pooling> benchmarker_float_nchw(handle);

  322.         Benchmarker<Pooling> benchmarker_float_nchw44(handle);

  323.         Benchmarker<Pooling> benchmarker_int_nchw44(handle);

  324.         size_t RUN = 500;

  325.         auto t1 = benchmarker_float_nchw.set_display(false)

  326.                           .set_times(RUN)

  327.                           .set_param(param)

  328.                           .exec({nchw_shape, {}});

  329. 

  330.         param.format = Param::Format::NCHW44;

  331.         auto t2 = benchmarker_int_nchw44.set_display(false)

  332.                           .set_times(RUN)

  333.                           .set_param(param)

  334.                           .execl({{nchw44_shape, dtype::QuantizedS8(1.0)},

  335.                                   {{}, dtype::QuantizedS8(1.0)}});

  336.         auto t3 = benchmarker_float_nchw44.set_display(false)

  337.                           .set_times(RUN)

  338.                           .set_param(param)

  339.                           .exec({nchw44_shape, {}});

  340. 

  341.         printf("{%zu %zu %zu %zu} filter = %zu, stride = %zu pad = %zu\n"

  342.                "nchw_fp32={%.3f ms, %.3f Mflops},  "

  343.                "nchw44_int={%.3f ms, %.3f Mflops},  "

  344.                "nchw44_fp32={%.3f ms, %.3f Mflops, speed_up %f}\n\n",

  345.                n, c, h, w, filter, stride, pad, t1 / RUN,

  346.                calc_amount / (t1 / RUN * 1000), t2 / RUN,

  347.                calc_amount / (t2 / RUN * 1000), t3 / RUN,

  348.                calc_amount / (t3 / RUN * 1000), t1 / t3);

  349.     };

  350.     // Resnet50

  351.     run(1, 64, 112, 112, 3, 2, 1, param::Pooling::Mode::MAX);

  352.     run(1, 2048, 7, 7, 7, 1, 0, param::Pooling::Mode::AVERAGE);

  353. 

  354.     // VGG16

  355.     run(1, 64, 224, 224, 2, 2, 0, param::Pooling::Mode::MAX);

  356.     run(1, 128, 112, 112, 2, 2, 0, param::Pooling::Mode::MAX);

  357.     run(1, 256, 56, 56, 2, 2, 0, param::Pooling::Mode::MAX);

  358.     run(1, 512, 28, 28, 2, 2, 0, param::Pooling::Mode::MAX);

  359.     run(1, 512, 14, 14, 2, 2, 0, param::Pooling::Mode::MAX);

  360. }

  361. 

  362. TEST_F(ARM_COMMON, BENCHMARK_POOLING_NCHW44_FP32) {

  363.     benchmark_nchw44_fp32(handle());

  364. }

  365. 

  366. TEST_F(ARM_COMMON_MULTI_THREADS, BENCHMARK_POOLING_NCHW44_FP32) {

  367.     benchmark_nchw44_fp32(handle());

  368. }

  369. 

  370. TEST_F(ARM_COMMON, BENCHMARK_POOLING_INT8_W3x3_S2x2) {

  371.     using Param = param::Pooling;

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

  373.         auto handle_naive = create_cpu_handle(2);

  374.         TensorLayoutArray layouts;

  375.         layouts.emplace_back(shapes[0], dtype::Int8());

  376.         layouts.emplace_back(shapes[1], dtype::Int8());

  377.         Benchmarker<Pooling> benchmarker_naive(handle_naive.get());

  378.         Benchmarker<Pooling> benchmarker_float(handle());

  379.         Benchmarker<Pooling> benchmarker_int(handle());

  380.         size_t RUN = 10;

  381.         auto t1 = benchmarker_naive.set_display(false)

  382.                           .set_times(RUN)

  383.                           .set_param(param)

  384.                           .exec(shapes);

  385.         auto t2 = benchmarker_float.set_display(false)

  386.                           .set_times(RUN)

  387.                           .set_param(param)

  388.                           .exec(shapes);

  389.         auto t3 = benchmarker_int.set_display(false)

  390.                           .set_times(RUN)

  391.                           .set_param(param)

  392.                           .execl(layouts);

  393.         printf("naive=%.3fms float=%.3fms, int=%.3fms\n", t1 / RUN, t2 / RUN, t3 / RUN);

  394.         auto speedup = t2 / t3;

  395.         ASSERT_GE(speedup, 2.0);

  396.     };

  397.     Param param;

  398.     param.window_h = param.window_w = 3;

  399.     param.stride_h = param.stride_w = 2;

  400.     param.pad_h = param.pad_w = 1;

  401.     std::cout << "3x3 with 2x2 stride max pooling:" << std::endl;

  402.     run({{1, 3, 640, 480}, {}}, param);

  403. }

  404. 

  405. TEST_F(ARM_COMMON, BENCHMARK_POOLING_W4x4_S2x2) {

  406.     using Param = param::Pooling;

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

  408.         std::cout << "N:" << shapes[0][0] << " "

  409.                   << "IC:" << shapes[0][1] << " "

  410.                   << "IH:" << shapes[0][2] << " "

  411.                   << "IW:" << shapes[0][3] << std::endl;

  412.         auto handle_naive = create_cpu_handle(2);

  413.         Benchmarker<Pooling> benchmarker_naive(handle_naive.get());

  414.         Benchmarker<Pooling> benchmarker_float(handle());

  415.         size_t RUN = 10;

  416.         auto t1 = benchmarker_naive.set_display(false)

  417.                           .set_times(RUN)

  418.                           .set_param(param)

  419.                           .exec(shapes);

  420.         auto t2 = benchmarker_float.set_display(false)

  421.                           .set_times(RUN)

  422.                           .set_param(param)

  423.                           .exec(shapes);

  424.         TensorLayout dst_layout;

  425.         auto opr = handle()->create_operator<Pooling>();

  426.         opr->param() = param;

  427.         opr->deduce_layout({shapes[0], dtype::Float32()}, dst_layout);

  428.         float calc_amount =

  429.                 dst_layout.total_nr_elems() * param.window_h * param.window_w;

  430.         printf("naive={%.3fms, %.3fMflops}, neon={%.3fms, %.3fMflops}\n", t1 / RUN,

  431.                calc_amount / (t1 / RUN * 1000), t2 / RUN,

  432.                calc_amount / (t2 / RUN * 1000));

  433.     };

  434.     Param param;

  435.     param.window_h = param.window_w = 4;

  436.     param.stride_h = param.stride_w = 2;

  437.     param.pad_h = param.pad_w = 1;

  438.     std::cout << "4x4 with 2x2 stride max pooling:" << std::endl;

  439.     run({{1, 24, 160, 128}, {}}, param);

  440.     run({{1, 4, 240, 135}, {}}, param);

  441.     run({{1, 32, 120, 67}, {}}, param);

  442.     run({{1, 64, 60, 33}, {}}, param);

  443. }

  444. 

  445. TEST_F(ARM_COMMON, BENCHMARK_POOLING_W5x5_S2x2) {

  446.     using Param = param::Pooling;

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

  448.         std::cout << "N:" << shapes[0][0] << " "

  449.                   << "IC:" << shapes[0][1] << " "

  450.                   << "IH:" << shapes[0][2] << " "

  451.                   << "IW:" << shapes[0][3] << std::endl;

  452.         auto handle_naive = create_cpu_handle(2);

  453.         Benchmarker<Pooling> benchmarker_naive(handle_naive.get());

  454.         Benchmarker<Pooling> benchmarker_float(handle());

  455.         size_t RUN = 10;

  456.         auto t1 = benchmarker_naive.set_display(false)

  457.                           .set_times(RUN)

  458.                           .set_param(param)

  459.                           .exec(shapes);

  460.         auto t2 = benchmarker_float.set_display(false)

  461.                           .set_times(RUN)

  462.                           .set_param(param)

  463.                           .exec(shapes);

  464.         TensorLayout dst_layout;

  465.         auto opr = handle()->create_operator<Pooling>();

  466.         opr->param() = param;

  467.         opr->deduce_layout({shapes[0], dtype::Float32()}, dst_layout);

  468.         float calc_amount =

  469.                 dst_layout.total_nr_elems() * param.window_h * param.window_w;

  470.         printf("naive={%.3fms, %.3fMflops}, neon={%.3fms, %.3fMflops}\n", t1 / RUN,

  471.                calc_amount / (t1 / RUN * 1000), t2 / RUN,

  472.                calc_amount / (t2 / RUN * 1000));

  473.     };

  474.     Param param;

  475.     param.window_h = param.window_w = 5;

  476.     param.stride_h = param.stride_w = 2;

  477.     param.pad_h = param.pad_w = 1;

  478.     std::cout << "5x5 with 2x2 stride max pooling:" << std::endl;

  479.     run({{1, 24, 160, 128}, {}}, param);

  480.     run({{1, 4, 240, 135}, {}}, param);

  481.     run({{1, 32, 120, 67}, {}}, param);

  482.     run({{1, 64, 60, 33}, {}}, param);

  483. }

  484. 

  485. TEST_F(ARM_COMMON, BENCHMARK_POOLING_FP16) {

  486.     using Param = param::Pooling;

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

  488.         TensorLayoutArray layouts;

  489.         layouts.emplace_back(shapes[0], dtype::Float16());

  490.         layouts.emplace_back(shapes[1], dtype::Float16());

  491.         Benchmarker<Pooling> benchmarker_float(handle());

  492.         Benchmarker<Pooling> benchmarker_half(handle());

  493.         size_t RUN = 10;

  494.         auto tf = benchmarker_float.set_display(false)

  495.                           .set_times(RUN)

  496.                           .set_param(param)

  497.                           .exec(shapes) /

  498.                   RUN;

  499.         auto th = benchmarker_half.set_display(false)

  500.                           .set_times(RUN)

  501.                           .set_param(param)

  502.                           .execl(layouts) /

  503.                   RUN;

  504.         TensorLayout dst_layout;

  505.         auto opr = handle()->create_operator<Pooling>();

  506.         opr->param() = param;

  507.         opr->deduce_layout({shapes[0], dtype::Float32()}, dst_layout);

  508. 

  509.         float computations = dst_layout.total_nr_elems() * param.window_h *

  510.                              param.window_w / (1024.f * 1024 * 1024);

  511.         printf("float=%.3fms %f gflops, float16=%.3fms %f gflops speedup: %f\n", tf,

  512.                computations / tf * 1e3, th, computations / th * 1e3, tf / th);

  513.     };

  514.     Param param;

  515.     param.window_h = param.window_w = 2;

  516.     param.stride_h = param.stride_w = 1;

  517.     param.pad_h = param.pad_w = 1;

  518.     printf("2x2 with 1x1 stride max pooling:\n");

  519.     run({{1, 3, 640, 480}, {}}, param);

  520. 

  521.     for (size_t oh : {640, 128})

  522.         for (size_t ow : {480, 112}) {

  523.             param.window_h = param.window_w = 3;

  524.             param.stride_h = param.stride_w = 2;

  525.             param.pad_h = param.pad_w = 1;

  526.             param.mode = Param::Mode::AVERAGE;

  527.             printf("3x3 with 2x2 stride average pooling.\n");

  528.             run({{1, 3, oh, ow}, {}}, param);

  529. 

  530.             for (size_t pw : {2, 3, 4, 5}) {

  531.                 param.window_h = param.window_w = pw;

  532.                 param.stride_h = param.stride_w = 2;

  533.                 param.pad_h = param.pad_w = 1;

  534.                 param.mode = Param::Mode::MAX;

  535.                 printf("%zux%zu with 2x2 stride max pooling:\n", pw, pw);

  536.                 run({{1, 3, oh, ow}, {}}, param);

  537.             }

  538.         }

  539. }

  540. 

  541. TEST_F(ARM_COMMON, BENCHMARK_POOLING_QUANTIZED) {

  542.     using Param = param::Pooling;

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

  544.         auto handle_naive = create_cpu_handle(2);

  545.         TensorLayoutArray layouts;

  546.         layouts.emplace_back(shapes[0], dtype::QuantizedS8(1.1f));

  547.         layouts.emplace_back(shapes[1], dtype::QuantizedS8(1.1f));

  548.         Benchmarker<Pooling> benchmarker_int(handle());

  549.         Benchmarker<Pooling> benchmarker_naive(handle_naive.get());

  550.         size_t RUN = 10;

  551.         auto time_int =

  552.                 benchmarker_int.set_display(false).set_times(RUN).set_param(param).exec(

  553.                         shapes) /

  554.                 RUN;

  555.         auto time_naive = benchmarker_naive.set_display(false)

  556.                                   .set_times(RUN)

  557.                                   .set_param(param)

  558.                                   .execl(layouts) /

  559.                           RUN;

  560.         TensorLayout dst_layout;

  561.         auto opr = handle()->create_operator<Pooling>();

  562.         opr->param() = param;

  563.         opr->deduce_layout({shapes[0], dtype::QuantizedS8(1.1f)}, dst_layout);

  564. 

  565.         float computations = dst_layout.total_nr_elems() * param.window_h *

  566.                              param.window_w / (1024.f * 1024 * 1024);

  567.         printf("naive=%.3fms %f gflops, int8=%.3fms %f gflops speedup: %f\n",

  568.                time_naive, computations / time_naive * 1e3, time_int,

  569.                computations / time_int * 1e3, time_naive / time_int);

  570.     };

  571.     Param param;

  572.     param.window_h = param.window_w = 2;

  573.     param.stride_h = param.stride_w = 1;

  574.     param.pad_h = param.pad_w = 1;

  575.     printf("2x2 with 1x1 stride max pooling:\n");

  576.     run({{1, 3, 640, 480}, {}}, param);

  577. 

  578.     // clang-format off

  579.     for (size_t oh : {640, 128})

  580.     for (size_t ow : {480, 112})

  581.     for (size_t pw : {2, 3, 4, 5}) {

  582.         param.window_h = param.window_w = pw;

  583.         param.stride_h = param.stride_w = 2;

  584.         param.pad_h = param.pad_w = 1;

  585.         printf("%zux%zu with 2x2 stride max pooling:\n", pw, pw);

  586.         run({{1, 3, oh, ow}, {}}, param);

  587.     }

  588.     // clang-format on

  589. }

  590. #endif

  591. 

  592. }  // namespace test

  593. }  // namespace megdnn

  594.    // vim: syntax=cpp.doxygen