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/arm_common/conv_bias_multi_thread_benc...

2169 lines
89 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/test/arm_common/conv_bias_multi_thread_benchmark.cpp

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

  4.  *

  5.  * Copyright (c) 2014-2021 Megvii Inc. All rights reserved.

  6.  *

  7.  * Unless required by applicable law or agreed to in writing,

  8.  * software distributed under the License is distributed on an

  9.  * "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or

  10.  * implied.

  11.  */

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

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

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

  15. 

  16. using namespace megdnn;

  17. using namespace test;

  18. using namespace conv_bias;

  19. #if MEGDNN_WITH_BENCHMARK

  20. namespace {

  21. void benchmark_impl(

  22.         const param::ConvBias param,

  23.         std::vector<std::pair<SmallVector<TensorShape>, float>>& shapes_and_computation,

  24.         const std::string algo_name, size_t RUNS,

  25.         TaskExecutorConfig&& multi_thread_config,

  26.         TaskExecutorConfig&& single_thread_config, std::vector<DType>& data_type) {

  27.     std::vector<float> multi_thread_times, single_thread_times;

  28.     {

  29.         auto multi_thread_hanle = create_cpu_handle(0, true, &multi_thread_config);

  30.         auto benchmarker = Benchmarker<ConvBias>(multi_thread_hanle.get());

  31.         benchmarker.set_times(RUNS)

  32.                 .set_display(false)

  33.                 .set_param(param)

  34.                 .set_dtype(0, data_type[0])

  35.                 .set_dtype(1, data_type[1])

  36.                 .set_dtype(2, data_type[2])

  37.                 .set_dtype(4, data_type[3])

  38.                 .set_before_exec_callback(

  39.                         conv_bias::ConvBiasAlgoChecker<ConvBias>(algo_name.c_str()));

  40.         for (auto shape : shapes_and_computation) {

  41.             multi_thread_times.push_back(benchmarker.exec(shape.first) / RUNS);

  42.         }

  43.     }

  44.     {

  45.         auto single_thread_handle = create_cpu_handle(0, true, &single_thread_config);

  46.         auto benchmarker = Benchmarker<ConvBias>(single_thread_handle.get());

  47.         benchmarker.set_times(RUNS)

  48.                 .set_display(false)

  49.                 .set_param(param)

  50.                 .set_dtype(0, data_type[0])

  51.                 .set_dtype(1, data_type[1])

  52.                 .set_dtype(2, data_type[2])

  53.                 .set_dtype(4, data_type[3])

  54.                 .set_before_exec_callback(

  55.                         conv_bias::ConvBiasAlgoChecker<ConvBias>(algo_name.c_str()));

  56.         for (auto shape : shapes_and_computation) {

  57.             single_thread_times.push_back(benchmarker.exec(shape.first) / RUNS);

  58.         }

  59.     }

  60.     printf("Benchmark : Multi threads  %zu, ", multi_thread_config.nr_thread);

  61.     printf("core_ids:");

  62.     for (size_t i = 0; i < multi_thread_config.affinity_core_set.size(); i++) {

  63.         printf("%zu ", multi_thread_config.affinity_core_set[i]);

  64.     }

  65.     printf(", Single thread core_id %zu\n", single_thread_config.affinity_core_set[0]);

  66.     for (size_t i = 0; i < shapes_and_computation.size(); i++) {

  67.         auto shapes = shapes_and_computation[i];

  68.         printf("Bench case: ");

  69.         for (auto&& shape : shapes.first) {

  70.             printf("%s ", shape.to_string().c_str());

  71.         }

  72.         float computations = shapes.second;

  73.         printf("%zu threads gflops: %f,\n single thread gflops: "

  74.                "%f. spead up = %f, speedup/cores=%f\n",

  75.                multi_thread_config.nr_thread, computations / multi_thread_times[i],

  76.                computations / single_thread_times[i],

  77.                single_thread_times[i] / multi_thread_times[i],

  78.                single_thread_times[i] / multi_thread_times[i] /

  79.                        multi_thread_config.nr_thread);

  80.     }

  81. }

  82. }  // namespace

  83. 

  84. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_DIRECTF32) {

  85.     constexpr size_t RUNS = 50;

  86. 

  87.     param::ConvBias param;

  88.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  89.     param.pad_h = 1;

  90.     param.pad_w = 1;

  91.     param.stride_h = 1;

  92.     param.stride_w = 1;

  93.     param.sparse = param::ConvBias::Sparse::GROUP;

  94. 

  95.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  96.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  97.                           size_t group) {

  98.         SmallVector<TensorShape> shapes{

  99.                 {N, IC, H, W},

  100.                 {group, OC / group, IC / group, FS, FS},

  101.                 {1, OC, 1, 1},

  102.                 {},

  103.                 {N, OC, H, W}};

  104.         TensorShape dst{N, OC, H, W};

  105.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  106.                               dst.total_nr_elems()) *

  107.                              1e-6;

  108.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  109.     };

  110. 

  111.     bench_case(1, 32, 32, 200, 200, 3, 4);

  112.     bench_case(1, 32, 32, 200, 200, 3, 32);

  113.     bench_case(1, 32, 32, 128, 128, 3, 4);

  114.     bench_case(1, 32, 32, 128, 128, 3, 32);

  115.     bench_case(1, 32, 32, 100, 100, 3, 4);

  116.     bench_case(1, 32, 32, 100, 100, 3, 32);

  117.     bench_case(1, 32, 32, 80, 80, 3, 4);

  118.     bench_case(1, 32, 32, 80, 80, 3, 32);

  119. 

  120.     std::string algo_name = "F32DIRECT";

  121.     printf("Benchmark F32DIRECT_LARGE_GROUP algo\n");

  122.     std::vector<DType> data_type = {

  123.             dtype::Float32(), dtype::Float32(), dtype::Float32(), dtype::Float32()};

  124.     benchmark_impl(

  125.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  126.             data_type);

  127.     benchmark_impl(

  128.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  129.             data_type);

  130.     benchmark_impl(

  131.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  132.             data_type);

  133.     shapes_and_computation.clear();

  134. 

  135.     algo_name = "F32DIRECT";

  136.     printf("Benchmark F32DIRECT_SMALL_GROUP algo\n");

  137.     bench_case(1, 32, 32, 200, 200, 3, 1);

  138.     bench_case(1, 32, 32, 128, 128, 3, 1);

  139.     bench_case(1, 32, 32, 100, 100, 3, 1);

  140.     bench_case(1, 32, 32, 80, 80, 3, 1);

  141.     benchmark_impl(

  142.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  143.             data_type);

  144.     benchmark_impl(

  145.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  146.             data_type);

  147.     benchmark_impl(

  148.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  149.             data_type);

  150. }

  151. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_DIRECTF32_STR1) {

  152.     constexpr size_t RUNS = 50;

  153.     param::ConvBias param;

  154.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  155.     param.pad_h = 1;

  156.     param.pad_w = 1;

  157.     param.stride_h = 1;

  158.     param.stride_w = 1;

  159.     param.sparse = param::ConvBias::Sparse::GROUP;

  160. 

  161.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  162.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  163.                           size_t group) {

  164.         SmallVector<TensorShape> shapes{

  165.                 {N, IC, H, W},

  166.                 {group, OC / group, IC / group, FS, FS},

  167.                 {1, OC, 1, 1},

  168.                 {},

  169.                 {N, OC, H, W}};

  170.         TensorShape dst{N, OC, H, W};

  171.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  172.                               dst.total_nr_elems()) *

  173.                              1e-6;

  174.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  175.     };

  176. 

  177.     bench_case(1, 32, 32, 200, 200, 3, 4);

  178.     bench_case(1, 32, 32, 200, 200, 3, 32);

  179.     bench_case(1, 32, 32, 128, 128, 3, 4);

  180.     bench_case(1, 32, 32, 128, 128, 3, 32);

  181.     bench_case(1, 32, 32, 100, 100, 3, 4);

  182.     bench_case(1, 32, 32, 100, 100, 3, 32);

  183.     bench_case(1, 32, 32, 80, 80, 3, 4);

  184.     bench_case(1, 32, 32, 80, 80, 3, 32);

  185. 

  186.     std::string algo_name = "F32STRD1";

  187.     printf("Benchmark F32STRD1_LARGE_GROUP algo\n");

  188.     std::vector<DType> data_type = {

  189.             dtype::Float32(), dtype::Float32(), dtype::Float32(), dtype::Float32()};

  190.     benchmark_impl(

  191.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  192.             data_type);

  193.     benchmark_impl(

  194.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  195.             data_type);

  196.     benchmark_impl(

  197.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  198.             data_type);

  199.     shapes_and_computation.clear();

  200. 

  201.     algo_name = "F32STRD1";

  202.     printf("Benchmark F32STRD1_SMALL_GROUP algo\n");

  203.     bench_case(1, 32, 32, 200, 200, 3, 1);

  204.     bench_case(1, 32, 32, 128, 128, 3, 1);

  205.     bench_case(1, 32, 32, 100, 100, 3, 1);

  206.     bench_case(1, 32, 32, 80, 80, 3, 1);

  207.     benchmark_impl(

  208.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  209.             data_type);

  210.     benchmark_impl(

  211.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  212.             data_type);

  213.     benchmark_impl(

  214.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  215.             data_type);

  216. }

  217. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_DIRECTF32_STR2) {

  218.     constexpr size_t RUNS = 50;

  219. 

  220.     param::ConvBias param;

  221.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  222.     param.pad_h = 1;

  223.     param.pad_w = 1;

  224.     param.stride_h = 2;

  225.     param.stride_w = 2;

  226.     param.sparse = param::ConvBias::Sparse::GROUP;

  227. 

  228.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  229.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  230.                           size_t group, size_t P, size_t S) {

  231.         SmallVector<TensorShape> shapes{

  232.                 {N, IC, H, W},

  233.                 {group, OC / group, IC / group, FS, FS},

  234.                 {1, OC, 1, 1},

  235.                 {},

  236.                 {N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1}};

  237.         TensorShape dst{N, OC, H, W};

  238.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  239.                               dst.total_nr_elems()) *

  240.                              1e-6;

  241.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  242.     };

  243. 

  244.     bench_case(1, 32, 32, 200, 200, 3, 4, 1, 2);

  245.     bench_case(1, 32, 32, 200, 200, 3, 32, 1, 2);

  246.     bench_case(1, 32, 32, 128, 128, 3, 4, 1, 2);

  247.     bench_case(1, 32, 32, 128, 128, 3, 32, 1, 2);

  248.     bench_case(1, 32, 32, 100, 100, 3, 4, 1, 2);

  249.     bench_case(1, 32, 32, 100, 100, 3, 32, 1, 2);

  250.     bench_case(1, 32, 32, 80, 80, 3, 4, 1, 2);

  251.     bench_case(1, 32, 32, 80, 80, 3, 32, 1, 2);

  252. 

  253.     std::string algo_name = "F32STRD2";

  254.     printf("Benchmark F32STRD2_LARGE_GROUP algo\n");

  255.     std::vector<DType> data_type = {

  256.             dtype::Float32(), dtype::Float32(), dtype::Float32(), dtype::Float32()};

  257.     benchmark_impl(

  258.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  259.             data_type);

  260.     benchmark_impl(

  261.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  262.             data_type);

  263.     benchmark_impl(

  264.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  265.             data_type);

  266.     shapes_and_computation.clear();

  267. 

  268.     algo_name = "F32STRD2";

  269.     printf("Benchmark F32STRD2_SMALL_GROUP algo\n");

  270.     bench_case(1, 32, 32, 200, 200, 3, 1, 1, 2);

  271.     bench_case(1, 32, 32, 128, 128, 3, 1, 1, 2);

  272.     bench_case(1, 32, 32, 100, 100, 3, 1, 1, 2);

  273.     bench_case(1, 32, 32, 80, 80, 3, 1, 1, 2);

  274.     benchmark_impl(

  275.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  276.             data_type);

  277.     benchmark_impl(

  278.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  279.             data_type);

  280.     benchmark_impl(

  281.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  282.             data_type);

  283. }

  284. 

  285. #if __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

  286. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_DIRECTF16) {

  287.     constexpr size_t RUNS = 50;

  288. 

  289.     param::ConvBias param;

  290.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  291.     param.pad_h = 1;

  292.     param.pad_w = 1;

  293.     param.stride_h = 1;

  294.     param.stride_w = 1;

  295.     param.sparse = param::ConvBias::Sparse::GROUP;

  296. 

  297.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  298.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  299.                           size_t group) {

  300.         SmallVector<TensorShape> shapes{

  301.                 {N, IC, H, W},

  302.                 {group, OC / group, IC / group, FS, FS},

  303.                 {1, OC, 1, 1},

  304.                 {},

  305.                 {N, OC, H, W}};

  306.         TensorShape dst{N, OC, H, W};

  307.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  308.                               dst.total_nr_elems()) *

  309.                              1e-6;

  310.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  311.     };

  312. 

  313.     bench_case(1, 32, 32, 200, 200, 3, 4);

  314.     bench_case(1, 32, 32, 200, 200, 3, 32);

  315.     bench_case(1, 32, 32, 128, 128, 3, 4);

  316.     bench_case(1, 32, 32, 128, 128, 3, 32);

  317.     bench_case(1, 32, 32, 100, 100, 3, 4);

  318.     bench_case(1, 32, 32, 100, 100, 3, 32);

  319.     bench_case(1, 32, 32, 80, 80, 3, 4);

  320.     bench_case(1, 32, 32, 80, 80, 3, 32);

  321. 

  322.     std::string algo_name = "F16DIRECT";

  323.     printf("Benchmark F16DIRECT_LARGE_GROUP algo\n");

  324.     std::vector<DType> data_type = {

  325.             dtype::Float16(), dtype::Float16(), dtype::Float16(), dtype::Float16()};

  326.     benchmark_impl(

  327.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  328.             data_type);

  329.     benchmark_impl(

  330.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  331.             data_type);

  332.     benchmark_impl(

  333.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  334.             data_type);

  335.     shapes_and_computation.clear();

  336. 

  337.     algo_name = "F16DIRECT";

  338.     printf("Benchmark F16DIRECT_SMALL_GROUP algo\n");

  339.     bench_case(1, 32, 32, 200, 200, 3, 1);

  340.     bench_case(1, 32, 32, 128, 128, 3, 1);

  341.     bench_case(1, 32, 32, 100, 100, 3, 1);

  342.     bench_case(1, 32, 32, 80, 80, 3, 1);

  343.     benchmark_impl(

  344.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  345.             data_type);

  346.     benchmark_impl(

  347.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  348.             data_type);

  349.     benchmark_impl(

  350.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  351.             data_type);

  352. }

  353. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_DIRECTF16_STR1) {

  354.     constexpr size_t RUNS = 50;

  355. 

  356.     param::ConvBias param;

  357.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  358.     param.pad_h = 1;

  359.     param.pad_w = 1;

  360.     param.stride_h = 1;

  361.     param.stride_w = 1;

  362.     param.sparse = param::ConvBias::Sparse::GROUP;

  363. 

  364.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  365.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  366.                           size_t group) {

  367.         SmallVector<TensorShape> shapes{

  368.                 {N, IC, H, W},

  369.                 {group, OC / group, IC / group, FS, FS},

  370.                 {1, OC, 1, 1},

  371.                 {},

  372.                 {N, OC, H, W}};

  373.         TensorShape dst{N, OC, H, W};

  374.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  375.                               dst.total_nr_elems()) *

  376.                              1e-6;

  377.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  378.     };

  379. 

  380.     bench_case(1, 32, 32, 200, 200, 3, 4);

  381.     bench_case(1, 32, 32, 200, 200, 3, 32);

  382.     bench_case(1, 32, 32, 128, 128, 3, 4);

  383.     bench_case(1, 32, 32, 128, 128, 3, 32);

  384.     bench_case(1, 32, 32, 100, 100, 3, 4);

  385.     bench_case(1, 32, 32, 100, 100, 3, 32);

  386.     bench_case(1, 32, 32, 80, 80, 3, 4);

  387.     bench_case(1, 32, 32, 80, 80, 3, 32);

  388. 

  389.     std::string algo_name = "F16STRD1";

  390.     printf("Benchmark F16STRD1_LARGE_GROUP algo\n");

  391.     std::vector<DType> data_type = {

  392.             dtype::Float16(), dtype::Float16(), dtype::Float16(), dtype::Float16()};

  393.     benchmark_impl(

  394.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  395.             data_type);

  396.     benchmark_impl(

  397.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  398.             data_type);

  399.     benchmark_impl(

  400.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  401.             data_type);

  402.     shapes_and_computation.clear();

  403. 

  404.     algo_name = "F16STRD1";

  405.     printf("Benchmark F16STRD1_SMALL_GROUP algo\n");

  406.     bench_case(1, 32, 32, 200, 200, 3, 1);

  407.     bench_case(1, 32, 32, 128, 128, 3, 1);

  408.     bench_case(1, 32, 32, 100, 100, 3, 1);

  409.     bench_case(1, 32, 32, 80, 80, 3, 1);

  410.     benchmark_impl(

  411.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  412.             data_type);

  413.     benchmark_impl(

  414.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  415.             data_type);

  416.     benchmark_impl(

  417.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  418.             data_type);

  419. }

  420. 

  421. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CHANNEL_WISE_FP16_NCHW88) {

  422.     constexpr size_t RUNS = 50;

  423. 

  424.     std::string algo_name = "F16_CHANNEL_WISE_NCHW88";

  425.     printf("Benchmarker F16_CHANNEL_WISE_NCHW88 algo\n");

  426.     std::vector<DType> data_type = {

  427.             dtype::Float16(), dtype::Float16(), dtype::Float16(), dtype::Float16()};

  428. 

  429.     auto bench_case = [&](size_t N, size_t IC, size_t H, size_t W, size_t FS, size_t P,

  430.                           size_t S) {

  431.         param::ConvBias param;

  432.         param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  433.         param.pad_h = P;

  434.         param.pad_w = P;

  435.         param.stride_h = S;

  436.         param.stride_w = S;

  437.         param.sparse = param::ConvBias::Sparse::GROUP;

  438.         param.format = param::ConvBias::Format::NCHW88;

  439. 

  440.         size_t group = IC;

  441.         size_t OC = IC;

  442.         SmallVector<TensorShape> shapes{

  443.                 {N, IC, H, W, 8},

  444.                 {group, 1, 1, FS, FS, 8},

  445.                 {1, OC, 1, 1, 8},

  446.                 {},

  447.                 {N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1, 8}};

  448.         TensorShape dst{N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1, 8};

  449.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  450.                               dst.total_nr_elems()) *

  451.                              1e-6;

  452.         std::vector<std::pair<SmallVector<TensorShape>, float>> shape_arg = {

  453.                 std::make_pair(shapes, computations)};

  454. 

  455.         benchmark_impl(

  456.                 param, shape_arg, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  457.                 data_type);

  458.     };

  459. 

  460.     bench_case(1, 64, 100, 100, 5, 2, 1);

  461.     bench_case(1, 64, 56, 56, 5, 2, 1);

  462.     bench_case(1, 64, 28, 28, 5, 2, 1);

  463.     bench_case(1, 64, 100, 100, 5, 2, 2);

  464.     bench_case(1, 64, 56, 56, 5, 2, 2);

  465.     bench_case(1, 64, 28, 28, 5, 2, 2);

  466. 

  467.     bench_case(1, 64, 100, 100, 3, 1, 1);

  468.     bench_case(1, 64, 56, 56, 3, 1, 1);

  469.     bench_case(1, 64, 28, 28, 3, 1, 1);

  470.     bench_case(1, 64, 100, 100, 3, 1, 2);

  471.     bench_case(1, 64, 56, 56, 3, 1, 2);

  472.     bench_case(1, 64, 28, 28, 3, 1, 2);

  473. 

  474.     bench_case(1, 64, 100, 100, 2, 0, 1);

  475.     bench_case(1, 64, 56, 56, 2, 0, 1);

  476.     bench_case(1, 64, 28, 28, 2, 0, 1);

  477.     bench_case(1, 64, 100, 100, 2, 0, 2);

  478.     bench_case(1, 64, 56, 56, 2, 0, 2);

  479.     bench_case(1, 64, 28, 28, 2, 0, 2);

  480. }

  481. 

  482. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_FP16_NCHW88) {

  483.     constexpr size_t RUNS = 40;

  484.     std::vector<DType> data_type = {

  485.             dtype::Float16(), dtype::Float16(), dtype::Float16(), dtype::Float16()};

  486.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  487.                           size_t group, size_t P, size_t S) {

  488.         param::ConvBias param;

  489.         param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  490.         param.pad_h = P;

  491.         param.pad_w = P;

  492.         param.stride_h = S;

  493.         param.stride_w = S;

  494.         param.sparse = param::ConvBias::Sparse::DENSE;

  495.         param.format = param::ConvBias::Format::NCHW88;

  496.         auto OH = (H + 2 * P - FS) / static_cast<size_t>(S) + 1;

  497.         auto OW = (W + 2 * P - FS) / static_cast<size_t>(S) + 1;

  498.         TensorShape src = {N, IC / 8, H, W, 8};

  499.         TensorShape filter = {OC / 8, IC / 8, FS, FS, 8, 8};

  500.         if (group > 1) {

  501.             filter = {group, OC / group / 8, IC / group / 8, FS, FS, 8, 8};

  502.             param.sparse = param::ConvBias::Sparse::GROUP;

  503.         }

  504.         TensorShape bias = {1, OC / 8, 1, 1, 8};

  505.         TensorShape dst = {N, OC / 8, OH, OW, 8};

  506. 

  507.         SmallVector<TensorShape> shapes{src, filter, bias, {}, dst};

  508.         float computations = (((IC / group) * FS * FS + 1) * dst.total_nr_elems() * 2 +

  509.                               dst.total_nr_elems()) *

  510.                              1e-6;

  511.         std::vector<std::pair<SmallVector<TensorShape>, float>> shape_arg = {

  512.                 std::make_pair(shapes, computations)};

  513.         benchmark_impl(

  514.                 param, shape_arg, ".+", RUNS, {4, {4, 5, 6, 7}}, {1, {7}}, data_type);

  515.     };

  516.     bench_case(1, 64, 64, 28, 28, 3, 1, 1, 1);

  517.     bench_case(1, 64, 64, 28, 28, 5, 1, 2, 1);

  518.     bench_case(1, 64, 64, 28, 28, 7, 1, 3, 1);

  519. 

  520.     bench_case(1, 64, 64, 28, 28, 3, 1, 1, 2);

  521.     bench_case(1, 64, 64, 28, 28, 5, 1, 2, 2);

  522.     bench_case(1, 64, 64, 28, 28, 7, 1, 3, 2);

  523. 

  524.     bench_case(1, 64, 64, 28, 28, 3, 2, 1, 1);

  525.     bench_case(1, 64, 64, 28, 28, 3, 4, 1, 1);

  526.     bench_case(1, 64, 64, 28, 28, 3, 8, 1, 1);

  527. 

  528.     bench_case(1, 16, 16, 28, 28, 3, 1, 1, 1);

  529.     bench_case(1, 32, 32, 28, 28, 3, 1, 1, 1);

  530.     bench_case(1, 128, 128, 28, 28, 3, 1, 1, 1);

  531.     bench_case(1, 256, 256, 28, 28, 3, 1, 1, 1);

  532. 

  533.     bench_case(1, 64, 64, 7, 7, 3, 1, 1, 1);

  534.     bench_case(1, 64, 64, 14, 14, 3, 1, 1, 1);

  535.     bench_case(1, 64, 64, 56, 56, 3, 1, 1, 1);

  536.     bench_case(1, 64, 64, 112, 112, 3, 1, 1, 1);

  537. }

  538. 

  539. #endif

  540. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_DIRECT_INT8x8x16) {

  541.     constexpr size_t RUNS = 50;

  542. 

  543.     param::ConvBias param;

  544.     param.nonlineMode = param::ConvBias::NonlineMode::IDENTITY;

  545.     param.pad_h = 1;

  546.     param.pad_w = 1;

  547.     param.stride_h = 1;

  548.     param.stride_w = 1;

  549.     param.sparse = param::ConvBias::Sparse::GROUP;

  550. 

  551.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  552.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  553.                           size_t group) {

  554.         SmallVector<TensorShape> shapes{

  555.                 {N, IC, H, W},

  556.                 {group, OC / group, IC / group, FS, FS},

  557.                 {},

  558.                 {},

  559.                 {N, OC, H, W}};

  560.         TensorShape dst{N, OC, H, W};

  561.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  562.                               dst.total_nr_elems()) *

  563.                              1e-6;

  564.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  565.     };

  566. 

  567.     bench_case(1, 32, 32, 200, 200, 3, 4);

  568.     bench_case(1, 32, 32, 200, 200, 3, 32);

  569.     bench_case(1, 32, 32, 128, 128, 3, 4);

  570.     bench_case(1, 32, 32, 128, 128, 3, 32);

  571.     bench_case(1, 32, 32, 100, 100, 3, 4);

  572.     bench_case(1, 32, 32, 100, 100, 3, 32);

  573.     bench_case(1, 32, 32, 80, 80, 3, 4);

  574.     bench_case(1, 32, 32, 80, 80, 3, 32);

  575. 

  576.     std::string algo_name = "I8816DIRECT";

  577.     printf("Benchmark I8816DIRECT_LARGE_GROUP algo\n");

  578.     std::vector<DType> data_type = {

  579.             dtype::Int8(), dtype::Int8(), dtype::Int16(), dtype::Int16()};

  580.     benchmark_impl(

  581.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  582.             data_type);

  583.     benchmark_impl(

  584.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  585.             data_type);

  586.     benchmark_impl(

  587.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  588.             data_type);

  589.     shapes_and_computation.clear();

  590. 

  591.     algo_name = "I8816DIRECT";

  592.     printf("Benchmark I8816DIRECT_SMALL_GROUP algo\n");

  593.     bench_case(1, 32, 32, 200, 200, 3, 1);

  594.     bench_case(1, 32, 32, 128, 128, 3, 1);

  595.     bench_case(1, 32, 32, 100, 100, 3, 1);

  596.     bench_case(1, 32, 32, 80, 80, 3, 1);

  597.     benchmark_impl(

  598.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  599.             data_type);

  600.     benchmark_impl(

  601.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  602.             data_type);

  603.     benchmark_impl(

  604.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  605.             data_type);

  606. }

  607. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_DIRECT_INT8x8x16_STR2) {

  608.     constexpr size_t RUNS = 50;

  609.     param::ConvBias param;

  610.     param.nonlineMode = param::ConvBias::NonlineMode::IDENTITY;

  611.     param.pad_h = 1;

  612.     param.pad_w = 1;

  613.     param.stride_h = 2;

  614.     param.stride_w = 2;

  615.     param.sparse = param::ConvBias::Sparse::GROUP;

  616. 

  617.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  618.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  619.                           size_t group, size_t P, size_t S) {

  620.         SmallVector<TensorShape> shapes{

  621.                 {N, IC, H, W},

  622.                 {group, OC / group, IC / group, FS, FS},

  623.                 {},

  624.                 {},

  625.                 {N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1}};

  626.         TensorShape dst{N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1};

  627.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  628.                               dst.total_nr_elems()) *

  629.                              1e-6;

  630.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  631.     };

  632. 

  633.     bench_case(1, 32, 32, 200, 200, 3, 4, 1, 2);

  634.     bench_case(1, 32, 32, 200, 200, 3, 32, 1, 2);

  635.     bench_case(1, 32, 32, 128, 128, 3, 4, 1, 2);

  636.     bench_case(1, 32, 32, 128, 128, 3, 32, 1, 2);

  637.     bench_case(1, 32, 32, 100, 100, 3, 4, 1, 2);

  638.     bench_case(1, 32, 32, 100, 100, 3, 32, 1, 2);

  639.     bench_case(1, 32, 32, 80, 80, 3, 4, 1, 2);

  640.     bench_case(1, 32, 32, 80, 80, 3, 32, 1, 2);

  641. 

  642.     std::string algo_name = "I8816STRD2";

  643.     printf("Benchmark I8816STRD2_LARGE_GROUP algo\n");

  644.     std::vector<DType> data_type = {

  645.             dtype::Int8(), dtype::Int8(), dtype::Int16(), dtype::Int16()};

  646.     benchmark_impl(

  647.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  648.             data_type);

  649.     benchmark_impl(

  650.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  651.             data_type);

  652.     benchmark_impl(

  653.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  654.             data_type);

  655.     shapes_and_computation.clear();

  656. 

  657.     algo_name = "I8816STRD2";

  658.     printf("Benchmark I8816STRD2_SMALL_GROUP algo\n");

  659.     bench_case(1, 32, 32, 200, 200, 3, 1, 1, 2);

  660.     bench_case(1, 32, 32, 128, 128, 3, 1, 1, 2);

  661.     bench_case(1, 32, 32, 100, 100, 3, 1, 1, 2);

  662.     bench_case(1, 32, 32, 80, 80, 3, 1, 1, 2);

  663.     benchmark_impl(

  664.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  665.             data_type);

  666.     benchmark_impl(

  667.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  668.             data_type);

  669.     benchmark_impl(

  670.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  671.             data_type);

  672. }

  673. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_INT8_INT8_INT8_STRIDE1) {

  674.     constexpr size_t RUNS = 50;

  675. 

  676.     param::ConvBias param;

  677.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  678.     param.pad_h = 1;

  679.     param.pad_w = 1;

  680.     param.stride_h = 1;

  681.     param.stride_w = 1;

  682.     param.sparse = param::ConvBias::Sparse::GROUP;

  683. 

  684.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  685.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  686.                           size_t group, size_t P, size_t S) {

  687.         SmallVector<TensorShape> shapes{

  688.                 {N, IC, H, W},

  689.                 {group, OC / group, IC / group, FS, FS},

  690.                 {1, OC, 1, 1},

  691.                 {},

  692.                 {N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1}};

  693.         TensorShape dst{N, OC, H, W};

  694.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  695.                               dst.total_nr_elems()) *

  696.                              1e-6;

  697.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  698.     };

  699. 

  700.     bench_case(1, 32, 32, 200, 200, 3, 4, 1, 1);

  701.     bench_case(1, 32, 32, 200, 200, 3, 32, 1, 1);

  702.     bench_case(1, 32, 32, 128, 128, 3, 4, 1, 1);

  703.     bench_case(1, 32, 32, 128, 128, 3, 32, 1, 1);

  704.     bench_case(1, 32, 32, 100, 100, 3, 4, 1, 1);

  705.     bench_case(1, 32, 32, 100, 100, 3, 32, 1, 1);

  706.     bench_case(1, 32, 32, 80, 80, 3, 4, 1, 1);

  707.     bench_case(1, 32, 32, 80, 80, 3, 32, 1, 1);

  708. 

  709.     std::string algo_name = "S8STRD1";

  710.     printf("Benchmark S8STRD1_LARGE_GROUP algo\n");

  711.     std::vector<DType> data_type = {

  712.             dtype::QuantizedS8(2.5f), dtype::QuantizedS8(2.5f),

  713.             dtype::QuantizedS32(6.25f), dtype::QuantizedS8(60.25f)};

  714.     benchmark_impl(

  715.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  716.             data_type);

  717.     benchmark_impl(

  718.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  719.             data_type);

  720.     benchmark_impl(

  721.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  722.             data_type);

  723.     shapes_and_computation.clear();

  724. 

  725.     algo_name = "S8STRD1";

  726.     printf("Benchmark S8STRD1_SMALL_GROUP algo\n");

  727.     bench_case(1, 32, 32, 200, 200, 3, 1, 1, 1);

  728.     bench_case(1, 32, 32, 128, 128, 3, 1, 1, 1);

  729.     bench_case(1, 32, 32, 100, 100, 3, 1, 1, 1);

  730.     bench_case(1, 32, 32, 80, 80, 3, 1, 1, 1);

  731.     benchmark_impl(

  732.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  733.             data_type);

  734.     benchmark_impl(

  735.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  736.             data_type);

  737.     benchmark_impl(

  738.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  739.             data_type);

  740. }

  741. 

  742. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_INT8_NCHW44) {

  743.     constexpr size_t RUNS = 40;

  744.     std::vector<DType> data_type = {

  745.             dtype::QuantizedS8(2.5f), dtype::QuantizedS8(2.5f),

  746.             dtype::QuantizedS32(6.25f), dtype::QuantizedS8(60.25f)};

  747.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  748.                           size_t group, size_t P, size_t S, bool is_nchw = false) {

  749.         param::ConvBias param;

  750.         param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  751.         param.pad_h = P;

  752.         param.pad_w = P;

  753.         param.stride_h = S;

  754.         param.stride_w = S;

  755.         param.sparse = param::ConvBias::Sparse::DENSE;

  756.         param.format = param::ConvBias::Format::NCHW44;

  757.         auto OH = (H + 2 * P - FS) / static_cast<size_t>(S) + 1;

  758.         auto OW = (W + 2 * P - FS) / static_cast<size_t>(S) + 1;

  759.         TensorShape src = {N, IC / 4, H, W, 4};

  760.         TensorShape filter = {OC / 4, IC / 4, FS, FS, 4, 4};

  761.         if (group > 1) {

  762.             filter = {group, OC / group / 4, IC / group / 4, FS, FS, 4, 4};

  763.             param.sparse = param::ConvBias::Sparse::GROUP;

  764.         }

  765.         if (is_nchw) {

  766.             src = {N, IC, H, W};

  767.             filter = {OC / 4, FS, FS, IC, 4};

  768.         }

  769.         TensorShape bias = {1, OC / 4, 1, 1, 4};

  770.         TensorShape dst = {N, OC / 4, OH, OW, 4};

  771. 

  772.         SmallVector<TensorShape> shapes{src, filter, bias, {}, dst};

  773.         float computations = (((IC / group) * FS * FS + 1) * dst.total_nr_elems() * 2 +

  774.                               dst.total_nr_elems()) *

  775.                              1e-6;

  776.         std::vector<std::pair<SmallVector<TensorShape>, float>> shape_arg = {

  777.                 std::make_pair(shapes, computations)};

  778.         benchmark_impl(

  779.                 param, shape_arg, ".+", RUNS, {4, {4, 5, 6, 7}}, {1, {7}}, data_type);

  780.     };

  781.     bench_case(1, 2, 64, 160, 160, 1, 1, 0, 1, true);

  782.     bench_case(1, 3, 64, 224, 224, 7, 1, 3, 2, true);

  783.     bench_case(1, 64, 64, 56, 56, 3, 1, 1, 1);

  784.     bench_case(1, 128, 128, 28, 28, 3, 1, 1, 1);

  785.     bench_case(1, 256, 256, 14, 14, 3, 1, 1, 1);

  786.     bench_case(1, 512, 512, 7, 7, 3, 1, 1, 1);

  787. 

  788.     bench_case(1, 64, 64, 56, 56, 3, 4, 1, 1);

  789.     bench_case(1, 128, 128, 28, 28, 3, 4, 1, 1);

  790.     bench_case(1, 256, 256, 14, 14, 3, 4, 1, 1);

  791.     bench_case(1, 512, 512, 7, 7, 3, 4, 1, 1);

  792. 

  793.     bench_case(1, 4, 64, 224, 224, 7, 1, 1, 2);

  794.     bench_case(1, 256, 128, 56, 56, 3, 1, 1, 2);

  795.     bench_case(1, 512, 256, 28, 28, 3, 1, 1, 2);

  796.     bench_case(1, 4, 32, 224, 224, 3, 1, 1, 2);

  797. 

  798.     bench_case(1, 256, 128, 56, 56, 3, 4, 1, 2);

  799.     bench_case(1, 512, 256, 28, 28, 3, 4, 1, 2);

  800. }

  801. 

  802. #if MGB_ENABLE_DOT

  803. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_INT8_NCHW44_DOT) {

  804.     constexpr size_t RUNS = 40;

  805.     std::vector<DType> data_type = {

  806.             dtype::QuantizedS8(2.5f), dtype::QuantizedS8(2.5f),

  807.             dtype::QuantizedS32(6.25f), dtype::QuantizedS8(60.25f)};

  808.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  809.                           size_t group, size_t P, size_t S, bool is_nchw = false) {

  810.         param::ConvBias param;

  811.         param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  812.         param.pad_h = P;

  813.         param.pad_w = P;

  814.         param.stride_h = S;

  815.         param.stride_w = S;

  816.         param.sparse = param::ConvBias::Sparse::DENSE;

  817.         param.format = param::ConvBias::Format::NCHW44_DOT;

  818.         auto OH = (H + 2 * P - FS) / static_cast<size_t>(S) + 1;

  819.         auto OW = (W + 2 * P - FS) / static_cast<size_t>(S) + 1;

  820.         TensorShape src = {N, IC / 4, H, W, 4};

  821.         TensorShape filter = {OC / 4, IC / 4, FS, FS, 4, 4};

  822.         if (group > 1) {

  823.             filter = {group, OC / group / 4, IC / group / 4, FS, FS, 4, 4};

  824.             param.sparse = param::ConvBias::Sparse::GROUP;

  825.         }

  826.         if (is_nchw) {

  827.             src = {N, IC, H, W};

  828.             filter = {OC / 4, FS, FS, IC, 4};

  829.         }

  830.         TensorShape bias = {1, OC / 4, 1, 1, 4};

  831.         TensorShape dst = {N, OC / 4, OH, OW, 4};

  832. 

  833.         SmallVector<TensorShape> shapes{src, filter, bias, {}, dst};

  834.         float computations = (((IC / group) * FS * FS + 1) * dst.total_nr_elems() * 2 +

  835.                               dst.total_nr_elems()) *

  836.                              1e-6;

  837.         std::vector<std::pair<SmallVector<TensorShape>, float>> shape_arg = {

  838.                 std::make_pair(shapes, computations)};

  839.         benchmark_impl(

  840.                 param, shape_arg, ".+", RUNS, {4, {4, 5, 6, 7}}, {1, {7}}, data_type);

  841.     };

  842.     bench_case(1, 64, 64, 56, 56, 3, 1, 1, 1);

  843.     bench_case(1, 128, 128, 28, 28, 3, 1, 1, 1);

  844.     bench_case(1, 256, 256, 14, 14, 3, 1, 1, 1);

  845.     bench_case(1, 512, 512, 7, 7, 3, 1, 1, 1);

  846. 

  847.     bench_case(1, 64, 64, 56, 56, 3, 4, 1, 1);

  848.     bench_case(1, 128, 128, 28, 28, 3, 4, 1, 1);

  849.     bench_case(1, 256, 256, 14, 14, 3, 4, 1, 1);

  850.     bench_case(1, 512, 512, 7, 7, 3, 4, 1, 1);

  851. }

  852. 

  853. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_INT8_NCHW44_DOT_S2) {

  854.     constexpr size_t RUNS = 40;

  855.     std::vector<DType> data_type = {

  856.             dtype::QuantizedS8(2.5f), dtype::QuantizedS8(2.5f),

  857.             dtype::QuantizedS32(6.25f), dtype::QuantizedS8(60.25f)};

  858.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  859.                           size_t group, size_t P, size_t S, bool is_nchw = false) {

  860.         param::ConvBias param;

  861.         param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  862.         param.pad_h = P;

  863.         param.pad_w = P;

  864.         param.stride_h = S;

  865.         param.stride_w = S;

  866.         param.sparse = param::ConvBias::Sparse::DENSE;

  867.         param.format = param::ConvBias::Format::NCHW44_DOT;

  868.         auto OH = (H + 2 * P - FS) / static_cast<size_t>(S) + 1;

  869.         auto OW = (W + 2 * P - FS) / static_cast<size_t>(S) + 1;

  870.         TensorShape src = {N, IC / 4, H, W, 4};

  871.         TensorShape filter = {OC / 4, IC / 4, FS, FS, 4, 4};

  872.         if (group > 1) {

  873.             filter = {group, OC / group / 4, IC / group / 4, FS, FS, 4, 4};

  874.             param.sparse = param::ConvBias::Sparse::GROUP;

  875.         }

  876.         if (is_nchw) {

  877.             src = {N, IC, H, W};

  878.             filter = {OC / 4, FS, FS, IC, 4};

  879.         }

  880.         TensorShape bias = {1, OC / 4, 1, 1, 4};

  881.         TensorShape dst = {N, OC / 4, OH, OW, 4};

  882. 

  883.         SmallVector<TensorShape> shapes{src, filter, bias, {}, dst};

  884.         float computations = (((IC / group) * FS * FS + 1) * dst.total_nr_elems() * 2 +

  885.                               dst.total_nr_elems()) *

  886.                              1e-6;

  887.         std::vector<std::pair<SmallVector<TensorShape>, float>> shape_arg = {

  888.                 std::make_pair(shapes, computations)};

  889.         benchmark_impl(

  890.                 param, shape_arg, ".+", RUNS, {4, {4, 5, 6, 7}}, {1, {7}}, data_type);

  891.     };

  892.     bench_case(1, 64, 64, 56, 56, 3, 1, 1, 2);

  893.     bench_case(1, 64, 64, 128, 128, 3, 1, 1, 2);

  894.     bench_case(1, 64, 64, 256, 256, 3, 1, 1, 2);

  895.     bench_case(1, 64, 64, 156, 156, 3, 1, 1, 2);

  896.     bench_case(1, 128, 128, 28, 28, 3, 1, 1, 2);

  897.     bench_case(1, 256, 256, 14, 14, 3, 1, 1, 2);

  898.     bench_case(1, 512, 512, 7, 7, 3, 1, 1, 2);

  899. 

  900.     bench_case(1, 64, 64, 56, 56, 3, 4, 1, 2);

  901.     bench_case(1, 128, 128, 28, 28, 3, 4, 1, 2);

  902.     bench_case(1, 256, 256, 14, 14, 3, 4, 1, 2);

  903.     bench_case(1, 512, 512, 7, 7, 3, 4, 1, 2);

  904. }

  905. 

  906. #endif

  907. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_FLOAT_NCHW44) {

  908.     constexpr size_t RUNS = 40;

  909.     std::vector<DType> data_type = {

  910.             dtype::Float32(), dtype::Float32(), dtype::Float32(), dtype::Float32()};

  911.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  912.                           size_t group, size_t P, size_t S, bool is_nchw = false) {

  913.         param::ConvBias param;

  914.         param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  915.         param.pad_h = P;

  916.         param.pad_w = P;

  917.         param.stride_h = S;

  918.         param.stride_w = S;

  919.         param.sparse = param::ConvBias::Sparse::DENSE;

  920.         param.format = param::ConvBias::Format::NCHW44;

  921.         auto OH = (H + 2 * P - FS) / static_cast<size_t>(S) + 1;

  922.         auto OW = (W + 2 * P - FS) / static_cast<size_t>(S) + 1;

  923.         TensorShape src = {N, IC / 4, H, W, 4};

  924.         TensorShape filter = {OC / 4, IC / 4, FS, FS, 4, 4};

  925.         if (group > 1) {

  926.             filter = {group, OC / group / 4, IC / group / 4, FS, FS, 4, 4};

  927.             param.sparse = param::ConvBias::Sparse::GROUP;

  928.         }

  929.         if (is_nchw) {

  930.             src = {N, IC, H, W};

  931.             filter = {OC / 4, FS, FS, IC, 4};

  932.         }

  933.         TensorShape bias = {1, OC / 4, 1, 1, 4};

  934.         TensorShape dst = {N, OC / 4, OH, OW, 4};

  935. 

  936.         SmallVector<TensorShape> shapes{src, filter, bias, {}, dst};

  937.         float computations = (((IC / group) * FS * FS + 1) * dst.total_nr_elems() * 2 +

  938.                               dst.total_nr_elems()) *

  939.                              1e-6;

  940.         std::vector<std::pair<SmallVector<TensorShape>, float>> shape_arg = {

  941.                 std::make_pair(shapes, computations)};

  942.         benchmark_impl(

  943.                 param, shape_arg, ".+", RUNS, {4, {4, 5, 6, 7}}, {1, {7}}, data_type);

  944.     };

  945.     bench_case(1, 64, 64, 56, 56, 3, 1, 1, 2);

  946.     bench_case(1, 128, 128, 28, 28, 3, 1, 1, 2);

  947.     bench_case(1, 256, 256, 14, 14, 3, 1, 1, 2);

  948.     bench_case(1, 512, 512, 7, 7, 3, 1, 1, 2);

  949. 

  950.     bench_case(1, 64, 64, 56, 56, 3, 4, 1, 2);

  951.     bench_case(1, 128, 128, 28, 28, 3, 4, 1, 2);

  952.     bench_case(1, 256, 256, 14, 14, 3, 4, 1, 2);

  953.     bench_case(1, 512, 512, 7, 7, 3, 4, 1, 2);

  954. 

  955.     bench_case(1, 64, 64, 56 * 2, 56 * 2, 3, 4, 1, 2);

  956.     bench_case(1, 128, 128, 28 * 2, 28 * 2, 3, 4, 1, 2);

  957.     bench_case(1, 256, 256, 14 * 2, 14 * 2, 3, 4, 1, 2);

  958.     bench_case(1, 512, 512, 7 * 2, 7 * 2, 3, 4, 1, 2);

  959. }

  960. 

  961. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_INT8_INT8_INT8_STRIDE2) {

  962.     constexpr size_t RUNS = 50;

  963. 

  964.     param::ConvBias param;

  965.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  966.     param.pad_h = 1;

  967.     param.pad_w = 1;

  968.     param.stride_h = 2;

  969.     param.stride_w = 2;

  970.     param.sparse = param::ConvBias::Sparse::GROUP;

  971. 

  972.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  973.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  974.                           size_t group, size_t P, size_t S) {

  975.         SmallVector<TensorShape> shapes{

  976.                 {N, IC, H, W},

  977.                 {group, OC / group, IC / group, FS, FS},

  978.                 {1, OC, 1, 1},

  979.                 {},

  980.                 {N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1}};

  981.         TensorShape dst{N, OC, H, W};

  982.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  983.                               dst.total_nr_elems()) *

  984.                              1e-6;

  985.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  986.     };

  987. 

  988.     bench_case(1, 32, 32, 200, 200, 3, 4, 1, 2);

  989.     bench_case(1, 32, 32, 200, 200, 3, 32, 1, 2);

  990.     bench_case(1, 32, 32, 128, 128, 3, 4, 1, 2);

  991.     bench_case(1, 32, 32, 128, 128, 3, 32, 1, 2);

  992.     bench_case(1, 32, 32, 100, 100, 3, 4, 1, 2);

  993.     bench_case(1, 32, 32, 100, 100, 3, 32, 1, 2);

  994.     bench_case(1, 32, 32, 80, 80, 3, 4, 1, 2);

  995.     bench_case(1, 32, 32, 80, 80, 3, 32, 1, 2);

  996. 

  997.     std::string algo_name = "S8STRD2";

  998.     printf("Benchmark S8STRD2_LARGE_GROUP algo\n");

  999.     std::vector<DType> data_type = {

  1000.             dtype::QuantizedS8(2.5f), dtype::QuantizedS8(2.5f),

  1001.             dtype::QuantizedS32(6.25f), dtype::QuantizedS8(60.25f)};

  1002.     benchmark_impl(

  1003.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1004.             data_type);

  1005.     benchmark_impl(

  1006.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1007.             data_type);

  1008.     benchmark_impl(

  1009.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1010.             data_type);

  1011.     shapes_and_computation.clear();

  1012. 

  1013.     algo_name = "S8STRD2";

  1014.     printf("Benchmark S8STRD2_SMALL_GROUP algo\n");

  1015.     bench_case(1, 32, 32, 200, 200, 3, 1, 1, 2);

  1016.     bench_case(1, 32, 32, 128, 128, 3, 1, 1, 2);

  1017.     bench_case(1, 32, 32, 100, 100, 3, 1, 1, 2);

  1018.     bench_case(1, 32, 32, 80, 80, 3, 1, 1, 2);

  1019.     benchmark_impl(

  1020.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1021.             data_type);

  1022.     benchmark_impl(

  1023.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1024.             data_type);

  1025.     benchmark_impl(

  1026.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1027.             data_type);

  1028. }

  1029. #if MGB_ENABLE_DOT

  1030. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS,

  1031.        BENCHMARK_CONVBIAS_INT8_INT8_INT8_STRIDE1_WITHDOTPROD) {

  1032.     constexpr size_t RUNS = 50;

  1033. 

  1034.     param::ConvBias param;

  1035.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  1036.     param.pad_h = 1;

  1037.     param.pad_w = 1;

  1038.     param.stride_h = 1;

  1039.     param.stride_w = 1;

  1040.     param.sparse = param::ConvBias::Sparse::GROUP;

  1041. 

  1042.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1043.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  1044.                           size_t group, size_t P, size_t S) {

  1045.         SmallVector<TensorShape> shapes{

  1046.                 {N, IC, H, W},

  1047.                 {group, OC / group, IC / group, FS, FS},

  1048.                 {1, OC, 1, 1},

  1049.                 {},

  1050.                 {N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1}};

  1051.         TensorShape dst{N, OC, H, W};

  1052.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1053.                               dst.total_nr_elems()) *

  1054.                              1e-6;

  1055.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1056.     };

  1057. 

  1058.     bench_case(1, 32, 32, 200, 200, 3, 4, 1, 1);

  1059.     bench_case(1, 32, 32, 200, 200, 3, 32, 1, 1);

  1060.     bench_case(1, 32, 32, 128, 128, 3, 4, 1, 1);

  1061.     bench_case(1, 32, 32, 128, 128, 3, 32, 1, 1);

  1062.     bench_case(1, 32, 32, 100, 100, 3, 4, 1, 1);

  1063.     bench_case(1, 32, 32, 100, 100, 3, 32, 1, 1);

  1064.     bench_case(1, 32, 32, 80, 80, 3, 4, 1, 1);

  1065.     bench_case(1, 32, 32, 80, 80, 3, 32, 1, 1);

  1066. 

  1067.     std::string algo_name = "ARMDOTS8STRD1";

  1068.     printf("Benchmark ARMDOTS8STRD1_LARGE_GROUP algo\n");

  1069.     std::vector<DType> data_type = {

  1070.             dtype::QuantizedS8(2.5f), dtype::QuantizedS8(2.5f),

  1071.             dtype::QuantizedS32(6.25f), dtype::QuantizedS8(60.25f)};

  1072.     benchmark_impl(

  1073.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1074.             data_type);

  1075.     benchmark_impl(

  1076.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1077.             data_type);

  1078.     benchmark_impl(

  1079.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1080.             data_type);

  1081.     shapes_and_computation.clear();

  1082. 

  1083.     algo_name = "ARMDOTS8STRD1";

  1084.     printf("Benchmark ARMDOTS8STRD1_SMALL_GROUP algo\n");

  1085.     bench_case(1, 32, 32, 200, 200, 3, 1, 1, 1);

  1086.     bench_case(1, 32, 32, 128, 128, 3, 1, 1, 1);

  1087.     bench_case(1, 32, 32, 100, 100, 3, 1, 1, 1);

  1088.     bench_case(1, 32, 32, 80, 80, 3, 1, 1, 1);

  1089.     benchmark_impl(

  1090.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1091.             data_type);

  1092.     benchmark_impl(

  1093.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1094.             data_type);

  1095.     benchmark_impl(

  1096.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1097.             data_type);

  1098. }

  1099. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS,

  1100.        BENCHMARK_CONVBIAS_INT8_INT8_INT8_STRIDE2_WITHDOTPROD) {

  1101.     constexpr size_t RUNS = 50;

  1102. 

  1103.     param::ConvBias param;

  1104.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  1105.     param.pad_h = 1;

  1106.     param.pad_w = 1;

  1107.     param.stride_h = 2;

  1108.     param.stride_w = 2;

  1109.     param.sparse = param::ConvBias::Sparse::GROUP;

  1110. 

  1111.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1112.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  1113.                           size_t group, size_t P, size_t S) {

  1114.         SmallVector<TensorShape> shapes{

  1115.                 {N, IC, H, W},

  1116.                 {group, OC / group, IC / group, FS, FS},

  1117.                 {1, OC, 1, 1},

  1118.                 {},

  1119.                 {N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1}};

  1120.         TensorShape dst{N, OC, H, W};

  1121.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1122.                               dst.total_nr_elems()) *

  1123.                              1e-6;

  1124.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1125.     };

  1126. 

  1127.     bench_case(1, 32, 32, 200, 200, 3, 4, 1, 2);

  1128.     bench_case(1, 32, 32, 200, 200, 3, 32, 1, 2);

  1129.     bench_case(1, 32, 32, 128, 128, 3, 4, 1, 2);

  1130.     bench_case(1, 32, 32, 128, 128, 3, 32, 1, 2);

  1131.     bench_case(1, 32, 32, 100, 100, 3, 4, 1, 2);

  1132.     bench_case(1, 32, 32, 100, 100, 3, 32, 1, 2);

  1133.     bench_case(1, 32, 32, 80, 80, 3, 4, 1, 2);

  1134.     bench_case(1, 32, 32, 80, 80, 3, 32, 1, 2);

  1135. 

  1136.     std::string algo_name = "ARMDOTS8STRD2";

  1137.     printf("Benchmark ARMDOTS8STRD2_LARGE_GROUP algo\n");

  1138.     std::vector<DType> data_type = {

  1139.             dtype::QuantizedS8(2.5f), dtype::QuantizedS8(2.5f),

  1140.             dtype::QuantizedS32(6.25f), dtype::QuantizedS8(60.25f)};

  1141.     benchmark_impl(

  1142.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1143.             data_type);

  1144.     benchmark_impl(

  1145.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1146.             data_type);

  1147.     benchmark_impl(

  1148.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1149.             data_type);

  1150.     shapes_and_computation.clear();

  1151. 

  1152.     algo_name = "ARMDOTS8STRD2";

  1153.     printf("Benchmark ARMDOTS8STRD2_SMALL_GROUP algo\n");

  1154.     bench_case(1, 32, 32, 200, 200, 3, 1, 1, 2);

  1155.     bench_case(1, 32, 32, 128, 128, 3, 1, 1, 2);

  1156.     bench_case(1, 32, 32, 100, 100, 3, 1, 1, 2);

  1157.     bench_case(1, 32, 32, 80, 80, 3, 1, 1, 2);

  1158.     benchmark_impl(

  1159.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1160.             data_type);

  1161.     benchmark_impl(

  1162.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1163.             data_type);

  1164.     benchmark_impl(

  1165.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1166.             data_type);

  1167. }

  1168. #endif

  1169. 

  1170. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS,

  1171.        BENCHMARK_CONVBIAS_QUINT8_QUINT8_QUINT8_STRIDE1) {

  1172.     constexpr size_t RUNS = 50;

  1173. 

  1174.     param::ConvBias param;

  1175.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  1176.     param.pad_h = 1;

  1177.     param.pad_w = 1;

  1178.     param.stride_h = 1;

  1179.     param.stride_w = 1;

  1180.     param.sparse = param::ConvBias::Sparse::GROUP;

  1181. 

  1182.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1183.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  1184.                           size_t group, size_t P, size_t S) {

  1185.         SmallVector<TensorShape> shapes{

  1186.                 {N, IC, H, W},

  1187.                 {group, OC / group, IC / group, FS, FS},

  1188.                 {1, OC, 1, 1},

  1189.                 {},

  1190.                 {N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1}};

  1191.         TensorShape dst{N, OC, H, W};

  1192.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1193.                               dst.total_nr_elems()) *

  1194.                              1e-6;

  1195.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1196.     };

  1197. 

  1198.     bench_case(1, 32, 32, 200, 200, 3, 4, 1, 1);

  1199.     bench_case(1, 32, 32, 200, 200, 3, 32, 1, 1);

  1200.     bench_case(1, 32, 32, 128, 128, 3, 4, 1, 1);

  1201.     bench_case(1, 32, 32, 128, 128, 3, 32, 1, 1);

  1202.     bench_case(1, 32, 32, 100, 100, 3, 4, 1, 1);

  1203.     bench_case(1, 32, 32, 100, 100, 3, 32, 1, 1);

  1204.     bench_case(1, 32, 32, 80, 80, 3, 4, 1, 1);

  1205.     bench_case(1, 32, 32, 80, 80, 3, 32, 1, 1);

  1206. 

  1207.     std::string algo_name = "QU8STRD1";

  1208.     printf("Benchmark QU8STRD1_LARGE_GROUP algo\n");

  1209.     std::vector<DType> data_type = {

  1210.             dtype::Quantized8Asymm(0.2f, 100), dtype::Quantized8Asymm(0.2f, 120),

  1211.             dtype::QuantizedS32(0.04f), dtype::Quantized8Asymm(1.4f, 110)};

  1212.     benchmark_impl(

  1213.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1214.             data_type);

  1215.     benchmark_impl(

  1216.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1217.             data_type);

  1218.     benchmark_impl(

  1219.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1220.             data_type);

  1221.     shapes_and_computation.clear();

  1222. 

  1223.     algo_name = "QU8STRD1";

  1224.     printf("Benchmark QU8STRD1_SMALL_GROUP algo\n");

  1225.     bench_case(1, 32, 32, 200, 200, 3, 1, 1, 1);

  1226.     bench_case(1, 32, 32, 128, 128, 3, 1, 1, 1);

  1227.     bench_case(1, 32, 32, 100, 100, 3, 1, 1, 1);

  1228.     bench_case(1, 32, 32, 80, 80, 3, 1, 1, 1);

  1229.     benchmark_impl(

  1230.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1231.             data_type);

  1232.     benchmark_impl(

  1233.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1234.             data_type);

  1235.     benchmark_impl(

  1236.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1237.             data_type);

  1238. }

  1239. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS,

  1240.        BENCHMARK_CONVBIAS_QUINT8_QUINT8_QUINT8_STRIDE2) {

  1241.     constexpr size_t RUNS = 50;

  1242. 

  1243.     param::ConvBias param;

  1244.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  1245.     param.pad_h = 1;

  1246.     param.pad_w = 1;

  1247.     param.stride_h = 2;

  1248.     param.stride_w = 2;

  1249.     param.sparse = param::ConvBias::Sparse::GROUP;

  1250. 

  1251.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1252.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  1253.                           size_t group, size_t P, size_t S) {

  1254.         SmallVector<TensorShape> shapes{

  1255.                 {N, IC, H, W},

  1256.                 {group, OC / group, IC / group, FS, FS},

  1257.                 {1, OC, 1, 1},

  1258.                 {},

  1259.                 {N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1}};

  1260.         TensorShape dst{N, OC, H, W};

  1261.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1262.                               dst.total_nr_elems()) *

  1263.                              1e-6;

  1264.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1265.     };

  1266. 

  1267.     bench_case(1, 32, 32, 200, 200, 3, 4, 1, 2);

  1268.     bench_case(1, 32, 32, 200, 200, 3, 32, 1, 2);

  1269.     bench_case(1, 32, 32, 128, 128, 3, 4, 1, 2);

  1270.     bench_case(1, 32, 32, 128, 128, 3, 32, 1, 2);

  1271.     bench_case(1, 32, 32, 100, 100, 3, 4, 1, 2);

  1272.     bench_case(1, 32, 32, 100, 100, 3, 32, 1, 2);

  1273.     bench_case(1, 32, 32, 80, 80, 3, 4, 1, 2);

  1274.     bench_case(1, 32, 32, 80, 80, 3, 32, 1, 2);

  1275. 

  1276.     std::string algo_name = "QU8STRD2";

  1277.     printf("Benchmark QU8STRD2_LARGE_GROUP algo\n");

  1278.     std::vector<DType> data_type = {

  1279.             dtype::Quantized8Asymm(0.2f, 100), dtype::Quantized8Asymm(0.2f, 120),

  1280.             dtype::QuantizedS32(0.04f), dtype::Quantized8Asymm(1.4f, 110)};

  1281.     benchmark_impl(

  1282.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1283.             data_type);

  1284.     benchmark_impl(

  1285.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1286.             data_type);

  1287.     benchmark_impl(

  1288.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1289.             data_type);

  1290.     shapes_and_computation.clear();

  1291. 

  1292.     algo_name = "QU8STRD2";

  1293.     printf("Benchmark QU8STRD2_SMALL_GROUP algo\n");

  1294.     bench_case(1, 32, 32, 200, 200, 3, 1, 1, 2);

  1295.     bench_case(1, 32, 32, 128, 128, 3, 1, 1, 2);

  1296.     bench_case(1, 32, 32, 100, 100, 3, 1, 1, 2);

  1297.     bench_case(1, 32, 32, 80, 80, 3, 1, 1, 2);

  1298.     benchmark_impl(

  1299.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1300.             data_type);

  1301.     benchmark_impl(

  1302.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1303.             data_type);

  1304.     benchmark_impl(

  1305.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1306.             data_type);

  1307. }

  1308. #if MGB_ENABLE_DOT

  1309. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS,

  1310.        BENCHMARK_CONVBIAS_QUINT8_QUINT8_QUINT8_STRIDE1_WITHDOTPROD) {

  1311.     constexpr size_t RUNS = 50;

  1312. 

  1313.     param::ConvBias param;

  1314.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  1315.     param.pad_h = 1;

  1316.     param.pad_w = 1;

  1317.     param.stride_h = 1;

  1318.     param.stride_w = 1;

  1319.     param.sparse = param::ConvBias::Sparse::GROUP;

  1320. 

  1321.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1322.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  1323.                           size_t group, size_t P, size_t S) {

  1324.         SmallVector<TensorShape> shapes{

  1325.                 {N, IC, H, W},

  1326.                 {group, OC / group, IC / group, FS, FS},

  1327.                 {1, OC, 1, 1},

  1328.                 {},

  1329.                 {N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1}};

  1330.         TensorShape dst{N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1};

  1331.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1332.                               dst.total_nr_elems()) *

  1333.                              1e-6;

  1334.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1335.     };

  1336. 

  1337.     bench_case(1, 32, 32, 200, 200, 3, 4, 1, 1);

  1338.     bench_case(1, 32, 32, 200, 200, 3, 32, 1, 1);

  1339.     bench_case(1, 32, 32, 128, 128, 3, 4, 1, 1);

  1340.     bench_case(1, 32, 32, 128, 128, 3, 32, 1, 1);

  1341.     bench_case(1, 32, 32, 100, 100, 3, 4, 1, 1);

  1342.     bench_case(1, 32, 32, 100, 100, 3, 32, 1, 1);

  1343.     bench_case(1, 32, 32, 80, 80, 3, 4, 1, 1);

  1344.     bench_case(1, 32, 32, 80, 80, 3, 32, 1, 1);

  1345. 

  1346.     std::string algo_name = "ARMDOTU8STRD1";

  1347.     printf("Benchmark ARMDOTU8STRD1_LARGE_GROUP algo\n");

  1348.     std::vector<DType> data_type = {

  1349.             dtype::Quantized8Asymm(0.2f, 100), dtype::Quantized8Asymm(0.2f, 120),

  1350.             dtype::QuantizedS32(0.04f), dtype::Quantized8Asymm(1.4f, 110)};

  1351.     benchmark_impl(

  1352.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1353.             data_type);

  1354.     benchmark_impl(

  1355.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1356.             data_type);

  1357.     benchmark_impl(

  1358.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1359.             data_type);

  1360.     shapes_and_computation.clear();

  1361. 

  1362.     algo_name = "ARMDOTU8STRD1";

  1363.     printf("Benchmark ARMDOTS8STRD1_SMALL_GROUP algo\n");

  1364.     bench_case(1, 32, 32, 200, 200, 3, 1, 1, 1);

  1365.     bench_case(1, 32, 32, 128, 128, 3, 1, 1, 1);

  1366.     bench_case(1, 32, 32, 100, 100, 3, 1, 1, 1);

  1367.     bench_case(1, 32, 32, 80, 80, 3, 1, 1, 1);

  1368.     benchmark_impl(

  1369.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1370.             data_type);

  1371.     benchmark_impl(

  1372.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1373.             data_type);

  1374.     benchmark_impl(

  1375.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1376.             data_type);

  1377. }

  1378. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS,

  1379.        BENCHMARK_CONVBIAS_QUINT8_QUINT8_QUINT8_STRIDE2_WITHDOTPROD) {

  1380.     constexpr size_t RUNS = 50;

  1381. 

  1382.     param::ConvBias param;

  1383.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  1384.     param.pad_h = 1;

  1385.     param.pad_w = 1;

  1386.     param.stride_h = 2;

  1387.     param.stride_w = 2;

  1388.     param.sparse = param::ConvBias::Sparse::GROUP;

  1389. 

  1390.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1391.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  1392.                           size_t group, size_t P, size_t S) {

  1393.         SmallVector<TensorShape> shapes{

  1394.                 {N, IC, H, W},

  1395.                 {group, OC / group, IC / group, FS, FS},

  1396.                 {1, OC, 1, 1},

  1397.                 {},

  1398.                 {N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1}};

  1399.         TensorShape dst{N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1};

  1400.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1401.                               dst.total_nr_elems()) *

  1402.                              1e-6;

  1403.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1404.     };

  1405. 

  1406.     bench_case(1, 32, 32, 200, 200, 5, 4, 1, 2);

  1407.     bench_case(1, 32, 32, 200, 200, 5, 32, 1, 2);

  1408.     bench_case(1, 32, 32, 128, 128, 5, 4, 1, 2);

  1409.     bench_case(1, 32, 32, 128, 128, 5, 32, 1, 2);

  1410.     bench_case(1, 32, 32, 100, 100, 5, 4, 1, 2);

  1411.     bench_case(1, 32, 32, 100, 100, 5, 32, 1, 2);

  1412.     bench_case(1, 32, 32, 80, 80, 5, 4, 1, 2);

  1413.     bench_case(1, 32, 32, 80, 80, 5, 32, 1, 2);

  1414. 

  1415.     std::string algo_name = "ARMDOTU8STRD2";

  1416.     printf("Benchmark ARMDOTU8STRD2_LARGE_GROUP algo\n");

  1417.     std::vector<DType> data_type = {

  1418.             dtype::Quantized8Asymm(0.2f, 100), dtype::Quantized8Asymm(0.2f, 120),

  1419.             dtype::QuantizedS32(0.04f), dtype::Quantized8Asymm(1.4f, 110)};

  1420.     benchmark_impl(

  1421.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1422.             data_type);

  1423.     benchmark_impl(

  1424.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1425.             data_type);

  1426.     benchmark_impl(

  1427.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1428.             data_type);

  1429.     shapes_and_computation.clear();

  1430. 

  1431.     algo_name = "ARMDOTU8STRD2";

  1432.     printf("Benchmark ARMDOTU8STRD2_SMALL_GROUP algo\n");

  1433.     bench_case(1, 32, 32, 200, 200, 5, 1, 1, 2);

  1434.     bench_case(1, 32, 32, 128, 128, 5, 1, 1, 2);

  1435.     bench_case(1, 32, 32, 100, 100, 5, 1, 1, 2);

  1436.     bench_case(1, 32, 32, 80, 80, 5, 1, 1, 2);

  1437.     benchmark_impl(

  1438.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1439.             data_type);

  1440.     benchmark_impl(

  1441.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1442.             data_type);

  1443.     benchmark_impl(

  1444.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1445.             data_type);

  1446. }

  1447. #endif

  1448. 

  1449. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_WINOGRAD_F32) {

  1450.     constexpr size_t RUNS = 50;

  1451. 

  1452.     param::ConvBias param;

  1453.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  1454.     param.pad_h = 1;

  1455.     param.pad_w = 1;

  1456.     param.stride_h = 1;

  1457.     param.stride_w = 1;

  1458.     param.sparse = param::ConvBias::Sparse::GROUP;

  1459. 

  1460.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1461.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  1462.                           size_t group) {

  1463.         SmallVector<TensorShape> shapes{

  1464.                 {N, IC, H, W},

  1465.                 {group, OC / group, IC / group, FS, FS},

  1466.                 {1, OC, 1, 1},

  1467.                 {},

  1468.                 {N, OC, H, W}};

  1469.         TensorShape dst{N, OC, H, W};

  1470.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1471.                               dst.total_nr_elems()) *

  1472.                              1e-6;

  1473.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1474.     };

  1475. 

  1476.     bench_case(1, 32, 32, 200, 200, 3, 4);

  1477.     bench_case(1, 32, 32, 200, 200, 3, 1);

  1478.     bench_case(1, 32, 32, 128, 128, 3, 4);

  1479.     bench_case(1, 32, 32, 128, 128, 3, 1);

  1480.     bench_case(1, 32, 32, 100, 100, 3, 4);

  1481.     bench_case(1, 32, 32, 100, 100, 3, 1);

  1482.     bench_case(1, 32, 32, 80, 80, 3, 4);

  1483. 

  1484.     bench_case(1, 512, 512, 14, 14, 3, 1);

  1485.     bench_case(1, 512, 256, 14, 14, 3, 1);

  1486.     bench_case(1, 512, 128, 14, 14, 3, 1);

  1487.     bench_case(1, 512, 64, 14, 14, 3, 1);

  1488. 

  1489.     bench_case(1, 512, 512, 7, 7, 3, 1);

  1490.     bench_case(1, 512, 256, 7, 7, 3, 1);

  1491.     bench_case(1, 512, 128, 7, 7, 3, 1);

  1492.     bench_case(1, 512, 64, 7, 7, 3, 1);

  1493. 

  1494.     std::string algo_name;

  1495. #if MEGDNN_AARCH64

  1496.     algo_name = "WINOGRAD:AARCH64_F32_MK4_4x16:4:2";

  1497. #else

  1498.     algo_name = "WINOGRAD:ARMV7_F32_MK4_4x8:4:2";

  1499. #endif

  1500.     std::vector<DType> data_type = {

  1501.             dtype::Float32(), dtype::Float32(), dtype::Float32(), dtype::Float32()};

  1502.     printf("Benchmark WINOGRAD_F32_MK4 algo\n");

  1503.     benchmark_impl(

  1504.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1505.             data_type);

  1506.     benchmark_impl(

  1507.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1508.             data_type);

  1509.     benchmark_impl(

  1510.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1511.             data_type);

  1512. }

  1513. 

  1514. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_WINOGRAD_INT8) {

  1515.     constexpr size_t RUNS = 50;

  1516. 

  1517.     param::ConvBias param;

  1518.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  1519.     param.pad_h = 1;

  1520.     param.pad_w = 1;

  1521.     param.stride_h = 1;

  1522.     param.stride_w = 1;

  1523.     param.sparse = param::ConvBias::Sparse::GROUP;

  1524. 

  1525.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1526.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  1527.                           size_t group) {

  1528.         SmallVector<TensorShape> shapes{

  1529.                 {N, IC, H, W},

  1530.                 {group, OC / group, IC / group, FS, FS},

  1531.                 {1, OC, 1, 1},

  1532.                 {},

  1533.                 {N, OC, H, W}};

  1534.         TensorShape dst{N, OC, H, W};

  1535.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1536.                               dst.total_nr_elems()) *

  1537.                              1e-6;

  1538.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1539.     };

  1540. 

  1541.     bench_case(1, 32, 32, 200, 200, 3, 4);

  1542.     bench_case(1, 32, 32, 200, 200, 3, 1);

  1543.     bench_case(1, 32, 32, 128, 128, 3, 4);

  1544.     bench_case(1, 32, 32, 128, 128, 3, 1);

  1545.     bench_case(1, 32, 32, 100, 100, 3, 4);

  1546.     bench_case(1, 32, 32, 100, 100, 3, 1);

  1547.     bench_case(1, 32, 32, 80, 80, 3, 4);

  1548. 

  1549.     bench_case(1, 512, 512, 14, 14, 3, 1);

  1550.     bench_case(1, 512, 256, 14, 14, 3, 1);

  1551.     bench_case(1, 512, 128, 14, 14, 3, 1);

  1552.     bench_case(1, 512, 64, 14, 14, 3, 1);

  1553. 

  1554.     bench_case(1, 512, 512, 7, 7, 3, 1);

  1555.     bench_case(1, 512, 256, 7, 7, 3, 1);

  1556.     bench_case(1, 512, 128, 7, 7, 3, 1);

  1557.     bench_case(1, 512, 64, 7, 7, 3, 1);

  1558. 

  1559.     std::string algo_name;

  1560. #if MEGDNN_AARCH64

  1561.     algo_name = "WINOGRAD:AARCH64_INT16X16X32_MK8_8X8:8:2:32";

  1562. #else

  1563.     algo_name = "WINOGRAD:ARMV7_INT16X16X32_MK8_4X8:8:2:32";

  1564. #endif

  1565. 

  1566.     std::vector<DType> data_type = {

  1567.             dtype::QuantizedS8(2.5f), dtype::QuantizedS8(2.5f),

  1568.             dtype::QuantizedS32(6.25f), dtype::QuantizedS8(60.25f)};

  1569.     printf("Benchmark WINOGRAD_IN8_MK8 algo\n");

  1570.     benchmark_impl(

  1571.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1572.             data_type);

  1573.     benchmark_impl(

  1574.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1575.             data_type);

  1576.     benchmark_impl(

  1577.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1578.             data_type);

  1579. }

  1580. 

  1581. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS,

  1582.        BENCHMARK_CONVBIAS_WINOGRAD_NCHW44_INT8_MK8) {

  1583.     constexpr size_t RUNS = 50;

  1584. 

  1585.     param::ConvBias param;

  1586.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  1587.     param.pad_h = 1;

  1588.     param.pad_w = 1;

  1589.     param.stride_h = 1;

  1590.     param.stride_w = 1;

  1591.     param.sparse = param::ConvBias::Sparse::DENSE;

  1592.     param.format = param::ConvBias::Format::NCHW44;

  1593. 

  1594.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1595.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  1596.                           size_t group) {

  1597.         SmallVector<TensorShape> shapes{

  1598.                 {N, IC / 4, H, W, 4},

  1599.                 {OC / 4, IC / 4, FS, FS, 4, 4},

  1600.                 {1, OC / 4, 1, 1, 4},

  1601.                 {},

  1602.                 {N, OC / 4, H, W, 4}};

  1603.         TensorShape dst{N, OC, H, W};

  1604.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1605.                               dst.total_nr_elems()) *

  1606.                              1e-6;

  1607.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1608.     };

  1609. 

  1610.     bench_case(1, 32, 32, 200, 200, 3, 1);

  1611.     bench_case(1, 32, 32, 128, 128, 3, 1);

  1612.     bench_case(1, 32, 32, 100, 100, 3, 1);

  1613. 

  1614.     bench_case(1, 512, 512, 14, 14, 3, 1);

  1615.     bench_case(1, 512, 256, 14, 14, 3, 1);

  1616.     bench_case(1, 512, 128, 14, 14, 3, 1);

  1617.     bench_case(1, 512, 64, 14, 14, 3, 1);

  1618. 

  1619.     bench_case(1, 512, 512, 7, 7, 3, 1);

  1620.     bench_case(1, 512, 256, 7, 7, 3, 1);

  1621.     bench_case(1, 512, 128, 7, 7, 3, 1);

  1622.     bench_case(1, 512, 64, 7, 7, 3, 1);

  1623. 

  1624.     std::string algo_name;

  1625. #if MEGDNN_AARCH64

  1626.     algo_name = "WINOGRAD_NCHW44:AARCH64_INT16X16X32_MK8_8X8:8:2:32";

  1627. #else

  1628.     algo_name = "WINOGRAD_NCHW44:ARMV7_INT16X16X32_MK8_4X8:8:2:32";

  1629. #endif

  1630. 

  1631.     std::vector<DType> data_type = {

  1632.             dtype::QuantizedS8(2.5f), dtype::QuantizedS8(2.5f),

  1633.             dtype::QuantizedS32(6.25f), dtype::QuantizedS8(60.25f)};

  1634.     printf("Benchmark WINOGRAD_INT8_MK8 algo\n");

  1635.     benchmark_impl(

  1636.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1637.             data_type);

  1638.     benchmark_impl(

  1639.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1640.             data_type);

  1641.     benchmark_impl(

  1642.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1643.             data_type);

  1644. }

  1645. 

  1646. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS,

  1647.        BENCHMARK_CONVBIAS_WINOGRAD_NCHW44_INT8_COMP_F32) {

  1648.     constexpr size_t RUNS = 50;

  1649. 

  1650.     param::ConvBias param;

  1651.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  1652.     param.pad_h = 1;

  1653.     param.pad_w = 1;

  1654.     param.stride_h = 1;

  1655.     param.stride_w = 1;

  1656.     param.sparse = param::ConvBias::Sparse::DENSE;  // GROUP;

  1657.     param.format = param::ConvBias::Format::NCHW44;

  1658. 

  1659.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1660.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  1661.                           size_t group) {

  1662.         SmallVector<TensorShape> shapes{

  1663.                 {N, IC / 4, H, W, 4},

  1664.                 {OC / 4, IC / 4, FS, FS, 4, 4},

  1665.                 {1, OC / 4, 1, 1, 4},

  1666.                 {},

  1667.                 {N, OC / 4, H, W, 4}};

  1668.         TensorShape dst{N, OC, H, W};

  1669.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1670.                               dst.total_nr_elems()) *

  1671.                              1e-6;

  1672.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1673.     };

  1674. 

  1675.     bench_case(1, 32, 32, 200, 200, 3, 1);

  1676.     bench_case(1, 32, 32, 128, 128, 3, 1);

  1677.     bench_case(1, 32, 32, 100, 100, 3, 1);

  1678. 

  1679.     bench_case(1, 512, 512, 14, 14, 3, 1);

  1680.     bench_case(1, 512, 256, 14, 14, 3, 1);

  1681.     bench_case(1, 512, 128, 14, 14, 3, 1);

  1682.     bench_case(1, 512, 64, 14, 14, 3, 1);

  1683. 

  1684.     bench_case(1, 512, 512, 7, 7, 3, 1);

  1685.     bench_case(1, 512, 256, 7, 7, 3, 1);

  1686.     bench_case(1, 512, 128, 7, 7, 3, 1);

  1687.     bench_case(1, 512, 64, 7, 7, 3, 1);

  1688. 

  1689.     std::string algo_name;

  1690. #if MEGDNN_AARCH64

  1691.     algo_name = "WINOGRAD_NCHW44:AARCH64_F32_MK4_4x16:4:2:32";

  1692. #else

  1693.     algo_name = "WINOGRAD_NCHW44:ARMV7_F32_MK4_4x8:4:2:32";

  1694. #endif

  1695. 

  1696.     std::vector<DType> data_type = {

  1697.             dtype::QuantizedS8(2.5f), dtype::QuantizedS8(2.5f),

  1698.             dtype::QuantizedS32(6.25f), dtype::QuantizedS8(60.25f)};

  1699.     printf("Benchmark WINOGRAD_INT8_NCHW44_MK4_COMP_F32 algo\n");

  1700.     benchmark_impl(

  1701.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1702.             data_type);

  1703.     benchmark_impl(

  1704.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1705.             data_type);

  1706.     benchmark_impl(

  1707.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1708.             data_type);

  1709. }

  1710. 

  1711. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_IM2COL_FP32) {

  1712.     constexpr size_t RUNS = 50;

  1713. 

  1714.     param::ConvBias param;

  1715.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  1716.     param.pad_h = 1;

  1717.     param.pad_w = 1;

  1718.     param.stride_h = 1;

  1719.     param.stride_w = 1;

  1720. 

  1721.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1722.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  1723.                           size_t group) {

  1724.         SmallVector<TensorShape> shapes{

  1725.                 {N, IC, H, W},

  1726.                 {OC, IC / group, FS, FS},

  1727.                 {1, OC, 1, 1},

  1728.                 {},

  1729.                 {N, OC, H, W}};

  1730.         TensorShape dst{N, OC, H, W};

  1731.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1732.                               dst.total_nr_elems()) *

  1733.                              1e-6;

  1734.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1735.     };

  1736.     std::vector<DType> data_type = {

  1737.             dtype::Float32(), dtype::Float32(), dtype::Float32(), dtype::Float32()};

  1738.     bench_case(1, 32, 32, 300, 300, 3, 1);

  1739.     bench_case(1, 32, 32, 400, 400, 3, 1);

  1740.     bench_case(1, 32, 32, 100, 100, 3, 1);

  1741.     bench_case(1, 32, 32, 80, 80, 3, 1);

  1742.     bench_case(1, 32, 64, 200, 200, 3, 1);

  1743.     bench_case(1, 32, 64, 128, 128, 3, 1);

  1744.     bench_case(1, 32, 64, 100, 100, 3, 1);

  1745.     bench_case(1, 32, 64, 80, 80, 3, 1);

  1746.     bench_case(1, 32, 128, 200, 200, 3, 1);

  1747.     bench_case(1, 32, 128, 128, 128, 3, 1);

  1748.     bench_case(1, 32, 128, 100, 100, 3, 1);

  1749.     bench_case(1, 32, 128, 80, 80, 3, 1);

  1750. 

  1751.     bench_case(1, 64, 32, 7, 7, 3, 1);

  1752.     bench_case(1, 64, 64, 7, 7, 3, 1);

  1753.     bench_case(1, 64, 128, 7, 7, 3, 1);

  1754.     bench_case(1, 64, 256, 7, 7, 3, 1);

  1755.     bench_case(1, 64, 512, 7, 7, 3, 1);

  1756.     bench_case(1, 64, 1024, 7, 7, 3, 1);

  1757. 

  1758.     bench_case(1, 64, 32, 14, 14, 3, 1);

  1759.     bench_case(1, 64, 64, 14, 14, 3, 1);

  1760.     bench_case(1, 64, 128, 14, 14, 3, 1);

  1761.     bench_case(1, 64, 256, 14, 14, 3, 1);

  1762.     bench_case(1, 64, 512, 14, 14, 3, 1);

  1763. 

  1764.     bench_case(1, 64, 1024, 14, 14, 3, 1);

  1765.     bench_case(1, 128, 128, 14, 14, 3, 1);

  1766.     bench_case(1, 128, 256, 14, 14, 3, 1);

  1767.     bench_case(1, 512, 512, 14, 14, 3, 1);

  1768.     bench_case(1, 256, 512, 14, 14, 3, 1);

  1769.     bench_case(1, 512, 1024, 14, 14, 3, 1);

  1770.     bench_case(1, 1024, 1024, 14, 14, 3, 1);

  1771.     std::string algo_name = "IM2COLMATMUL:AARCH64_F32K8X12X1:96";

  1772.     printf("Benchmark IM2COLMATMUL:AARCH64_F32K8X12X1algo:96\n");

  1773.     benchmark_impl(

  1774.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1775.             data_type);

  1776.     benchmark_impl(

  1777.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1778.             data_type);

  1779.     benchmark_impl(

  1780.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1781.             data_type);

  1782.     algo_name = "IM2COLMATMUL:AARCH64_F32K8X12X1:192";

  1783.     printf("Benchmark IM2COLMATMUL:AARCH64_F32K8X12X1algo:192\n");

  1784.     benchmark_impl(

  1785.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1786.             data_type);

  1787.     benchmark_impl(

  1788.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1789.             data_type);

  1790.     benchmark_impl(

  1791.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1792.             data_type);

  1793.     algo_name = "IM2COLMATMUL:AARCH64_F32K8X12X1:384";

  1794.     printf("Benchmark IM2COLMATMUL:AARCH64_F32K8X12X1algo:384\n");

  1795.     benchmark_impl(

  1796.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1797.             data_type);

  1798.     benchmark_impl(

  1799.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1800.             data_type);

  1801.     benchmark_impl(

  1802.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1803.             data_type);

  1804.     shapes_and_computation.clear();

  1805. }

  1806. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS,

  1807.        BENCHMARK_CHANNEL_WISE_INT8_INT8_INT8_STRIDE1) {

  1808.     constexpr size_t RUNS = 50;

  1809. 

  1810.     param::ConvBias param;

  1811.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  1812.     param.pad_h = 1;

  1813.     param.pad_w = 1;

  1814.     param.stride_h = 1;

  1815.     param.stride_w = 1;

  1816.     param.sparse = param::ConvBias::Sparse::GROUP;

  1817.     param.format = param::ConvBias::Format::NCHW44;

  1818. 

  1819.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1820.     auto bench_case = [&](size_t N, size_t IC, size_t H, size_t W, size_t FS,

  1821.                           size_t P) {

  1822.         size_t group = IC;

  1823.         size_t OC = IC;

  1824.         size_t S = 1;

  1825.         SmallVector<TensorShape> shapes{

  1826.                 {N, IC, H, W, 4},

  1827.                 {group, 1, 1, FS, FS, 4},

  1828.                 {1, OC, 1, 1, 4},

  1829.                 {},

  1830.                 {N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1, 4}};

  1831.         TensorShape dst{N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1, 4};

  1832.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1833.                               dst.total_nr_elems()) *

  1834.                              1e-6;

  1835.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1836.     };

  1837.     bench_case(1, 128, 200, 200, 3, 1);

  1838.     bench_case(1, 128, 128, 128, 3, 1);

  1839.     bench_case(1, 128, 100, 100, 3, 1);

  1840.     bench_case(1, 128, 80, 80, 3, 1);

  1841.     bench_case(1, 128, 56, 56, 3, 1);

  1842.     bench_case(1, 128, 28, 28, 3, 1);

  1843.     bench_case(1, 128, 14, 14, 3, 1);

  1844. 

  1845.     bench_case(1, 64, 200, 200, 3, 1);

  1846.     bench_case(1, 64, 128, 128, 3, 1);

  1847.     bench_case(1, 64, 100, 100, 3, 1);

  1848.     bench_case(1, 64, 80, 80, 3, 1);

  1849.     bench_case(1, 64, 56, 56, 3, 1);

  1850.     bench_case(1, 64, 28, 28, 3, 1);

  1851.     bench_case(1, 64, 14, 14, 3, 1);

  1852. 

  1853.     bench_case(1, 32, 200, 200, 3, 1);

  1854.     bench_case(1, 32, 128, 128, 3, 1);

  1855.     bench_case(1, 32, 100, 100, 3, 1);

  1856.     bench_case(1, 32, 80, 80, 3, 1);

  1857.     bench_case(1, 32, 56, 56, 3, 1);

  1858.     bench_case(1, 32, 28, 28, 3, 1);

  1859.     bench_case(1, 32, 14, 14, 3, 1);

  1860. 

  1861.     std::string algo_name = "S8_CHAN_WISE_STRD1_NCHW44";

  1862.     printf("Benchmarker S8_CHAN_WISE_STRD1_NCHW44 algo\n");

  1863.     std::vector<DType> data_type = {

  1864.             dtype::QuantizedS8(2.5f), dtype::QuantizedS8(2.5f),

  1865.             dtype::QuantizedS32(6.25f), dtype::QuantizedS8(60.25f)};

  1866.     benchmark_impl(

  1867.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1868.             data_type);

  1869.     benchmark_impl(

  1870.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1871.             data_type);

  1872.     benchmark_impl(

  1873.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1874.             data_type);

  1875. }

  1876. 

  1877. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS,

  1878.        BENCHMARK_CHANNEL_WISE_INT8_INT8_INT16_STRIDE1) {

  1879.     constexpr size_t RUNS = 50;

  1880. 

  1881.     param::ConvBias param;

  1882.     param.nonlineMode = param::ConvBias::NonlineMode::IDENTITY;

  1883.     param.pad_h = 1;

  1884.     param.pad_w = 1;

  1885.     param.stride_h = 1;

  1886.     param.stride_w = 1;

  1887.     param.sparse = param::ConvBias::Sparse::GROUP;

  1888.     param.format = param::ConvBias::Format::NCHW44;

  1889. 

  1890.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1891.     auto bench_case = [&](size_t N, size_t IC, size_t H, size_t W, size_t FS,

  1892.                           size_t P) {

  1893.         size_t group = IC;

  1894.         size_t OC = IC;

  1895.         size_t S = 1;

  1896.         SmallVector<TensorShape> shapes{

  1897.                 {N, IC, H, W, 4},

  1898.                 {group, 1, 1, FS, FS, 4},

  1899.                 {1, OC, 1, 1, 4},

  1900.                 {},

  1901.                 {N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1, 4}};

  1902.         TensorShape dst{N, OC, (H + 2 * P - FS) / S + 1, (W + 2 * P - FS) / S + 1, 4};

  1903.         float computations = ((IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1904.                               dst.total_nr_elems()) *

  1905.                              1e-6;

  1906.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1907.     };

  1908.     bench_case(1, 128, 200, 200, 3, 1);

  1909.     bench_case(1, 128, 128, 128, 3, 1);

  1910.     bench_case(1, 128, 100, 100, 3, 1);

  1911.     bench_case(1, 128, 80, 80, 3, 1);

  1912.     bench_case(1, 128, 56, 56, 3, 1);

  1913.     bench_case(1, 128, 28, 28, 3, 1);

  1914.     bench_case(1, 128, 14, 14, 3, 1);

  1915. 

  1916.     bench_case(1, 64, 200, 200, 3, 1);

  1917.     bench_case(1, 64, 128, 128, 3, 1);

  1918.     bench_case(1, 64, 100, 100, 3, 1);

  1919.     bench_case(1, 64, 80, 80, 3, 1);

  1920.     bench_case(1, 64, 56, 56, 3, 1);

  1921.     bench_case(1, 64, 28, 28, 3, 1);

  1922.     bench_case(1, 64, 14, 14, 3, 1);

  1923. 

  1924.     bench_case(1, 32, 200, 200, 3, 1);

  1925.     bench_case(1, 32, 128, 128, 3, 1);

  1926.     bench_case(1, 32, 100, 100, 3, 1);

  1927.     bench_case(1, 32, 80, 80, 3, 1);

  1928.     bench_case(1, 32, 56, 56, 3, 1);

  1929.     bench_case(1, 32, 28, 28, 3, 1);

  1930.     bench_case(1, 32, 14, 14, 3, 1);

  1931. 

  1932.     std::string algo_name = "S8x8x16_CHAN_WISE_STRD1_STRD2_NCHW44";

  1933.     printf("Benchmarker S8x8x16_CHAN_WISE_STRD1_STRD2_NCHW44 algo\n");

  1934.     std::vector<DType> data_type = {

  1935.             dtype::Int8(), dtype::Int8(), dtype::Int16(), dtype::Int16()};

  1936.     benchmark_impl(

  1937.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  1938.             data_type);

  1939.     benchmark_impl(

  1940.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  1941.             data_type);

  1942.     benchmark_impl(

  1943.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  1944.             data_type);

  1945. }

  1946. 

  1947. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_IM2COL_NCHW44_INT8x8x32_STRIDE1) {

  1948.     constexpr size_t RUNS = 50;

  1949. 

  1950.     param::ConvBias param;

  1951.     param.nonlineMode = param::ConvBias::NonlineMode::IDENTITY;

  1952.     param.pad_h = 1;

  1953.     param.pad_w = 1;

  1954.     param.stride_h = 1;

  1955.     param.stride_w = 1;

  1956.     param.sparse = param::ConvBias::Sparse::DENSE;

  1957.     param.format = param::ConvBias::Format::NCHW44;

  1958. 

  1959.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  1960.     auto bench_case = [&](size_t N, size_t IC, size_t OC, size_t H, size_t W, size_t FS,

  1961.                           size_t group = 1) {

  1962.         SmallVector<TensorShape> shapes{

  1963.                 {N, IC, H, W, 4},

  1964.                 {OC, IC / group, FS, FS, 4, 4},

  1965.                 {/*1, OC, 1, 1*/},

  1966.                 {},

  1967.                 {N, OC, H, W, 4}};

  1968.         TensorShape dst{N, OC, H, W, 4};

  1969.         float computations = ((4 * IC / group) * FS * FS * dst.total_nr_elems() * 2 +

  1970.                               dst.total_nr_elems()) *

  1971.                              1e-6;

  1972.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  1973.     };

  1974. 

  1975.     bench_case(1, 32, 32, 300, 300, 3, 1);

  1976.     bench_case(1, 32, 32, 400, 400, 3, 1);

  1977.     bench_case(1, 32, 32, 100, 100, 3, 1);

  1978.     bench_case(1, 32, 32, 80, 80, 3, 1);

  1979.     bench_case(1, 32, 64, 200, 200, 3, 1);

  1980.     bench_case(1, 32, 64, 128, 128, 3, 1);

  1981.     bench_case(1, 32, 64, 100, 100, 3, 1);

  1982.     bench_case(1, 32, 64, 80, 80, 3, 1);

  1983.     bench_case(1, 32, 128, 200, 200, 3, 1);

  1984.     bench_case(1, 32, 128, 128, 128, 3, 1);

  1985.     bench_case(1, 32, 128, 100, 100, 3, 1);

  1986.     bench_case(1, 32, 128, 80, 80, 3, 1);

  1987. #if 1

  1988.     bench_case(1, 64, 32, 7, 7, 3, 1);

  1989.     bench_case(1, 64, 64, 7, 7, 3, 1);

  1990.     bench_case(1, 64, 128, 7, 7, 3, 1);

  1991.     bench_case(1, 64, 256, 7, 7, 3, 1);

  1992.     bench_case(1, 64, 512, 7, 7, 3, 1);

  1993.     bench_case(1, 64, 1024, 7, 7, 3, 1);

  1994. 

  1995.     bench_case(1, 64, 32, 14, 14, 3, 1);

  1996.     bench_case(1, 64, 64, 14, 14, 3, 1);

  1997.     bench_case(1, 64, 128, 14, 14, 3, 1);

  1998.     bench_case(1, 64, 256, 14, 14, 3, 1);

  1999.     bench_case(1, 64, 512, 14, 14, 3, 1);

  2000. 

  2001.     bench_case(1, 64, 1024, 14, 14, 3, 1);

  2002.     bench_case(1, 128, 128, 14, 14, 3, 1);

  2003.     bench_case(1, 128, 256, 14, 14, 3, 1);

  2004.     bench_case(1, 512, 512, 14, 14, 3, 1);

  2005.     bench_case(1, 256, 512, 14, 14, 3, 1);

  2006.     bench_case(1, 512, 1024, 14, 14, 3, 1);

  2007.     bench_case(1, 1024, 1024, 14, 14, 3, 1);

  2008. #endif

  2009.     std::string algo_name = "IM2COLMATMUL:AARCH64_INT8X8X32_MK4_4X4X16:96";

  2010.     printf("Benchmarker  IM2COLMATMUL:AARCH64_INT8X8X32_MK4_4X4X16:96  algo\n");

  2011.     std::vector<DType> data_type = {

  2012.             dtype::QuantizedS8(2.5f),

  2013.             dtype::QuantizedS8(2.5f),

  2014.             dtype::QuantizedS32(6.25f),

  2015.             {}};

  2016.     benchmark_impl(

  2017.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  2018.             data_type);

  2019.     benchmark_impl(

  2020.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  2021.             data_type);

  2022.     benchmark_impl(

  2023.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  2024.             data_type);

  2025. 

  2026.     algo_name = "IM2COLMATMUL:AARCH64_INT8X8X32_MK4_4X4X16:192";

  2027.     printf("Benchmarker  IM2COLMATMUL:AARCH64_INT8X8X32_MK4_4X4X16:192  "

  2028.            "algo\n");

  2029.     benchmark_impl(

  2030.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  2031.             data_type);

  2032.     benchmark_impl(

  2033.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  2034.             data_type);

  2035.     benchmark_impl(

  2036.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  2037.             data_type);

  2038. 

  2039.     algo_name = "IM2COLMATMUL:AARCH64_INT8X8X32_MK4_4X4X16:384";

  2040.     printf("Benchmarker  IM2COLMATMUL:AARCH64_INT8X8X32_MK4_4X4X16:384  "

  2041.            "algo\n");

  2042.     benchmark_impl(

  2043.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  2044.             data_type);

  2045.     benchmark_impl(

  2046.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  2047.             data_type);

  2048.     benchmark_impl(

  2049.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  2050.             data_type);

  2051. }

  2052. 

  2053. #endif

  2054. 

  2055. /*================== BENCHMARK MULTITHREAD CONV1X1 =====================*/

  2056. #if MEGDNN_WITH_BENCHMARK

  2057. 

  2058. namespace {

  2059. std::vector<std::pair<SmallVector<TensorShape>, float>>

  2060. get_conv1x1_multithread_benchmark_args() {

  2061.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation;

  2062.     auto bench_case = [&](size_t IC, size_t OC, size_t H, size_t W) {

  2063.         SmallVector<TensorShape> shapes{

  2064.                 {1, IC, H, W}, {OC, IC, 1, 1}, {1, OC, 1, 1}, {}, {1, OC, H, W}};

  2065.         TensorShape dst{1, OC, H, W};

  2066.         float computations =

  2067.                 (IC * dst.total_nr_elems() * 2 + dst.total_nr_elems()) * 1e-6;

  2068.         shapes_and_computation.push_back(std::make_pair(shapes, computations));

  2069.     };

  2070.     bench_case(32, 32, 300, 300);

  2071.     bench_case(32, 32, 400, 400);

  2072.     bench_case(32, 32, 100, 100);

  2073.     bench_case(32, 32, 80, 80);

  2074.     bench_case(32, 64, 200, 200);

  2075.     bench_case(32, 64, 128, 128);

  2076.     bench_case(32, 64, 100, 100);

  2077.     bench_case(32, 64, 80, 80);

  2078.     bench_case(32, 128, 200, 200);

  2079.     bench_case(32, 128, 128, 128);

  2080.     bench_case(32, 128, 100, 100);

  2081.     bench_case(32, 128, 80, 80);

  2082. 

  2083.     bench_case(64, 32, 7, 7);

  2084.     bench_case(64, 64, 7, 7);

  2085.     bench_case(64, 128, 7, 7);

  2086.     bench_case(64, 256, 7, 7);

  2087.     bench_case(64, 512, 7, 7);

  2088.     bench_case(64, 1024, 7, 7);

  2089. 

  2090.     bench_case(64, 32, 14, 14);

  2091.     bench_case(64, 64, 14, 14);

  2092.     bench_case(64, 128, 14, 14);

  2093.     bench_case(64, 256, 14, 14);

  2094.     bench_case(64, 512, 14, 14);

  2095. 

  2096.     bench_case(64, 1024, 14, 14);

  2097.     bench_case(128, 128, 14, 14);

  2098.     bench_case(128, 256, 14, 14);

  2099.     bench_case(512, 512, 14, 14);

  2100.     bench_case(256, 512, 14, 14);

  2101.     bench_case(512, 1024, 14, 14);

  2102.     bench_case(1024, 1024, 14, 14);

  2103.     return shapes_and_computation;

  2104. }

  2105. 

  2106. void conv1x1_multithread_benchmark(

  2107.         const char* algo_name, DType stype, DType ftype, DType btype, DType dtype) {

  2108.     constexpr size_t RUNS = 50;

  2109.     std::vector<std::pair<SmallVector<TensorShape>, float>> shapes_and_computation =

  2110.             get_conv1x1_multithread_benchmark_args();

  2111. 

  2112.     std::vector<DType> data_type = {stype, ftype, btype, dtype};

  2113. 

  2114.     param::ConvBias param;

  2115.     param.nonlineMode = param::ConvBias::NonlineMode::RELU;

  2116.     param.pad_h = 0;

  2117.     param.pad_w = 0;

  2118.     param.stride_h = 1;

  2119.     param.stride_w = 1;

  2120. 

  2121.     benchmark_impl(

  2122.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {4}},

  2123.             data_type);

  2124.     benchmark_impl(

  2125.             param, shapes_and_computation, algo_name, RUNS, {4, {4, 5, 6, 7}}, {1, {7}},

  2126.             data_type);

  2127.     benchmark_impl(

  2128.             param, shapes_and_computation, algo_name, RUNS, {2, {4, 5}}, {1, {4}},

  2129.             data_type);

  2130.     shapes_and_computation.clear();

  2131. }

  2132. }  // namespace

  2133. 

  2134. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS, BENCHMARK_CONVBIAS_CONV1X1_S1_FP32) {

  2135. #if MEGDNN_AARCH64

  2136.     conv1x1_multithread_benchmark(

  2137.             "CONV1x1:AARCH64_F32K8X12X1:8", dtype::Float32(), dtype::Float32(),

  2138.             dtype::Float32(), dtype::Float32());

  2139. #else

  2140.     conv1x1_multithread_benchmark(

  2141.             "CONV1x1:ARMV7_F32:8", dtype::Float32(), dtype::Float32(), dtype::Float32(),

  2142.             dtype::Float32());

  2143. #endif

  2144. }

  2145. 

  2146. TEST_F(ARM_COMMON_BENCHMARK_MULTI_THREADS,

  2147.        BENCHMARK_CONVBIAS_CONV1X1_S1_QUANTIZEDASYM) {

  2148.     dtype::Quantized8Asymm stype(0.2f, 100);

  2149.     dtype::Quantized8Asymm ftype(0.2f, 120);

  2150.     dtype::QuantizedS32 btype(0.04f);

  2151.     dtype::Quantized8Asymm dtype(1.4f, 110);

  2152. #if MEGDNN_AARCH64

  2153. #if MGB_ENABLE_DOT

  2154.     conv1x1_multithread_benchmark(

  2155.             "CONV1x1:AARCH64_QUINT8_K8X8X4_DOTPROD:8", stype, ftype, btype, dtype);

  2156. #else

  2157.     conv1x1_multithread_benchmark(

  2158.             "CONV1x1:AARCH64_QUINT8_K8X8X8:8", stype, ftype, btype, dtype);

  2159. #endif

  2160. #else

  2161.     conv1x1_multithread_benchmark(

  2162.             "CONV1x1:ARMV7_QUINT8_K4X8X8:8", stype, ftype, btype, dtype);

  2163. #endif

  2164. }

  2165. 

  2166. #endif

  2167. 

  2168. // vim: syntax=cpp.doxygen