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

597 lines
24 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/test/arm_common/elemwise.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/common/elemwise.h"

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

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

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

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

  17. 

  18. #include "megdnn/opr_param_defs.h"

  19. #include "megdnn/oprs/general.h"

  20. 

  21. using namespace megdnn;

  22. using namespace test;

  23. 

  24. template <typename tag>

  25. class ARM_ELEMWISE : public ARM_COMMON {};

  26. TYPED_TEST_CASE(ARM_ELEMWISE, elemwise::test_types);

  27. TYPED_TEST(ARM_ELEMWISE, run) {

  28.     elemwise::run_test<TypeParam>(this->handle());

  29. }

  30. 

  31. template <typename tag>

  32. class ARM_ELEMWISE_MULTI_THREADS : public ARM_COMMON_MULTI_THREADS {};

  33. TYPED_TEST_CASE(ARM_ELEMWISE_MULTI_THREADS, elemwise::test_types);

  34. TYPED_TEST(ARM_ELEMWISE_MULTI_THREADS, run) {

  35.     elemwise::run_test<TypeParam>(this->handle());

  36. }

  37. 

  38. TEST_F(ARM_COMMON, ELEMWISE_FORWARD_TERNARY) {

  39.     using Mode = ElemwiseForward::Param::Mode;

  40.     Checker<ElemwiseForward> checker(handle());

  41.     checker.set_param(Mode::FUSE_MUL_ADD3);

  42. 

  43.     auto run = [&] {

  44.         //! nchw44

  45.         checker.execs({{1, 3, 1, 1, 4}, {1, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  46.         checker.execs({{1, 3, 1, 1, 4}, {2, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  47.         checker.execs({{1, 8, 1, 1, 4}, {3, 8, 5, 3, 4}, {1, 8, 1, 1, 4}, {}});

  48.         checker.execs({{3, 4, 5, 7, 4}, {3, 4, 5, 7, 4}, {3, 4, 5, 7, 4}, {}});

  49.         checker.execs({{1, 2, 1, 1, 4}, {1, 2, 5, 7, 4}, {1, 2, 1, 1, 4}, {}});

  50. 

  51.         //! nchw44

  52.         checker.execs({{1, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {1, 3, 2, 2, 4}, {}});

  53.         checker.execs({{2, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {2, 3, 2, 2, 4}, {}});

  54.         checker.execs({{3, 8, 5, 3, 4}, {1, 8, 1, 1, 4}, {3, 8, 5, 3, 4}, {}});

  55.         checker.execs({{3, 4, 5, 7, 4}, {3, 4, 5, 7, 4}, {3, 4, 5, 7, 4}, {}});

  56.         checker.execs({{1, 2, 5, 7, 4}, {1, 2, 1, 1, 4}, {1, 2, 5, 7, 4}, {}});

  57. 

  58.         //! nchw88

  59.         checker.execs({{1, 3, 1, 1, 8}, {1, 3, 2, 2, 8}, {1, 3, 1, 1, 8}, {}});

  60.         checker.execs({{1, 3, 1, 1, 8}, {2, 3, 2, 2, 8}, {1, 3, 1, 1, 8}, {}});

  61.         checker.execs({{1, 8, 1, 1, 8}, {3, 8, 5, 3, 8}, {1, 8, 1, 1, 8}, {}});

  62.         checker.execs({{3, 4, 5, 7, 8}, {3, 4, 5, 7, 8}, {3, 4, 5, 7, 8}, {}});

  63.         checker.execs({{1, 2, 1, 1, 8}, {1, 2, 5, 7, 8}, {1, 2, 1, 1, 8}, {}});

  64. 

  65.         //! nchw88

  66.         checker.execs({{1, 3, 2, 2, 8}, {1, 3, 1, 1, 8}, {1, 3, 2, 2, 8}, {}});

  67.         checker.execs({{2, 3, 2, 2, 8}, {1, 3, 1, 1, 8}, {2, 3, 2, 2, 8}, {}});

  68.         checker.execs({{3, 8, 5, 3, 8}, {1, 8, 1, 1, 8}, {3, 8, 5, 3, 8}, {}});

  69.         checker.execs({{3, 4, 5, 7, 8}, {3, 4, 5, 7, 8}, {3, 4, 5, 7, 8}, {}});

  70.         checker.execs({{1, 2, 5, 7, 8}, {1, 2, 1, 1, 8}, {1, 2, 5, 7, 8}, {}});

  71. 

  72.         checker.execs({{3, 4, 7}, {3, 4, 7}, {3, 4, 7}, {}});

  73.         checker.execs({{1, 4, 1, 1}, {3, 4, 5, 7}, {1, 4, 1, 1}, {}});

  74.         checker.execs({{1, 4, 1}, {3, 4, 7}, {1, 4, 1}, {}});

  75.         checker.execs({{3, 4, 5, 7}, {3, 4, 5, 7}, {1, 1, 1, 1}, {}});

  76.         checker.execs({{1, 7}, {1, 7}, {1, 7}, {}});

  77.         checker.execs({{1, 2, 1}, {1, 2, 2}, {1, 2, 1}, {}});

  78.         checker.execs({{1, 2, 2}, {1, 2, 2}, {1, 1, 1}, {}});

  79.         checker.execs({{3, 4, 1}, {3, 4, 1}, {3, 4, 1}, {}});

  80.         checker.execs({{3, 4, 5}, {1}, {1}, {}});

  81.         checker.execs({{1}, {3, 4, 5}, {1}, {}});

  82.     };

  83. 

  84.     // case int

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

  86.     checker.set_dtype(1, dtype::Int8());

  87.     checker.set_dtype(2, dtype::Int8());

  88.     run();

  89. 

  90.     checker.set_dtype(0, dtype::Int16());

  91.     checker.set_dtype(1, dtype::Int16());

  92.     checker.set_dtype(2, dtype::Int16());

  93.     run();

  94. 

  95.     checker.set_dtype(0, dtype::Int32());

  96.     checker.set_dtype(1, dtype::Int32());

  97.     checker.set_dtype(2, dtype::Int32());

  98.     run();

  99. 

  100.     // case float

  101.     UniformFloatRNG rng(1e-5, 7e1);

  102.     checker.set_rng(0, &rng);

  103.     checker.set_epsilon(1e-5);

  104.     checker.set_dtype(0, dtype::Float32());

  105.     checker.set_dtype(1, dtype::Float32());

  106.     checker.set_dtype(2, dtype::Float32());

  107.     run();

  108. 

  109. #if __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

  110.     // case half

  111.     UniformFloatRNG rng_float16(1, 10);

  112.     checker.set_rng(0, &rng_float16);

  113.     checker.set_epsilon(1e-2);

  114.     checker.set_dtype(0, dtype::Float16());

  115.     checker.set_dtype(1, dtype::Float16());

  116.     checker.set_dtype(2, dtype::Float16());

  117.     run();

  118. #endif

  119. }

  120. 

  121. TEST_F(ARM_COMMON, ELEMWISE_FORWARD_NCHW44_INT8_INT16_INT32) {

  122.     using Mode = ElemwiseForward::Param::Mode;

  123.     Checker<ElemwiseForward> checker(handle());

  124. 

  125.     auto run = [&]() {

  126.         // VEC_BCAST101x not PowOp

  127.         checker.set_param(Mode::ADD).execs({{1, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  128.         checker.set_param(Mode::ADD).execs({{2, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  129.         checker.set_param(Mode::ADD).execs({{3, 8, 5, 3, 4}, {1, 8, 1, 1, 4}, {}});

  130.         checker.set_param(Mode::ADD).execs({{3, 4, 5, 7, 4}, {3, 4, 5, 7, 4}, {}});

  131.         checker.set_param(Mode::ADD).execs({{1, 2, 5, 7, 4}, {1, 2, 1, 1, 4}, {}});

  132.         checker.set_param(Mode::RMULH).execs({{1, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  133.         checker.set_param(Mode::RMULH).execs({{2, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  134.         checker.set_param(Mode::RMULH).execs({{3, 8, 5, 3, 4}, {1, 8, 1, 1, 4}, {}});

  135.         checker.set_param(Mode::RMULH).execs({{3, 4, 5, 7, 4}, {3, 4, 5, 7, 4}, {}});

  136.         checker.set_param(Mode::RMULH).execs({{1, 2, 5, 7, 4}, {1, 2, 1, 1, 4}, {}});

  137.         checker.set_param(Mode::FUSE_ADD_RELU)

  138.                 .execs({{1, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  139.         checker.set_param(Mode::FUSE_ADD_RELU)

  140.                 .execs({{2, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  141.         checker.set_param(Mode::FUSE_ADD_RELU)

  142.                 .execs({{3, 8, 5, 3, 4}, {1, 8, 1, 1, 4}, {}});

  143.         checker.set_param(Mode::FUSE_ADD_RELU)

  144.                 .execs({{3, 4, 5, 7, 4}, {3, 4, 5, 7, 4}, {}});

  145.         checker.set_param(Mode::FUSE_ADD_RELU)

  146.                 .execs({{1, 2, 5, 7, 4}, {1, 2, 1, 1, 4}, {}});

  147.         // BCAST101x_VEC not PowOp

  148.         checker.set_param(Mode::ADD).execs({{1, 3, 1, 1, 4}, {1, 3, 2, 2, 4}, {}});

  149.         checker.set_param(Mode::ADD).execs({{1, 3, 1, 1, 4}, {2, 3, 2, 2, 4}, {}});

  150.         checker.set_param(Mode::ADD).execs({{1, 8, 1, 1, 4}, {3, 8, 5, 3, 4}, {}});

  151.         checker.set_param(Mode::ADD).execs({{3, 4, 5, 7, 4}, {3, 4, 5, 7, 4}, {}});

  152.         checker.set_param(Mode::ADD).execs({{1, 2, 1, 1, 4}, {1, 2, 5, 7, 4}, {}});

  153.         checker.set_param(Mode::FUSE_ADD_RELU)

  154.                 .execs({{1, 3, 1, 1, 4}, {1, 3, 2, 2, 4}, {}});

  155.         checker.set_param(Mode::FUSE_ADD_RELU)

  156.                 .execs({{1, 3, 1, 1, 4}, {2, 3, 2, 2, 4}, {}});

  157.         checker.set_param(Mode::FUSE_ADD_RELU)

  158.                 .execs({{1, 8, 1, 1, 4}, {3, 8, 5, 3, 4}, {}});

  159.         checker.set_param(Mode::FUSE_ADD_RELU)

  160.                 .execs({{3, 4, 5, 7, 4}, {3, 4, 5, 7, 4}, {}});

  161.         checker.set_param(Mode::FUSE_ADD_RELU)

  162.                 .execs({{1, 2, 1, 1, 4}, {1, 2, 5, 7, 4}, {}});

  163.     };

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

  165.     checker.set_dtype(1, dtype::Int8());

  166.     run();

  167.     checker.set_dtype(0, dtype::Int16());

  168.     checker.set_dtype(1, dtype::Int16());

  169.     run();

  170.     checker.set_dtype(0, dtype::Int32());

  171.     checker.set_dtype(1, dtype::Int32());

  172.     run();

  173. }

  174. 

  175. TEST_F(ARM_COMMON, ELEMWISE_FORWARD_NCHW44_FP32) {

  176.     using Mode = ElemwiseForward::Param::Mode;

  177.     Checker<ElemwiseForward> checker(handle());

  178. 

  179.     UniformFloatRNG rng(1e-5, 7e1);

  180.     checker.set_rng(0, &rng);

  181.     checker.set_epsilon(1e-5);

  182.     checker.set_dtype(0, dtype::Float32());

  183.     checker.set_dtype(1, dtype::Float32());

  184. 

  185.     checker.set_param(Mode::FUSE_ADD_RELU)

  186.             .execs({{1, 3, 1, 1, 4}, {1, 3, 2, 2, 4}, {}});

  187.     checker.set_param(Mode::FUSE_ADD_RELU)

  188.             .execs({{1, 3, 1, 1, 4}, {2, 3, 2, 2, 4}, {}});

  189.     checker.set_param(Mode::FUSE_ADD_RELU)

  190.             .execs({{1, 8, 1, 1, 4}, {3, 8, 5, 3, 4}, {}});

  191.     checker.set_param(Mode::FUSE_ADD_RELU)

  192.             .execs({{3, 4, 5, 7, 4}, {3, 4, 5, 7, 4}, {}});

  193.     checker.set_param(Mode::FUSE_ADD_RELU)

  194.             .execs({{1, 2, 1, 1, 4}, {1, 2, 5, 7, 4}, {}});

  195.     checker.set_param(Mode::FUSE_ADD_RELU)

  196.             .execs({{1, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  197.     checker.set_param(Mode::FUSE_ADD_RELU)

  198.             .execs({{2, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  199.     checker.set_param(Mode::FUSE_ADD_RELU)

  200.             .execs({{3, 8, 5, 3, 4}, {1, 8, 1, 1, 4}, {}});

  201.     checker.set_param(Mode::FUSE_ADD_RELU)

  202.             .execs({{3, 4, 5, 7, 4}, {3, 4, 5, 7, 4}, {}});

  203.     checker.set_param(Mode::FUSE_ADD_RELU)

  204.             .execs({{1, 2, 5, 7, 4}, {1, 2, 1, 1, 4}, {}});

  205. 

  206.     auto run = [&](Mode mode) {

  207.         // VEC_BCAST101x

  208.         checker.set_param(mode).execs({{1, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  209.         checker.set_param(mode).execs({{2, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  210.         checker.set_param(mode).execs({{3, 8, 5, 3, 4}, {1, 8, 1, 1, 4}, {}});

  211.         checker.set_param(mode).execs({{3, 4, 5, 7, 4}, {3, 4, 5, 7, 4}, {}});

  212.         checker.set_param(mode).execs({{1, 2, 5, 7, 4}, {1, 2, 1, 1, 4}, {}});

  213.         // BCAST101x_VEC not powOp

  214.         checker.set_param(mode).execs({{1, 3, 1, 1, 4}, {1, 3, 2, 2, 4}, {}});

  215.         checker.set_param(mode).execs({{1, 3, 1, 1, 4}, {2, 3, 2, 2, 4}, {}});

  216.         checker.set_param(mode).execs({{1, 8, 1, 1, 4}, {3, 8, 5, 3, 4}, {}});

  217.         checker.set_param(mode).execs({{3, 4, 5, 7, 4}, {3, 4, 5, 7, 4}, {}});

  218.         checker.set_param(mode).execs({{1, 2, 1, 1, 4}, {1, 2, 5, 7, 4}, {}});

  219.     };

  220.     run(Mode::ADD);

  221.     run(Mode::FUSE_ADD_H_SWISH);

  222.     run(Mode::FUSE_ADD_RELU);

  223.     run(Mode::MAX);

  224.     run(Mode::MIN);

  225.     run(Mode::MUL);

  226.     run(Mode::SUB);

  227.     run(Mode::TRUE_DIV);

  228.     run(Mode::POW);

  229. }

  230. 

  231. TEST_F(ARM_COMMON, ELEMWISE_FORWARD_NCHW88_FP) {

  232.     using Mode = ElemwiseForward::Param::Mode;

  233.     Checker<ElemwiseForward> checker(handle());

  234. 

  235.     checker.set_param(Mode::FUSE_ADD_RELU)

  236.             .execs({{1, 3, 1, 1, 8}, {1, 3, 2, 2, 8}, {}});

  237.     checker.set_param(Mode::FUSE_ADD_RELU)

  238.             .execs({{1, 3, 1, 1, 8}, {2, 3, 2, 2, 8}, {}});

  239.     checker.set_param(Mode::FUSE_ADD_RELU)

  240.             .execs({{1, 8, 1, 1, 8}, {3, 8, 5, 3, 8}, {}});

  241.     checker.set_param(Mode::FUSE_ADD_RELU)

  242.             .execs({{3, 4, 5, 7, 8}, {3, 4, 5, 7, 8}, {}});

  243.     checker.set_param(Mode::FUSE_ADD_RELU)

  244.             .execs({{1, 2, 1, 1, 8}, {1, 2, 5, 7, 8}, {}});

  245.     checker.set_param(Mode::FUSE_ADD_RELU)

  246.             .execs({{1, 3, 2, 2, 8}, {1, 3, 1, 1, 8}, {}});

  247.     checker.set_param(Mode::FUSE_ADD_RELU)

  248.             .execs({{2, 3, 2, 2, 8}, {1, 3, 1, 1, 8}, {}});

  249.     checker.set_param(Mode::FUSE_ADD_RELU)

  250.             .execs({{3, 8, 5, 3, 8}, {1, 8, 1, 1, 8}, {}});

  251.     checker.set_param(Mode::FUSE_ADD_RELU)

  252.             .execs({{3, 4, 5, 7, 8}, {3, 4, 5, 7, 8}, {}});

  253.     checker.set_param(Mode::FUSE_ADD_RELU)

  254.             .execs({{1, 2, 5, 7, 8}, {1, 2, 1, 1, 8}, {}});

  255. 

  256.     auto run = [&](Mode mode) {

  257.         // VEC_BCAST101x

  258.         checker.set_param(mode).execs({{1, 3, 2, 2, 8}, {1, 3, 1, 1, 8}, {}});

  259.         checker.set_param(mode).execs({{2, 3, 2, 2, 8}, {1, 3, 1, 1, 8}, {}});

  260.         checker.set_param(mode).execs({{3, 8, 5, 3, 8}, {1, 8, 1, 1, 8}, {}});

  261.         checker.set_param(mode).execs({{3, 4, 5, 7, 8}, {3, 4, 5, 7, 8}, {}});

  262.         checker.set_param(mode).execs({{1, 2, 5, 7, 8}, {1, 2, 1, 1, 8}, {}});

  263.         // BCAST101x_VEC not powOp

  264.         checker.set_param(mode).execs({{1, 3, 1, 1, 8}, {1, 3, 2, 2, 8}, {}});

  265.         checker.set_param(mode).execs({{1, 3, 1, 1, 8}, {2, 3, 2, 2, 8}, {}});

  266.         checker.set_param(mode).execs({{1, 8, 1, 1, 8}, {3, 8, 5, 3, 8}, {}});

  267.         checker.set_param(mode).execs({{3, 4, 5, 7, 8}, {3, 4, 5, 7, 8}, {}});

  268.         checker.set_param(mode).execs({{1, 2, 1, 1, 8}, {1, 2, 5, 7, 8}, {}});

  269.     };

  270.     auto run_all = [&]() {

  271.         run(Mode::ADD);

  272.         run(Mode::FUSE_ADD_H_SWISH);

  273.         run(Mode::FUSE_ADD_RELU);

  274.         run(Mode::MAX);

  275.         run(Mode::MIN);

  276.         run(Mode::MUL);

  277.         run(Mode::SUB);

  278.         run(Mode::TRUE_DIV);

  279.         run(Mode::POW);

  280.     };

  281. 

  282.     {

  283.         UniformFloatRNG rng(1e-5, 7e1);

  284.         checker.set_rng(0, &rng);

  285.         checker.set_epsilon(1e-5);

  286.         checker.set_dtype(0, dtype::Float32());

  287.         checker.set_dtype(1, dtype::Float32());

  288.         run_all();

  289.     }

  290. 

  291. #if __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

  292.     {

  293.         UniformFloatRNG rng(1, 2);

  294.         checker.set_rng(0, &rng);

  295.         checker.set_epsilon(3e-3);

  296.         checker.set_dtype(0, dtype::Float16());

  297.         checker.set_dtype(1, dtype::Float16());

  298.         run_all();

  299.     }

  300. #endif

  301. }

  302. 

  303. TEST_F(ARM_COMMON_MULTI_THREADS, ELEMWISE_FORWARD_NHWC_FP32_BCAST) {

  304.     using Mode = ElemwiseForward::Param::Mode;

  305.     Checker<ElemwiseForward> checker(handle());

  306. 

  307.     UniformFloatRNG rng(1e-5, 7e1);

  308.     checker.set_rng(0, &rng);

  309.     checker.set_epsilon(1e-5);

  310.     checker.set_dtype(0, dtype::Float32());

  311.     checker.set_dtype(1, dtype::Float32());

  312. 

  313.     //! 2 dim

  314.     auto run = [&](Mode mode) {

  315.         // VEC_BCAST111C

  316.         checker.set_param(mode).execs({{1, 2, 2, 12}, {1, 1, 1, 12}, {}});

  317.         checker.set_param(mode).execs({{2, 5, 3, 28}, {1, 1, 1, 28}, {}});

  318.         checker.set_param(mode).execs({{3, 5, 8, 32}, {1, 1, 1, 32}, {}});

  319.         // BCAST111C_VEC

  320.         checker.set_param(mode).execs({{1, 1, 1, 12}, {1, 2, 2, 12}, {}});

  321.         checker.set_param(mode).execs({{1, 1, 1, 28}, {2, 5, 3, 28}, {}});

  322.         checker.set_param(mode).execs({{1, 1, 1, 32}, {3, 5, 8, 32}, {}});

  323.     };

  324.     run(Mode::ADD);

  325.     run(Mode::MUL);

  326.     run(Mode::SUB);

  327. 

  328.     //! 3 dim contig

  329.     auto run_3d_contig = [&](Mode mode) {

  330.         // BCAST111C_VEC_BCAST111C

  331.         checker.set_param(mode).execs(

  332.                 {{1, 1, 1, 12}, {1, 2, 2, 12}, {1, 1, 1, 12}, {}});

  333.         checker.set_param(mode).execs(

  334.                 {{1, 1, 1, 28}, {2, 5, 3, 28}, {1, 1, 1, 28}, {}});

  335.         checker.set_param(mode).execs(

  336.                 {{1, 1, 1, 32}, {3, 5, 8, 32}, {1, 1, 1, 32}, {}});

  337.         // VEC_BCAST111C_VEC

  338.         checker.set_param(mode).execs(

  339.                 {{1, 2, 2, 12}, {1, 1, 1, 12}, {1, 2, 2, 12}, {}});

  340.         checker.set_param(mode).execs(

  341.                 {{2, 5, 3, 28}, {1, 1, 1, 28}, {2, 5, 3, 28}, {}});

  342.         checker.set_param(mode).execs(

  343.                 {{3, 5, 8, 32}, {1, 1, 1, 32}, {3, 5, 8, 32}, {}});

  344.     };

  345.     run_3d_contig(Mode::FUSE_MUL_ADD3);

  346. 

  347.     //! 3 dim incontig

  348.     auto run_3d_incontig = [&](Mode mode) {

  349.         megdnn::TensorLayout src0({1, 1, 1, 12}, dtype::Float32());

  350.         megdnn::TensorLayout src1({1, 2, 2, 12}, {80, 40, 20, 1}, dtype::Float32());

  351. 

  352.         // BCAST111C_VEC_BCAST111C

  353.         checker.set_param(mode).execl({src0, src1, src0, {}});

  354.         // VEC_BCAST111C_VEC

  355.         checker.set_param(mode).execl({src1, src0, src1, {}});

  356.     };

  357.     run_3d_incontig(Mode::FUSE_MUL_ADD3);

  358. }

  359. 

  360. TEST_F(ARM_COMMON, ELEMWISE_FORWARD_N1HW_FP32_BCAST) {

  361.     using Mode = ElemwiseForward::Param::Mode;

  362.     Checker<ElemwiseForward> checker(handle());

  363. 

  364.     UniformFloatRNG rng(1e-5, 7e1);

  365.     checker.set_rng(0, &rng);

  366.     checker.set_epsilon(1e-5);

  367.     checker.set_dtype(0, dtype::Float32());

  368.     checker.set_dtype(1, dtype::Float32());

  369. 

  370.     //! 2 dim

  371.     auto run = [&](Mode mode) {

  372.         // VEC_BCASTX0X

  373.         checker.set_param(mode).execs({{2, 8, 4, 4}, {2, 1, 4, 4}, {}});

  374.         checker.set_param(mode).execs({{4, 21, 78}, {4, 1, 78}, {}});

  375.         // BCASTX0X_VEC

  376.         checker.set_param(mode).execs({{2, 1, 4, 4}, {2, 8, 4, 4}, {}});

  377.         checker.set_param(mode).execs({{4, 1, 78}, {4, 21, 78}, {}});

  378.     };

  379.     run(Mode::ADD);

  380.     run(Mode::MUL);

  381.     run(Mode::SUB);

  382. }

  383. 

  384. TEST_F(ARM_COMMON, ELEMWISE_FORWARD_TERNARY_RECORD) {

  385.     using Mode = ElemwiseForward::Param::Mode;

  386.     TaskRecordChecker<ElemwiseForward> checker(0);

  387.     checker.set_param(Mode::FUSE_MUL_ADD3);

  388. 

  389.     auto run = [&] {

  390.         //! nchw44

  391.         checker.execs({{1, 3, 1, 1, 4}, {1, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  392.         checker.execs({{1, 3, 1, 1, 4}, {2, 3, 2, 2, 4}, {1, 3, 1, 1, 4}, {}});

  393. 

  394.         //! nchw88

  395.         checker.execs({{1, 3, 1, 1, 8}, {1, 3, 2, 2, 8}, {1, 3, 1, 1, 8}, {}});

  396.         checker.execs({{1, 3, 1, 1, 8}, {2, 3, 2, 2, 8}, {1, 3, 1, 1, 8}, {}});

  397. 

  398.         checker.execs({{3, 4, 7}, {3, 4, 7}, {3, 4, 7}, {}});

  399.         checker.execs({{1, 4, 1, 1}, {3, 4, 5, 7}, {1, 4, 1, 1}, {}});

  400.     };

  401. 

  402.     // case int

  403.     checker.set_dtype(0, dtype::Int32());

  404.     checker.set_dtype(1, dtype::Int32());

  405.     checker.set_dtype(2, dtype::Int32());

  406.     run();

  407. 

  408.     // case float

  409.     UniformFloatRNG rng(1e-5, 7e1);

  410.     checker.set_rng(0, &rng);

  411.     checker.set_epsilon(1e-5);

  412.     checker.set_dtype(0, dtype::Float32());

  413.     checker.set_dtype(1, dtype::Float32());

  414.     checker.set_dtype(2, dtype::Float32());

  415.     run();

  416. }

  417. 

  418. #if MEGDNN_WITH_BENCHMARK

  419. namespace {

  420. void run_elemwise_benchmark(

  421.         const TensorShapeArray& shapes, param::Elemwise::Mode mode,

  422.         const char* mode_str, DType type, Handle* handle_bench) {

  423.     auto handle_fallback = create_cpu_handle(1);

  424.     Benchmarker<Elemwise> benchmarker_bench(handle_bench);

  425.     Benchmarker<Elemwise> benchmarker_fallback(handle_fallback.get());

  426. 

  427.     float throughput = 0;

  428.     SmallVector<TensorLayout> layouts;

  429.     std::string src_strs;

  430.     for (size_t i = 0; i < shapes.size(); i++) {

  431.         layouts.emplace_back(shapes[i], type);

  432.         throughput += layouts.back().span().dist_byte();

  433.         src_strs += layouts.back().to_string();

  434.         if (i != shapes.size() - 1) {

  435.             src_strs += ",";

  436.         }

  437.     }

  438.     constexpr size_t RUN = 50;

  439.     benchmarker_fallback.set_times(RUN).set_display(false);

  440.     benchmarker_bench.set_times(RUN).set_display(false);

  441. 

  442.     benchmarker_fallback.set_param(mode);

  443.     benchmarker_bench.set_param(mode);

  444. 

  445.     TensorLayout dst_layout;

  446.     auto opr = handle_bench->create_operator<Elemwise>();

  447.     opr->param() = mode;

  448.     opr->deduce_layout(layouts, dst_layout);

  449. 

  450.     float computations =

  451.             dst_layout.total_nr_elems() * (std::max<size_t>(shapes.size(), 2) - 1);

  452.     throughput += dst_layout.span().dist_byte();

  453.     computations *= (1e3 / (1024.0 * 1024));

  454.     throughput *= (1e3 / (1024.0 * 1024));

  455. 

  456.     layouts.emplace_back(dst_layout);

  457.     auto fallback_time = benchmarker_fallback.execl(layouts) / RUN;

  458.     auto bench_time = benchmarker_bench.execl(layouts) / RUN;

  459. 

  460.     float fallback_flops = computations / fallback_time;

  461.     float bench_flops = computations / bench_time;

  462.     float fallback_thr = throughput / fallback_time;

  463.     float bench_thr = throughput / bench_time;

  464. 

  465.     printf("%s = %s (type: %s, mode: %s) cpu=%fMFLOPS %fMB/s, bench=%fMFLOPS "

  466.            "%fMB/s "

  467.            "computations: %fx, throughput: %fx\n",

  468.            src_strs.c_str(), dst_layout.to_string().c_str(), type.name(), mode_str,

  469.            fallback_flops, fallback_thr, bench_flops, bench_thr,

  470.            bench_flops / fallback_flops, bench_thr / fallback_thr);

  471. }

  472. }  // namespace

  473. 

  474. TEST_F(ARM_COMMON, BENCHMARK_NCHW_VS_NHWC) {

  475.     Benchmarker<Elemwise> benchmarker(handle());

  476.     constexpr size_t RUN = 50;

  477.     benchmarker.set_times(RUN).set_display(false);

  478. 

  479.     auto run = [&](size_t N, size_t C, size_t H, size_t W, param::Elemwise::Mode mode,

  480.                    const char* mode_name) {

  481.         megdnn::param::Elemwise param;

  482.         param.mode = mode;

  483.         benchmarker.set_param(param);

  484.         megdnn::TensorShape nhwc_src0{N, H, W, C};

  485.         megdnn::TensorShape nhwc_src1{1, 1, 1, C};

  486. 

  487.         megdnn::TensorShape nchw_src0{N, C, H, W};

  488.         megdnn::TensorShape nchw_src1{1, C, 1, 1};

  489. 

  490.         float computations = N * C * H * W;

  491.         auto nhwc_time = benchmarker.execs({nhwc_src1, nhwc_src0, {}}) / RUN;

  492.         auto nchw_time = benchmarker.execs({nchw_src1, nchw_src0, {}}) / RUN;

  493.         auto perf_nhwc = computations / nhwc_time / 1e6;

  494.         auto perf_nchw = computations / nchw_time / 1e6;

  495.         printf("Elemwise Mode : %s\nNHWC : %fms  %fGflops\nNCHW : %fms  "

  496.                "%fGflops\n",

  497.                mode_name, nhwc_time, perf_nhwc, nchw_time, perf_nchw);

  498.     };

  499.     run(1, 120, 16, 24, param::Elemwise::Mode::ADD, "ADD");

  500.     run(1, 120, 16, 24, param::Elemwise::Mode::MUL, "MUL");

  501.     run(1, 120, 32, 48, param::Elemwise::Mode::ADD, "ADD");

  502.     run(1, 120, 32, 48, param::Elemwise::Mode::MUL, "MUL");

  503.     run(1, 120, 64, 96, param::Elemwise::Mode::ADD, "ADD");

  504.     run(1, 120, 64, 96, param::Elemwise::Mode::MUL, "MUL");

  505. }

  506. 

  507. #define INT_RUN(shape, mode)                                              \

  508.     run_elemwise_benchmark(shape, mode, #mode, dtype::Int8{}, handle());  \

  509.     run_elemwise_benchmark(shape, mode, #mode, dtype::Int16{}, handle()); \

  510.     run_elemwise_benchmark(shape, mode, #mode, dtype::Int32{}, handle());

  511. 

  512. #define FLOAT_RUN(shape, mode)                                              \

  513.     run_elemwise_benchmark(shape, mode, #mode, dtype::Float32{}, handle()); \

  514.     run_elemwise_benchmark(shape, mode, #mode, dtype::Float16{}, handle());

  515. 

  516. #define BENCHMARK_CASES(shape) \

  517.     INT_BENCHMARK_CASES(shape) \

  518.     FLOAT_BENCHMARK_CASES(shape)

  519. 

  520. TEST_F(ARM_COMMON, BENCHMARK_UNARY) {

  521. #define INT_BENCHMARK_CASES(shape) \

  522.     INT_RUN(shape, Mode::RELU);    \

  523.     INT_RUN(shape, Mode::ABS);

  524. 

  525. #define FLOAT_BENCHMARK_CASES(shape) \

  526.     FLOAT_RUN(shape, Mode::RELU);    \

  527.     FLOAT_RUN(shape, Mode::ABS);     \

  528.     FLOAT_RUN(shape, Mode::SIGMOID); \

  529.     FLOAT_RUN(shape, Mode::EXP);     \

  530.     FLOAT_RUN(shape, Mode::TANH);    \

  531.     FLOAT_RUN(shape, Mode::FAST_TANH);

  532. 

  533.     using Mode = param::Elemwise::Mode;

  534.     BENCHMARK_CASES({{10000}});

  535.     BENCHMARK_CASES({{50000}});

  536. 

  537. #undef INT_BENCHMARK_CASES

  538. #undef FLOAT_BENCHMARK_CASES

  539. }

  540. 

  541. TEST_F(ARM_COMMON, BENCHMARK_BINARY) {

  542. #define INT_BENCHMARK_CASES(shape) \

  543.     INT_RUN(shape, Mode::MIN);     \

  544.     INT_RUN(shape, Mode::MAX);     \

  545.     INT_RUN(shape, Mode::ADD);     \

  546.     INT_RUN(shape, Mode::SUB);     \

  547.     INT_RUN(shape, Mode::MUL);     \

  548.     INT_RUN(shape, Mode::RMULH);   \

  549.     INT_RUN(shape, Mode::FUSE_ADD_RELU);

  550. 

  551. #define FLOAT_BENCHMARK_CASES(shape)  \

  552.     FLOAT_RUN(shape, Mode::MIN);      \

  553.     FLOAT_RUN(shape, Mode::MAX);      \

  554.     FLOAT_RUN(shape, Mode::ADD);      \

  555.     FLOAT_RUN(shape, Mode::SUB);      \

  556.     FLOAT_RUN(shape, Mode::MUL);      \

  557.     FLOAT_RUN(shape, Mode::POW);      \

  558.     FLOAT_RUN(shape, Mode::TRUE_DIV); \

  559.     FLOAT_RUN(shape, Mode::FUSE_ADD_RELU);

  560. 

  561.     using Mode = param::Elemwise::Mode;

  562.     TensorShapeArray shapes = {{1, 112, 28, 28}, {1, 112, 28, 28}};

  563.     BENCHMARK_CASES(shapes);

  564.     shapes = {{1, 16, 1, 1}, {1, 16, 112, 112}};

  565.     BENCHMARK_CASES(shapes);

  566.     shapes = {{1, 448, 7, 7}, {1, 448, 7, 7}};

  567.     BENCHMARK_CASES(shapes);

  568. 

  569. #undef INT_BENCHMARK_CASES

  570. #undef FLOAT_BENCHMARK_CASES

  571. }

  572. 

  573. TEST_F(ARM_COMMON, BENCHMARK_TERNARY_FMA3) {

  574. #define INT_BENCHMARK_CASES(shape) INT_RUN(shape, Mode::FUSE_MUL_ADD3);

  575. 

  576. #define FLOAT_BENCHMARK_CASES(shape) FLOAT_RUN(shape, Mode::FUSE_MUL_ADD3);

  577. 

  578.     using Mode = param::Elemwise::Mode;

  579.     TensorShapeArray shapes = {{30, 40, 70}, {30, 40, 70}, {30, 40, 70}};

  580.     BENCHMARK_CASES(shapes);

  581.     shapes = {{1, 4, 1, 1}, {3, 4, 5, 7}, {1, 4, 1, 1}};

  582.     BENCHMARK_CASES(shapes);

  583.     shapes = {{3, 4, 5, 7}, {3, 4, 5, 7}, {1, 1, 1, 1}};

  584.     BENCHMARK_CASES(shapes);

  585. 

  586. #undef INT_BENCHMARK_CASES

  587. #undef FLOAT_BENCHMARK_CASES

  588. }

  589. 

  590. #undef BENCHMARK_CASES

  591. #undef INT_RUN

  592. #undef FLOAT_RUN

  593. 

  594. #endif

  595. 

  596. // vim: syntax=cpp.doxygen