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

954 lines
34 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/test/common/elemwise.cpp

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

  4.  *

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

  6.  *

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

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

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

  10.  */

  11. 

  12. #include "test/common/elemwise.h"

  13. #include "src/common/utils.cuh"

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

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

  16. 

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

  18. 

  19. #include "test/common/fix_gtest_on_platforms_without_exception.inl"

  20. 

  21. using namespace megdnn;

  22. using namespace test;

  23. 

  24. namespace {

  25.     void fma3_extra_opr_impl(const TensorNDArray &data) {

  26.         megdnn_assert(data.size() == 4);

  27.         auto handle = create_cpu_handle(2);

  28.         auto opr = handle->create_operator<Elemwise>();

  29.         using Mode = Elemwise::Mode;

  30.         opr->param().mode = Mode::MUL;

  31.         opr->exec({data[0], data[1]}, data[3]);

  32.         opr->param().mode = Mode::ADD;

  33.         opr->exec({data[2], data[3]}, data[3]);

  34.     }

  35. 

  36.     void fma4_extra_opr_impl(const TensorNDArray &data) {

  37.         megdnn_assert(data.size() == 5);

  38.         std::vector<uint8_t> tmp_storage(data[4].layout.span().dist_byte());

  39.         TensorND tmp;

  40.         tmp.raw_ptr = tmp_storage.data();

  41.         tmp.layout = data[4].layout;

  42.         tmp.layout.init_contiguous_stride();

  43.         auto handle = create_cpu_handle(2);

  44.         auto opr = handle->create_operator<Elemwise>();

  45.         using Mode = Elemwise::Mode;

  46.         opr->param().mode = Mode::MUL;

  47.         opr->exec({data[0], data[1]}, data[4]);

  48.         opr->exec({data[2], data[3]}, tmp);

  49.         opr->param().mode = Mode::ADD;

  50.         opr->exec({tmp, data[4]}, data[4]);

  51.     }

  52. 

  53.     TensorLayout make_layout(const TensorShape &shp,

  54.             std::initializer_list<ptrdiff_t> stride) {

  55.         TensorLayout ret{shp, dtype::Float32()};

  56.         megdnn_assert(stride.size() == shp.ndim);

  57.         auto idx = 0;

  58.         for (auto i: stride)

  59.             ret.stride[idx ++] = i;

  60.         return ret;

  61.     }

  62. } // anonymous namespace

  63. 

  64. namespace megdnn {

  65. namespace test {

  66. namespace elemwise {

  67. 

  68. #define DEF_TEST(name) \

  69. template<> \

  70. void run_test<name>(Handle *handle)

  71. 

  72. DEF_TEST(unary) {

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

  74.     Checker<ElemwiseForward> checker(handle);

  75.     checker.set_param(Mode::SIN);

  76.     checker.set_dtype(0, dtype::Float32()).execs({{3, 4, 1}, {}});

  77.     checker.set_dtype(0, dtype::Float16()).execs({{3, 4, 1}, {}});

  78. }

  79. 

  80. DEF_TEST(binary_brdcst) {

  81.     auto run = [&](DType dtype) {

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

  83.         Checker<ElemwiseForward> checker(handle);

  84.         checker.set_param(Mode::ADD);

  85.         checker.set_dtype(0, dtype);

  86.         checker.set_dtype(1, dtype);

  87.         checker.execs({{3, 1}, {1, 3}, {3, 3}});

  88.         {

  89.             checker.execs({{10, 11},

  90.                     {10, 11},

  91.                     {10, 11}});

  92.             //

  93.             checker.execs({{2, 3, 4, 5, 6, 7},

  94.                     {1, 3, 1, 1, 6, 1},

  95.                     {2, 3, 4, 5, 6, 7}});

  96.             checker.execs({{1, 3, 1, 1, 6, 1},

  97.                     {2, 3, 4, 5, 6, 7},

  98.                     {2, 3, 4, 5, 6, 7}});

  99.             //

  100.             checker.execs({{256, 256, 3},

  101.                     {1, 1, 3},

  102.                     {256, 256, 3}});

  103.             checker.execs({{1, 1, 3},

  104.                     {256, 256, 3},

  105.                     {256, 256, 3}});

  106.             //

  107.             checker.execs({{8, 1, 6, 1},

  108.                     {1, 7, 1, 5},

  109.                     {8, 7, 6, 5}});

  110.             checker.execs({{1, 7, 1, 5},

  111.                     {8, 1, 6, 1},

  112.                     {8, 7, 6, 5}});

  113.             //

  114.             checker.execs({{5, 4},

  115.                     {1, 1},

  116.                     {5, 4}});

  117.             checker.execs({{1, 1},

  118.                     {5, 4},

  119.                     {5, 4}});

  120.             //

  121.             checker.execs({{5, 4},

  122.                     {1, 4},

  123.                     {5, 4}});

  124.             checker.execs({{1, 4},

  125.                     {5, 4},

  126.                     {5, 4}});

  127.             //

  128.             checker.execs({{15, 3, 5},

  129.                     {15, 1, 5},

  130.                     {15, 3, 5}});

  131.             checker.execs({{15, 1, 5},

  132.                     {15, 3, 5},

  133.                     {15, 3, 5}});

  134.             //

  135.             checker.execs({{15, 3, 5},

  136.                     {1, 3, 5},

  137.                     {15, 3, 5}});

  138.             checker.execs({{1, 3, 5},

  139.                     {15, 3, 5},

  140.                     {15, 3, 5}});

  141.             //

  142.             checker.execs({{15, 3, 5},

  143.                     {1, 3, 1},

  144.                     {15, 3, 5}});

  145.             checker.execs({{1, 3, 1},

  146.                     {15, 3, 5},

  147.                     {15, 3, 5}});

  148.             //

  149.             checker.execs({{3, 1},

  150.                     {1, 4},

  151.                     {3, 4}});

  152.             // numpy broadcast

  153.             checker.execs({

  154.                     {2, 3, 1, 5}, {4, 5}, {2, 3, 4, 5}});

  155.             checker.execs({

  156.                     {3, 1, 1}, {4, 5}, {3, 4, 5}});

  157.         }

  158. 

  159.         {

  160.             // 1d

  161.             {

  162.                 auto n = 1000u;

  163.                 checker.execs({{n}, {n}, {n}});

  164.                 checker.execs({{1}, {n}, {n}});

  165.                 checker.execs({{n}, {1}, {n}});

  166.             }

  167. 

  168.             // 2d

  169.             {

  170.                 auto m = 200u, n = 100u;

  171.                 auto collapse = [](size_t n, bool is_collapsed) {

  172.                     return is_collapsed ? 1u : n;

  173.                 };

  174. 

  175.                 for (auto msk = 0u; msk < 16; ++msk) {

  176.                     checker.execs({

  177.                             {collapse(m, msk&1), collapse(n,msk&2)},

  178.                             {collapse(m, msk&4), collapse(n,msk&8)},

  179.                             {}});

  180.                 }

  181.             }

  182.             // nd

  183.             {

  184.                 checker.execs({

  185.                         {2, 3, 4, 5, 6},

  186.                         {1, 3, 1, 5, 6},

  187.                         {2, 3, 4, 5, 6}});

  188.                 checker.execs({

  189.                         {2, 3, 4, 5, 6},

  190.                         {2, 1, 4, 1, 6},

  191.                         {2, 3, 4, 5, 6}});

  192.             }

  193.         }

  194. 

  195.     };

  196.     run(dtype::Float32());

  197.     //run(dtype::Float16());

  198. }

  199. 

  200. DEF_TEST(binary_non_contig) {

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

  202.     Checker<ElemwiseForward> checker(handle);

  203.     checker.set_param(Mode::ADD);

  204.     TensorLayout ly{{2, 3}, dtype::Float32()};

  205.     ly.stride[0] = 4;

  206.     checker.execl({ly, ly, {{2, 3}, dtype::Float32()}});

  207. }

  208. 

  209. DEF_TEST(ternary) {

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

  211.     Checker<ElemwiseForward> checker(handle);

  212.     checker.set_param(Mode::COND_LEQ_MOV);

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

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

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

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

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

  218.     checker.set_dtype(0, dtype::Float16()).

  219.         set_dtype(1, dtype::Float16()).

  220.         set_dtype(2, dtype::Float16()).

  221.         set_dtype(3, dtype::Float16()).

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

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

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

  225.     ASSERT_THROW(checker.execs({{2, 3, 4}, {4, 1}, {1}, {2, 3, 4}}),

  226.                 MegDNNError);

  227.     ASSERT_THROW(checker.execs({{2, 4, 4}, {4, 1}, {3, 1, 1}, {2, 3, 4}}),

  228.                 MegDNNError);

  229. }

  230. 

  231. DEF_TEST(ternary_non_contig) {

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

  233.     Checker<ElemwiseForward> checker(handle);

  234.     checker.set_param(Mode::COND_LEQ_MOV);

  235.     TensorLayout ly{{2, 3}, dtype::Float32()};

  236.     ly.stride[0] = 4;

  237.     checker.execl({ly, ly, ly, {{2, 3}, dtype::Float32()}});

  238. }

  239. 

  240. 

  241. DEF_TEST(fuse_mul_add3) {

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

  243.     Checker<ElemwiseForward> checker(handle);

  244.     checker.set_param(Mode::FUSE_MUL_ADD3)

  245.         .set_extra_opr_impl(fma3_extra_opr_impl);

  246.     auto make_shape = [](const TensorShape &s0, const TensorShape &s1,

  247.             const TensorShape &s2) {

  248.         TensorShape dest;

  249.         dest.ndim = s0.ndim;

  250.         for (size_t i = 0; i < dest.ndim; ++ i) {

  251.             auto a = i < s0.ndim ? s0[i] : 1;

  252.             auto b = i < s1.ndim ? s1[i] : 1;

  253.             dest[i] = std::max(a, b);

  254.         }

  255.         return TensorShapeArray{s0, s1, s2, dest};

  256.     };

  257.     checker.exec(make_shape({2, 1}, {2, 2}, {2, 2}));

  258.     checker.exec(make_shape({2, 2}, {2, 1}, {2, 2}));

  259.     checker.exec(make_shape({2, 2}, {2, 2}, {1}));

  260.     checker.exec(make_shape({3, 1}, {1, 3}, {3, 1}));

  261.     checker.exec(make_shape(

  262.                 {2, 1, 2, 1, 2, 1},

  263.                 {1, 2, 1, 2, 1, 2},

  264.                 {1}));

  265.     checker.exec(make_shape({1, 1, 3}, {5, 8, 1}, {5, 8, 1}));

  266.     checker.exec(make_shape({1, 192, 9, 16}, {1}, {1, 192, 9, 16}));

  267. }

  268. 

  269. DEF_TEST(fuse_mul_add3_non_contig) {

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

  271.     Checker<ElemwiseForward> checker(handle);

  272.     checker.set_param(Mode::FUSE_MUL_ADD3)

  273.         .set_extra_opr_impl(fma3_extra_opr_impl);

  274.     TensorLayout ly{{2, 3}, dtype::Float32()};

  275.     ly.stride[0] = 4;

  276.     checker.execl({ly, ly, ly, {{2, 3}, dtype::Float32()}});

  277. }

  278. 

  279. DEF_TEST(fuse_mul_add4) {

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

  281.     Checker<ElemwiseForward> checker(handle);

  282.     checker.set_param(Mode::FUSE_MUL_ADD4)

  283.         .set_extra_opr_impl(fma4_extra_opr_impl);

  284.     auto make_shape = [](const TensorShape &s0, const TensorShape &s1,

  285.             bool swap = false) {

  286.         TensorShape dest;

  287.         dest.ndim = s0.ndim;

  288.         for (size_t i = 0; i < dest.ndim; ++ i) {

  289.             auto a = i < s0.ndim ? s0[i] : 1;

  290.             auto b = i < s1.ndim ? s1[i] : 1;

  291.             dest[i] = std::max(a, b);

  292.         }

  293.         TensorShapeArray ret{s0, s1, s0, s1, dest};

  294.         if (swap)

  295.             std::swap(ret[2], ret[3]);

  296.         return ret;

  297.     };

  298.     checker.exec(make_shape({2, 2}, {2, 2}));

  299.     checker.exec(make_shape({3, 1}, {1, 3}));

  300.     checker.exec(make_shape(

  301.                 {2, 1, 2, 1, 2, 1},

  302.                 {1, 2, 1, 2, 1, 2}));

  303.     checker.exec(make_shape({4, 2}, {1, 2}, true));

  304. }

  305. 

  306. DEF_TEST(rmulh) {

  307. 

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

  309.     Checker<ElemwiseForward> checker(handle);

  310. 

  311.     auto run_for_dtype = [&checker](auto dtype) {

  312.         auto minv = DTypeTrait<decltype(dtype)>::min();

  313.         auto maxv = DTypeTrait<decltype(dtype)>::max();

  314.         UniformIntRNG rng0{minv, maxv};

  315.         UniformIntRNG rngM{(maxv >> 1) + 1, maxv};

  316.         checker.set_param({Mode::RMULH})

  317.                 .set_dtype(0, dtype)

  318.                 .set_dtype(1, dtype)

  319.                 .set_dtype(2, dtype)

  320.                 .set_rng(0, &rng0)

  321.                 .set_rng(1, &rngM);

  322.         checker.execs({{7, 9, 11, 13}, {1}, {}})

  323.                 .execs({{16, 3, 256, 256}, {1}, {}})

  324.                 .execs({{2, 3, 1, 7}, {2, 3, 1, 7}, {}})

  325.                 .execs({{9, 5, 4}, {1, 5, 1}, {}})

  326.                 .execs({{233}, {1}, {}});

  327.     };

  328. 

  329.     run_for_dtype(dtype::Int8());

  330.     run_for_dtype(dtype::Int16());

  331.     run_for_dtype(dtype::Int32());

  332. }

  333. 

  334. /* ============= migrated from x86 tests ============= */

  335. 

  336. #define UNARY_TEST_CASE(_optr) \

  337.     checker.set_param(Mode::_optr).execs({{1, 127}, {}}); \

  338.     checker.set_param(Mode::_optr).execs({{1, 7}, {}});

  339. 

  340. #define BUILD_UNARY_TEST_CASE_INT \

  341.     UNARY_TEST_CASE(RELU) \

  342.     UNARY_TEST_CASE(ABS)

  343. 

  344. #define BUILD_UNARY_TEST_CASE_FLOAT \

  345.     UNARY_TEST_CASE(ABS) \

  346.     UNARY_TEST_CASE(LOG) \

  347.     UNARY_TEST_CASE(COS) \

  348.     UNARY_TEST_CASE(SIN) \

  349.     UNARY_TEST_CASE(FLOOR) \

  350.     UNARY_TEST_CASE(CEIL) \

  351.     UNARY_TEST_CASE(SIGMOID) \

  352.     UNARY_TEST_CASE(EXP) \

  353.     UNARY_TEST_CASE(TANH) \

  354.     UNARY_TEST_CASE(FAST_TANH) \

  355.     UNARY_TEST_CASE(RELU) \

  356.     UNARY_TEST_CASE(ROUND)

  357. 

  358. DEF_TEST(unary1) {

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

  360.     Checker<ElemwiseForward> checker(handle);

  361.     // case int

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

  363.     BUILD_UNARY_TEST_CASE_INT

  364. 

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

  366.     BUILD_UNARY_TEST_CASE_INT

  367. 

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

  369.     BUILD_UNARY_TEST_CASE_INT

  370. 

  371.     // case float

  372.     UniformFloatRNG rng(1e-2, 6e1);

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

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

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

  376.     BUILD_UNARY_TEST_CASE_FLOAT

  377. }

  378. 

  379. #undef UNARY_TEST_CASE

  380. #undef BUILD_UNARY_TEST_CASE_INT

  381. #undef BUILD_UNARY_TEST_CASE_FLOAT

  382. 

  383. 

  384. #define BINARY_TEST_CASE(_optr) \

  385.     checker.set_param(Mode::_optr).execs({{3, 4, 7}, {3, 4, 7}, {}}); \

  386.     checker.set_param(Mode::_optr).execs({{3, 4, 5, 7}, {1, 1, 1, 1}, {}}); \

  387.     checker.set_param(Mode::_optr).execs({{1, 1, 1, 1}, {3, 4, 5, 7}, {}}); \

  388.     checker.set_param(Mode::_optr).execs({{1, 2, 2}, {1, 1, 1}, {}}); \

  389.     checker.set_param(Mode::_optr).execs({{1, 1, 1}, {1, 2, 2}, {}}); \

  390.     checker.set_param(Mode::_optr).execs({{1, 7}, {1, 7}, {}});

  391. 

  392. #define BUILD_BINARY_TEST_CASE \

  393.     BINARY_TEST_CASE(MIN) \

  394.     BINARY_TEST_CASE(MAX)

  395. 

  396. #define BINARY_COMPLATE_TEST_CASE(_optr) \

  397.     checker.set_param(Mode::_optr).execs({{3, 4, 7}, {3, 4, 7}, {}}); \

  398.     checker.set_param(Mode::_optr).execs({{3, 4, 5, 7}, {1, 4, 1, 1}, {}}); \

  399.     checker.set_param(Mode::_optr).execs({{1, 4, 1, 1}, {3, 4, 5, 7}, {}}); \

  400.     checker.set_param(Mode::_optr).execs({{3, 4, 7}, {1, 4, 1}, {}}); \

  401.     checker.set_param(Mode::_optr).execs({{1, 4, 1}, {3, 4, 7}, {}}); \

  402.     checker.set_param(Mode::_optr).execs({{3, 4, 5, 7}, {1, 1, 1, 1}, {}}); \

  403.     checker.set_param(Mode::_optr).execs({{1, 1, 1, 1}, {3, 4, 5, 7}, {}}); \

  404.     checker.set_param(Mode::_optr).execs({{1, 7}, {1, 7}, {}}); \

  405.     checker.set_param(Mode::_optr).execs({{1, 2, 2}, {1, 2, 1}, {}}); \

  406.     checker.set_param(Mode::_optr).execs({{1, 2, 1}, {1, 2, 2}, {}}); \

  407.     checker.set_param(Mode::_optr).execs({{1, 2, 2}, {1, 1, 1}, {}}); \

  408.     checker.set_param(Mode::_optr).execs({{1, 1, 1}, {1, 2, 2}, {}}); \

  409.     checker.set_param(Mode::_optr).execs({{3, 4, 1}, {3, 4, 1}, {}}); \

  410. 

  411. #define BUILD_BINARY_COMPLATE_TEST_CASE \

  412.     BINARY_COMPLATE_TEST_CASE(ADD) \

  413.     BINARY_COMPLATE_TEST_CASE(MUL) \

  414.     BINARY_COMPLATE_TEST_CASE(MAX) \

  415.     BINARY_COMPLATE_TEST_CASE(MIN) \

  416.     BINARY_COMPLATE_TEST_CASE(SUB)

  417. 

  418. #define BUILD_BINARY_COMPLATE_TEST_CASE_FLOAT32 \

  419.     BINARY_COMPLATE_TEST_CASE(POW)              \

  420.     BINARY_COMPLATE_TEST_CASE(TRUE_DIV)         \

  421.     BINARY_COMPLATE_TEST_CASE(FUSE_ADD_SIGMOID) \

  422.     BINARY_COMPLATE_TEST_CASE(FUSE_ADD_TANH)    \

  423.     BINARY_COMPLATE_TEST_CASE(FUSE_ADD_RELU)    \

  424.     BINARY_COMPLATE_TEST_CASE(FUSE_ADD_H_SWISH) \

  425.     BINARY_COMPLATE_TEST_CASE(FAST_TANH_GRAD)   \

  426.     BINARY_COMPLATE_TEST_CASE(H_SWISH_GRAD)

  427. 

  428. DEF_TEST(binary1) {

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

  430.     Checker<ElemwiseForward> checker(handle);

  431. 

  432.     // case float

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

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

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

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

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

  438.     BUILD_BINARY_COMPLATE_TEST_CASE

  439.     BUILD_BINARY_COMPLATE_TEST_CASE_FLOAT32

  440. 

  441. 

  442.     // case int

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

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

  445.     BUILD_BINARY_TEST_CASE

  446.     BUILD_BINARY_COMPLATE_TEST_CASE

  447. 

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

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

  450.     BUILD_BINARY_TEST_CASE

  451.     BUILD_BINARY_COMPLATE_TEST_CASE

  452. 

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

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

  455.     BUILD_BINARY_TEST_CASE

  456.     BUILD_BINARY_COMPLATE_TEST_CASE

  457. }

  458. 

  459. #undef BINARY_TEST_CASE

  460. #undef BUILD_BINARY_TEST_CASE

  461. #undef BINARY_COMPLATE_TEST_CASE

  462. #undef BUILD_BINARY_COMPLATE_TEST_CASE

  463. #undef BUILD_BINARY_COMPLATE_TEST_CASE_FLOAT32

  464. 

  465. #define TERNARY_COMPLATE_TEST_CASE(_optr) \

  466.     checker.set_param(Mode::_optr).execs({{3, 4, 7}, {3, 4, 7}, {3, 4, 7}, {}}); \

  467.     checker.set_param(Mode::_optr).execs({{1, 4, 1, 1}, {3, 4, 5, 7}, {1, 4, 1, 1}, {}}); \

  468.     checker.set_param(Mode::_optr).execs({{1, 4, 1}, {3, 4, 7}, {1, 4, 1}, {}}); \

  469.     checker.set_param(Mode::_optr).execs({{3, 4, 5, 7}, {3, 4, 5, 7}, {1, 1, 1, 1}, {}}); \

  470.     checker.set_param(Mode::_optr).execs({{1, 7}, {1, 7}, {1, 7}, {}}); \

  471.     checker.set_param(Mode::_optr).execs({{1, 2, 1}, {1, 2, 2}, {1, 2, 1}, {}}); \

  472.     checker.set_param(Mode::_optr).execs({{1, 2, 2}, {1, 2, 2}, {1, 1, 1}, {}}); \

  473.     checker.set_param(Mode::_optr).execs({{3, 4, 1}, {3, 4, 1}, {3, 4, 1}, {}}); \

  474. 

  475. #define BUILD_TERNARY_COMPLATE_TEST_CASE \

  476.     TERNARY_COMPLATE_TEST_CASE(FUSE_MUL_ADD3)

  477. 

  478. 

  479. DEF_TEST(ternary1) {

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

  481.     Checker<ElemwiseForward> checker(handle);

  482.     // case int

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

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

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

  486.     //BUILD_TERNARY_TEST_CASE

  487.     BUILD_TERNARY_COMPLATE_TEST_CASE

  488. 

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

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

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

  492.     //BUILD_TERNARY_TEST_CASE

  493.     BUILD_TERNARY_COMPLATE_TEST_CASE

  494. 

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

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

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

  498.     //BUILD_TERNARY_TEST_CASE

  499.     BUILD_TERNARY_COMPLATE_TEST_CASE

  500. 

  501.     // case float

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

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

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

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

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

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

  508. 

  509.     //BUILD_TERNARY_TEST_CASE

  510.     BUILD_TERNARY_COMPLATE_TEST_CASE

  511.     //TERNARY_COMPLATE_TEST_CASE(FUSE_MUL_ADD3)

  512. }

  513. 

  514. #undef TERNARY_COMPLATE_TEST_CASE

  515. #undef BUILD_TERNARY_COMPLATE_TEST_CASE

  516. 

  517. /* ============= migrated from arm tests ============= */

  518. 

  519. #define UNARY_TEST_CASE(_optr) \

  520.     checker.set_param(Mode::_optr).execs({{1, 129}, {}}); \

  521.     checker.set_param(Mode::_optr).execs({{1, 7}, {}});

  522. 

  523. #define BUILD_UNARY_TEST_CASE_INT \

  524.     UNARY_TEST_CASE(RELU) \

  525.     UNARY_TEST_CASE(ABS) \

  526.     UNARY_TEST_CASE(NEGATE)

  527. 

  528. #define BUILD_UNARY_TEST_CASE_FLOAT \

  529.     BUILD_UNARY_TEST_CASE_INT       \

  530.     UNARY_TEST_CASE(SIGMOID)        \

  531.     UNARY_TEST_CASE(EXP)            \

  532.     UNARY_TEST_CASE(TANH)           \

  533.     UNARY_TEST_CASE(FAST_TANH)      \

  534.     UNARY_TEST_CASE(H_SWISH)

  535. 

  536. DEF_TEST(unary2) {

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

  538.     Checker<ElemwiseForward> checker(handle);

  539.     // case int

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

  541.     BUILD_UNARY_TEST_CASE_INT

  542. 

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

  544.     BUILD_UNARY_TEST_CASE_INT

  545. 

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

  547.     BUILD_UNARY_TEST_CASE_INT

  548. 

  549.     // case float

  550.     {

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

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

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

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

  555.         BUILD_UNARY_TEST_CASE_FLOAT

  556.     }

  557. 

  558.     {

  559.         UniformFloatRNG rng(1e-2, 1e1);

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

  561.         checker.set_epsilon(6e-3);

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

  563.         BUILD_UNARY_TEST_CASE_FLOAT

  564.     }

  565. 

  566.     // tanh NaN bug case

  567.     {

  568.         UniformFloatRNG rng(100, 200);

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

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

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

  572.         checker.set_param(Mode::TANH).execs({{1, 1025}, {}});

  573.         checker.set_param(Mode::TANH).execs({{1, 7}, {}});

  574.     }

  575. }

  576. 

  577. #undef UNARY_TEST_CASE

  578. #undef BUILD_UNARY_TEST_CASE_INT

  579. #undef BUILD_UNARY_TEST_CASE_FLOAT

  580. 

  581. #define BINARY_TEST_CASE(_optr) \

  582.     checker.set_param(Mode::_optr).execs({{3, 4, 7}, {3, 4, 7}, {}}); \

  583.     checker.set_param(Mode::_optr).execs({{3, 4, 5, 7}, {1, 1, 1, 1}, {}}); \

  584.     checker.set_param(Mode::_optr).execs({{1, 1, 1, 1}, {3, 4, 5, 7}, {}}); \

  585.     checker.set_param(Mode::_optr).execs({{1, 2, 2}, {1, 1, 1}, {}}); \

  586.     checker.set_param(Mode::_optr).execs({{1, 1, 1}, {1, 2, 2}, {}}); \

  587.     checker.set_param(Mode::_optr).execs({{1, 7}, {1, 7}, {}});

  588. 

  589. #define BUILD_BINARY_TEST_CASE \

  590.     BINARY_TEST_CASE(MIN) \

  591.     BINARY_TEST_CASE(MAX)

  592. 

  593. #define BINARY_COMPLATE_TEST_CASE(_optr) \

  594.     checker.set_param(Mode::_optr).execs({{3, 4, 7}, {3, 4, 7}, {}}); \

  595.     checker.set_param(Mode::_optr).execs({{3, 4, 5, 7}, {1, 4, 1, 1}, {}}); \

  596.     checker.set_param(Mode::_optr).execs({{1, 4, 1, 1}, {3, 4, 5, 7}, {}}); \

  597.     checker.set_param(Mode::_optr).execs({{3, 4, 7}, {1, 4, 1}, {}}); \

  598.     checker.set_param(Mode::_optr).execs({{1, 4, 1}, {3, 4, 7}, {}}); \

  599.     checker.set_param(Mode::_optr).execs({{3, 4, 5, 7}, {1, 1, 1, 1}, {}}); \

  600.     checker.set_param(Mode::_optr).execs({{1, 1, 1, 1}, {3, 4, 5, 7}, {}}); \

  601.     checker.set_param(Mode::_optr).execs({{1, 7}, {1, 7}, {}}); \

  602.     checker.set_param(Mode::_optr).execs({{1, 2, 2}, {1, 2, 1}, {}}); \

  603.     checker.set_param(Mode::_optr).execs({{1, 2, 1}, {1, 2, 2}, {}}); \

  604.     checker.set_param(Mode::_optr).execs({{1, 2, 2}, {1, 1, 1}, {}}); \

  605.     checker.set_param(Mode::_optr).execs({{1, 1, 1}, {1, 2, 2}, {}}); \

  606.     checker.set_param(Mode::_optr).execs({{3, 4, 1}, {3, 4, 1}, {}});

  607. 

  608. #define BUILD_BINARY_COMPLATE_TEST_CASE \

  609.     BINARY_COMPLATE_TEST_CASE(ADD)      \

  610.     BINARY_COMPLATE_TEST_CASE(MUL)      \

  611.     BINARY_COMPLATE_TEST_CASE(MAX)      \

  612.     BINARY_COMPLATE_TEST_CASE(MIN)      \

  613.     BINARY_COMPLATE_TEST_CASE(SUB)      \

  614.     BINARY_COMPLATE_TEST_CASE(FUSE_ADD_RELU)

  615. 

  616. DEF_TEST(binary2) {

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

  618.     Checker<ElemwiseForward> checker(handle);

  619. 

  620.     // case float

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

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

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

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

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

  626. 

  627.     BUILD_BINARY_COMPLATE_TEST_CASE

  628.     BINARY_COMPLATE_TEST_CASE(FUSE_ADD_SIGMOID)

  629.     BINARY_COMPLATE_TEST_CASE(FUSE_ADD_TANH)

  630. 

  631.     // case int

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

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

  634.     //BUILD_BINARY_TEST_CASE

  635.     BUILD_BINARY_COMPLATE_TEST_CASE

  636. 

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

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

  639.     //BUILD_BINARY_TEST_CASE

  640.     BUILD_BINARY_COMPLATE_TEST_CASE

  641. 

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

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

  644.     BUILD_BINARY_TEST_CASE

  645.     BUILD_BINARY_COMPLATE_TEST_CASE

  646. 

  647.     // case float

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

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

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

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

  652.     checker.set_param(Mode::FUSE_ADD_SIGMOID).execs({{3, 4, 7}, {1}, {}});

  653.     checker.set_param(Mode::FUSE_ADD_TANH).execs({{3, 4, 7}, {1}, {}});

  654. 

  655.     // commutable

  656.     checker.set_param(Mode::TRUE_DIV).execs({{1}, {4}, {}});

  657. 

  658.     BUILD_BINARY_TEST_CASE

  659.     BUILD_BINARY_COMPLATE_TEST_CASE

  660.     BINARY_COMPLATE_TEST_CASE(TRUE_DIV)

  661. 

  662.     {

  663.         UniformFloatRNG rng(1e-3, 3e1);

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

  665.         checker.set_rng(1, &rng);

  666.         checker.set_epsilon(1e-3);

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

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

  669.         checker.set_param(Mode::FUSE_ADD_SIGMOID).execs({{3, 4, 7}, {1}, {}});

  670.         checker.set_param(Mode::FUSE_ADD_TANH).execs({{3, 4, 7}, {1}, {}});

  671. 

  672.         BUILD_BINARY_TEST_CASE

  673.         BUILD_BINARY_COMPLATE_TEST_CASE

  674.         BINARY_COMPLATE_TEST_CASE(TRUE_DIV)

  675. 

  676.         // commutable

  677.         checker.set_param(Mode::TRUE_DIV).execs({{1}, {4}, {}});

  678.     }

  679. 

  680. }

  681. 

  682. #undef BINARY_TEST_CASE

  683. #undef BUILD_BINARY_TEST_CASE

  684. #undef BINARY_COMPLATE_TEST_CASE

  685. #undef BUILD_BINARY_COMPLATE_TEST_CASE

  686. 

  687. #define TERNARY_COMPLATE_TEST_CASE(_optr) \

  688.     checker.set_param(Mode::_optr).execs({{1, 123, 1}, {300, 123, 253}, {300, 123, 253}, {}}); \

  689.     checker.set_param(Mode::_optr).execs({{3, 4, 7}, {3, 4, 7}, {3, 4, 7}, {}}); \

  690.     checker.set_param(Mode::_optr).execs({{1, 4, 1, 1}, {3, 4, 5, 7}, {1, 4, 1, 1}, {}}); \

  691.     checker.set_param(Mode::_optr).execs({{1, 4, 1}, {3, 4, 7}, {1, 4, 1}, {}}); \

  692.     checker.set_param(Mode::_optr).execs({{3, 4, 5, 7}, {3, 4, 5, 7}, {1, 1, 1, 1}, {}}); \

  693.     checker.set_param(Mode::_optr).execs({{1, 7}, {1, 7}, {1, 7}, {}}); \

  694.     checker.set_param(Mode::_optr).execs({{1, 2, 1}, {1, 2, 2}, {1, 2, 1}, {}}); \

  695.     checker.set_param(Mode::_optr).execs({{1, 2, 2}, {1, 2, 2}, {1, 1, 1}, {}}); \

  696.     checker.set_param(Mode::_optr).execs({{3, 4, 1}, {3, 4, 1}, {3, 4, 1}, {}}); \

  697.     checker.set_param(Mode::_optr).execs({{3, 4, 1}, {1, 1, 1}, {3, 4, 1}, {}}); \

  698. 

  699. #define BUILD_TERNARY_COMPLATE_TEST_CASE \

  700.     TERNARY_COMPLATE_TEST_CASE(FUSE_MUL_ADD3)

  701. 

  702. 

  703. DEF_TEST(ternary2) {

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

  705.     Checker<ElemwiseForward> checker(handle);

  706.     // case int

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

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

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

  710.     BUILD_TERNARY_COMPLATE_TEST_CASE

  711. 

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

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

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

  715.     BUILD_TERNARY_COMPLATE_TEST_CASE

  716. 

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

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

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

  720.     BUILD_TERNARY_COMPLATE_TEST_CASE

  721. 

  722.     // case float

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

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

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

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

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

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

  729.     BUILD_TERNARY_COMPLATE_TEST_CASE

  730. 

  731.     {

  732.         UniformFloatRNG rng(1e-3, 3e1);

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

  734.         checker.set_rng(1, &rng);

  735.         checker.set_rng(2, &rng);

  736.         checker.set_epsilon(1e-3);

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

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

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

  740.         BUILD_TERNARY_COMPLATE_TEST_CASE

  741. 

  742.     }

  743. }

  744. 

  745. #undef TERNARY_COMPLATE_TEST_CASE

  746. #undef BUILD_TERNARY_COMPLATE_TEST_CASE

  747. 

  748. /* ============= migrated from fallback tests ============= */

  749. 

  750. DEF_TEST(unary3) {

  751.     Checker<Elemwise> checker(handle);

  752.     auto make_layouts = [](

  753.             const TensorShape &shp, std::initializer_list<ptrdiff_t> stride) ->

  754.             TensorLayoutArray{

  755.         return {make_layout(shp, stride), {shp, dtype::Float32()}};

  756.     };

  757.     checker.set_param({Elemwise::Mode::SIN});

  758. 

  759.     checker.exec(make_layouts({2, 2}, {2, 1}));

  760.     checker.exec(make_layouts({4}, {3}));

  761. }

  762. 

  763. DEF_TEST(binary3) {

  764.     Checker<Elemwise> checker(handle);

  765.     checker.set_param({Elemwise::Mode::ADD});

  766. 

  767.     auto run = [&](

  768.             const TensorShape &shp0, std::initializer_list<ptrdiff_t> stride0,

  769.             const TensorShape &shp1, std::initializer_list<ptrdiff_t> stride1) {

  770.         TensorShape shpo;

  771.         Elemwise::deduce_shape({shp0, shp1}, shpo);

  772.         auto ly0 = make_layout(shp0, stride0),

  773.              ly1 = make_layout(shp1, stride1),

  774.              lyo = TensorLayout{shpo, dtype::Float32()};

  775.         checker.execl({ly0, ly1, lyo});

  776.         checker.execl({ly1, ly0, lyo});

  777.     };

  778. 

  779.     run({2, 2}, {2, 1}, {2, 2}, {2, 1});

  780.     run({1}, {1}, {3, 3}, {1, 2});

  781.     run({3, 4, 5}, {40, 10, 2}, {1, 4, 1}, {1, 1, 1});

  782. }

  783. 

  784. DEF_TEST(all_modes) {

  785.     // test correctness of all elemwise modes

  786.     Checker<Elemwise> checker(handle);

  787.     TensorShapeArray shapes;

  788.     UniformFloatRNG default_rng_f32{-100.f, 100.f}, pos_rng_f32{.1f, 1000.f},

  789.             small_pos_rng_f32{.1f, .10f}, small_rng_f32{-3.f, 3.f},

  790.             abslt1_rng_f32{-1.f, 1.f}, uniform_0_2_rng{0.f, 2.f},

  791.             tanh_rng_f32{-5.f, 5.f};

  792.     UniformFloatNonZeroRNG nonzero_rng_f32{.1f, 1000.f},

  793.             big_nonzero_rng_f32{100.f, 1000.f};

  794.     UniformIntRNG default_rng_i32{-100, 100}, small_rng_i32{-2, 2},

  795.             shift_rng_i32_i32{0, 31}, shift_rng_i32_i8{0, 7};

  796.     UniformIntNonZeroRNG nonzero_rng_i32{1, 100};

  797. 

  798.     using Mode = Elemwise::Mode;

  799. 

  800.     auto should_ignore = [handle](Mode mode) {

  801.         MEGDNN_MARK_USED_VAR(mode);

  802.         return false;

  803.     };

  804. 

  805.     for (int mode_nr = 0;

  806.          mode_nr < static_cast<int>(Elemwise::Param::MODE_NR_MEMBER);

  807.          ++mode_nr) {

  808.         auto mode = static_cast<Mode>(mode_nr);

  809. 

  810.         // ignore unsupported modes

  811.         if (should_ignore(mode)) {

  812.             continue;

  813.         }

  814. 

  815.         checker.set_param({mode});

  816.         auto&& trait = Elemwise::ModeTrait::from_mode(mode);

  817.         shapes.resize(trait.arity + 1);

  818.         for (size_t i = 0; i < shapes.size() - 1; ++i) {

  819.             shapes[i] = {3, 9, 7};

  820.         }

  821.         auto do_run = [&](DType dtype, float eps = 1e-3) {

  822.             // limit value ranges for some modes

  823.             if (mode == Mode::LOG || mode == Mode::LOG1P) {

  824.                 checker.set_rng(0, &pos_rng_f32);

  825.             } else if (mode == Mode::POW) {

  826.                 checker.set_rng(0, &small_pos_rng_f32);

  827.                 checker.set_rng(1, &small_rng_f32);

  828.             } else if (mode == Mode::EXP || mode == Mode::EXPM1) {

  829.                 checker.set_rng(0, &small_rng_f32);

  830.             } else if (mode == Mode::FAST_TANH) {

  831.                 checker.set_rng(0, &tanh_rng_f32);

  832.             } else if (mode == Mode::LOG_SUM_EXP) {

  833.                 // check numerical stability with large values

  834.                 checker.set_rng(0, &big_nonzero_rng_f32);

  835.                 checker.set_rng(1, &big_nonzero_rng_f32);

  836.             } else if (mode == Mode::ASIN || mode == Mode::ACOS ||

  837.                        mode == Mode::SIGMOID_GRAD || mode == Mode::TANH_GRAD ||

  838.                        mode == Mode::ERFINV) {

  839.                 checker.set_rng(0, &abslt1_rng_f32);

  840.                 checker.set_rng(1, &default_rng_f32);

  841.             } else if (mode == Mode::ERFCINV) {

  842.                 checker.set_rng(0, &uniform_0_2_rng);

  843.             } else if (mode == Mode::MOD || mode == Mode::TRUE_DIV ||

  844.                        mode == Mode::FLOOR_DIV) {

  845.                 if (dtype.category() == DTypeCategory::INT) {

  846.                     checker.set_rng(0, &default_rng_i32);

  847.                     checker.set_rng(1, &nonzero_rng_i32);

  848.                 } else {

  849.                     checker.set_rng(0, &default_rng_f32);

  850.                     checker.set_rng(1, &nonzero_rng_f32);

  851.                 }

  852.             } else if (mode == Mode::EQ) {

  853.                 checker.set_rng(0, &small_rng_i32);

  854.                 checker.set_rng(1, &small_rng_i32);

  855.             } else if (mode == Mode::SHL || mode == Mode::SHR) {

  856.                 checker.set_rng(0, &default_rng_i32);

  857.                 if (dtype.size() == 4) {

  858.                     checker.set_rng(1, &shift_rng_i32_i32);

  859.                 } else {

  860.                     megdnn_assert(dtype.size() == 1);

  861.                     checker.set_rng(1, &shift_rng_i32_i8);

  862.                 }

  863.             } else if (mode == Mode::ATAN2) {

  864.                 checker.set_rng(0, &nonzero_rng_f32);

  865.                 checker.set_rng(1, &nonzero_rng_f32);

  866.             } else {

  867.                 RNG* rng;

  868.                 if (dtype.category() == DTypeCategory::INT) {

  869.                     rng = &default_rng_i32;

  870.                 } else {

  871.                     rng = &default_rng_f32;

  872.                 }

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

  874.                     checker.set_rng(i, rng);

  875.                 }

  876.             }

  877. 

  878.             checker.set_epsilon(eps);

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

  880.                 checker.set_dtype(i, dtype);

  881.             }

  882.             EXPECT_NO_THROW(checker.execs(shapes));

  883.             if (!::testing::Test::HasFailure() && shapes.size() == 3) {

  884.                 // channel bcast

  885.                 shapes[1][0] = 1;

  886.                 shapes[1][2] = 1;

  887.                 EXPECT_NO_THROW(checker.execs(shapes));

  888. 

  889.                 if (!::testing::Test::HasFailure()) {

  890.                     // scalar bcast

  891.                     shapes[1][1] = 1;

  892.                     EXPECT_NO_THROW(checker.execs(shapes));

  893.                 }

  894.             }

  895.             if (::testing::Test::HasFailure()) {

  896.                 printf("failed on mode=%d(%s) dtype=%s\n", mode_nr, trait.name,

  897.                        dtype.name());

  898.                 for (auto&& i : shapes) {

  899.                     printf("ishape: %s\n", i.to_string().c_str());

  900.                 }

  901.                 return false;

  902.             }

  903.             return true;

  904.         };

  905. #define run(args...)         \

  906.     do {                     \

  907.         if (!do_run(args)) { \

  908.             return;          \

  909.         }                    \

  910.     } while (0)

  911. 

  912.         if (trait.allow_int) {

  913.             run(dtype::Int8{});

  914.             run(dtype::Int32{});

  915.         }

  916.         if (trait.allow_float) {

  917.             MEGDNN_FLOAT16_SELECT(

  918.                     run(dtype::Float16{},

  919.                         mode == Mode::FAST_TANH_GRAD ? 0.5 : 0.05), );

  920.             run(dtype::Float32{});

  921.         }

  922.     }

  923. 

  924. #undef run

  925. }

  926. 

  927. TEST(TEST_ELEMWISE, MODE_TRAIT) {

  928.     using M = Elemwise::Mode;

  929.     using T = Elemwise::ModeTrait;

  930.     ASSERT_EQ(1u, T::from_mode(M::RELU).arity);

  931.     ASSERT_EQ(2u, T::from_mode(M::ADD).arity);

  932.     ASSERT_EQ(3u, T::from_mode(M::FUSE_MUL_ADD3).arity);

  933.     ASSERT_EQ(4u, T::from_mode(M::FUSE_MUL_ADD4).arity);

  934.     ASSERT_TRUE(T::from_mode(M::ADD).commutable);

  935.     ASSERT_FALSE(T::from_mode(M::TRUE_DIV).commutable);

  936. 

  937.     ASSERT_TRUE(T::from_mode(M::ADD).allow_int);

  938.     ASSERT_FALSE(T::from_mode(M::EXP).allow_int);

  939. 

  940.     ASSERT_TRUE(T::from_mode(M::ADD).allow_float);

  941.     ASSERT_FALSE(T::from_mode(M::SHL).allow_float);

  942. 

  943.     ASSERT_TRUE(T::from_mode(M::RMULH).commutable);

  944.     ASSERT_FALSE(T::from_mode(M::RMULH).allow_float);

  945. 

  946.     ASSERT_TRUE(T::from_mode(M::XOR).allow_bool);

  947. }

  948. 

  949. } // namespace elemwise

  950. } // namespace test

  951. } // namespace megdnn

  952. 

  953. // vim: syntax=cpp.doxygen