OpenI
/
MegEngine
Not watched
1
0
Fork 0
Code
Releases 31 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
MegEngine/dnn/test/fallback/elemwise.cpp

378 lines
16 kB
Raw Permalink Blame History 

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

  2. 

  3. #include <ctime>

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

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

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

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

  8. 

  9. using namespace megdnn;

  10. using namespace test;

  11. 

  12. template <typename tag>

  13. class FALLBACK_ELEMWISE : public FALLBACK {};

  14. TYPED_TEST_CASE(FALLBACK_ELEMWISE, elemwise::test_types);

  15. TYPED_TEST(FALLBACK_ELEMWISE, run) {

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

  17. }

  18. TEST_F(FALLBACK, ELEMWISE_RECORD) {

  19.     TaskRecordChecker<Elemwise> checker{1};

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

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

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

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

  24.     UniformIntRNG rng{-100, 100};

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

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

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

  28.     checker.execs({{10, 10, 32}, {10, 10, 32}, {}});

  29. }

  30. 

  31. TEST_F(FALLBACK, ELEMWISE_FORWARD_TERNARY) {

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

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

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

  35. 

  36.     auto run = [&] {

  37.         //! nchw44

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

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

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

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

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

  43. 

  44.         //! nchw44

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

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

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

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

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

  50. 

  51.         //! nchw88

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

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

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

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

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

  57. 

  58.         //! nchw88

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

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

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

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

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

  64. 

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

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

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

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

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

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

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

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

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

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

  75.     };

  76. 

  77.     // case int

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

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

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

  81.     run();

  82. 

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

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

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

  86.     run();

  87. 

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

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

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

  91.     run();

  92. 

  93.     // case float

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

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

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

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

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

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

  100.     run();

  101. }

  102. 

  103. TEST_F(FALLBACK, ELEMWISE_FORWARD_NCHW44_INT8_INT16_INT32) {

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

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

  106. 

  107.     auto run = [&]() {

  108.         // VEC_BCAST101x not PowOp

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

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

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

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

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

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

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

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

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

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

  119.         checker.set_param(Mode::FUSE_ADD_RELU)

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

  121.         checker.set_param(Mode::FUSE_ADD_RELU)

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

  123.         checker.set_param(Mode::FUSE_ADD_RELU)

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

  125.         checker.set_param(Mode::FUSE_ADD_RELU)

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

  127.         checker.set_param(Mode::FUSE_ADD_RELU)

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

  129.         // BCAST101x_VEC not PowOp

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

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

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

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

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

  135.         checker.set_param(Mode::FUSE_ADD_RELU)

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

  137.         checker.set_param(Mode::FUSE_ADD_RELU)

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

  139.         checker.set_param(Mode::FUSE_ADD_RELU)

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

  141.         checker.set_param(Mode::FUSE_ADD_RELU)

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

  143.         checker.set_param(Mode::FUSE_ADD_RELU)

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

  145.     };

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

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

  148.     run();

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

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

  151.     run();

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

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

  154.     run();

  155. }

  156. 

  157. TEST_F(FALLBACK, ELEMWISE_FORWARD_NCHW44_FP32) {

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

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

  160. 

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

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

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

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

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

  166. 

  167.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  169.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  171.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  173.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  175.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  177.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  179.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  181.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  183.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  185.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  187. 

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

  189.         // VEC_BCAST101x

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

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

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

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

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

  195.         // BCAST101x_VEC not powOp

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

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

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

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

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

  201.     };

  202.     run(Mode::ADD);

  203.     run(Mode::FUSE_ADD_H_SWISH);

  204.     run(Mode::FUSE_ADD_RELU);

  205.     run(Mode::MAX);

  206.     run(Mode::MIN);

  207.     run(Mode::MUL);

  208.     run(Mode::SUB);

  209.     run(Mode::TRUE_DIV);

  210.     run(Mode::POW);

  211. }

  212. 

  213. TEST_F(FALLBACK, ELEMWISE_FORWARD_NCHW88_FP) {

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

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

  216. 

  217.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  219.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  221.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  223.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  225.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  227.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  229.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  231.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  233.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  235.     checker.set_param(Mode::FUSE_ADD_RELU)

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

  237. 

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

  239.         // VEC_BCAST101x

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

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

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

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

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

  245.         // BCAST101x_VEC not powOp

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

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

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

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

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

  251.     };

  252.     auto run_all = [&]() {

  253.         run(Mode::ADD);

  254.         run(Mode::FUSE_ADD_H_SWISH);

  255.         run(Mode::FUSE_ADD_RELU);

  256.         run(Mode::MAX);

  257.         run(Mode::MIN);

  258.         run(Mode::MUL);

  259.         run(Mode::SUB);

  260.         run(Mode::TRUE_DIV);

  261.         run(Mode::POW);

  262.     };

  263. 

  264.     {

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

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

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

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

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

  270.         run_all();

  271.     }

  272. }

  273. 

  274. TEST_F(FALLBACK, ELEMWISE_FORWARD_N1HW_FP32_BCAST) {

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

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

  277. 

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

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

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

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

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

  283. 

  284.     //! 2 dim

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

  286.         // VEC_BCASTX0X

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

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

  289.         // BCASTX0X_VEC

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

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

  292.     };

  293.     run(Mode::ADD);

  294.     run(Mode::MUL);

  295.     run(Mode::SUB);

  296. }

  297. 

  298. TEST_F(FALLBACK, ELEMWISE_FORWARD_TERNARY_RECORD) {

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

  300.     TaskRecordChecker<ElemwiseForward> checker(0);

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

  302. 

  303.     auto run = [&] {

  304.         //! nchw44

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

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

  307. 

  308.         //! nchw88

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

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

  311. 

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

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

  314.     };

  315. 

  316.     // case int

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

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

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

  320.     run();

  321. 

  322.     // case float

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

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

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

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

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

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

  329.     run();

  330. }

  331. 

  332. #if MEGDNN_WITH_BENCHMARK

  333. TEST_F(FALLBACK, BENCHMARK_ELEMWISE) {

  334.     auto naive_handle = create_cpu_handle(2);

  335.     auto run = [&](const TensorShape& shp0, const TensorShape& shp1) {

  336.         TensorShape shpo;

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

  338.         Tensor<> op0(handle(), {shp0, dtype::Float32()}),

  339.                 op1(handle(), {shp1, dtype::Float32()}),

  340.                 out(handle(), {shpo, dtype::Float32()});

  341.         auto opr_cur = handle()->create_operator<Elemwise>();

  342.         auto opr_naive = naive_handle->create_operator<Elemwise>();

  343.         opr_cur->param() = {Elemwise::Mode::ADD};

  344.         opr_naive->param() = {Elemwise::Mode::ADD};

  345. 

  346.         auto timeit = [&](Elemwise* opr) {

  347.             opr->exec({op0.tensornd(), op1.tensornd()}, out.tensornd());

  348.             auto start = clock();

  349.             opr->exec({op0.tensornd(), op1.tensornd()}, out.tensornd());

  350.             auto stop = clock();

  351.             return (stop - start) * 1e3 / CLOCKS_PER_SEC;

  352.         };

  353.         auto t0 = timeit(opr_cur.get()), t1 = timeit(opr_naive.get());

  354.         double tot_size_gb_ms =

  355.                 (op0.layout().span().dist_byte() + op1.layout().span().dist_byte() +

  356.                  out.layout().span().dist_byte()) /

  357.                 1024.0 / 1024.0 / 1024.0 * 1e3;

  358.         printf("%15s+%-15s: fallback=%7.3fms,%5.2fGiB/s "

  359.                "naive=%7.3fms,%5.2fGiB/s\n",

  360.                shp0.to_string().c_str(), shp1.to_string().c_str(), t0,

  361.                tot_size_gb_ms / t0, t1, tot_size_gb_ms / t1);

  362.     };

  363.     // contig

  364.     run({1024, 1024, 32}, {1024, 1024, 32});

  365.     // bcast 101

  366.     run({1024, 1024, 32}, {1, 1024, 1});

  367.     // bcast 01

  368.     run({4096 * 4, 1024}, {4096 * 4, 1});

  369.     // bcast 10

  370.     run({4096 * 4, 1024}, {1, 1024});

  371. 

  372.     // non-contig, fallback to naive

  373.     run({1024, 1024, 32}, {1024, 1, 32});

  374. }

  375. #endif

  376. 

  377. // vim: syntax=cpp.doxygen