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

432 lines
18 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/test/cuda/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 "test/cuda/fixture.h"

  14. #include "megdnn/oprs.h"

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

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

  17. #include "./utils.h"

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

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

  20. 

  21. #include <cudnn.h>

  22. #include <cuda_profiler_api.h>

  23. 

  24. using namespace megdnn;

  25. using namespace test;

  26. 

  27. #define cudnn_check(e) megdnn_assert((e) == CUDNN_STATUS_SUCCESS)

  28. namespace {

  29.     __attribute__((unused))

  30.     cudnnTensorDescriptor_t make_cudnn_tensor_desc(const TensorLayout &ly) {

  31.         megdnn_assert(ly.ndim && ly.ndim <= 4 && ly.is_contiguous());

  32.         int dim[4] = {1, 1, 1, 1}, stride[4] = {1, 1, 1, 1};

  33.         for (size_t i = 0; i < ly.ndim; ++ i) {

  34.             dim[i] = ly.shape[i];

  35.             stride[i] = ly.stride[i];

  36.         }

  37.         cudnnTensorDescriptor_t ret;

  38.         cudnn_check(cudnnCreateTensorDescriptor(&ret));

  39.         // cudnn requires tensors to be at-least 4D

  40.         cudnn_check(cudnnSetTensor4dDescriptorEx(ret,

  41.                     CUDNN_DATA_FLOAT,

  42.                     dim[0], dim[1], dim[2], dim[3],

  43.                     stride[0], stride[1], stride[2], stride[3]));

  44. 

  45.         return ret;

  46.     }

  47. 

  48.     void run_tensor_add(

  49.             Handle *handle_cuda,

  50.             const TensorND &a, const TensorND &b,

  51.             const TensorND &c) {

  52. #if 1

  53.         cudnnHandle_t cudnn_handle;

  54.         cudnn_check(cudnnCreate(&cudnn_handle));

  55.         cuda_check(cudaDeviceSynchronize());

  56.         cuda_check(cudaMemcpy(c.raw_ptr, a.raw_ptr, a.layout.span().dist_byte(),

  57.                     cudaMemcpyDeviceToDevice));

  58. 

  59.         auto bdesc = make_cudnn_tensor_desc(b.layout),

  60.              cdesc = make_cudnn_tensor_desc(c.layout);

  61. 

  62.         float alpha = 1, beta = 1;

  63.         cudaProfilerStart();

  64.         cudnn_check(cudnnAddTensor(cudnn_handle,

  65.                 &alpha, bdesc, b.raw_ptr,

  66.                 &beta, cdesc, c.raw_ptr));

  67.         cudaProfilerStop();

  68. 

  69.         cudnn_check(cudnnDestroyTensorDescriptor(cdesc));

  70.         cudnn_check(cudnnDestroyTensorDescriptor(bdesc));

  71.         cudnn_check(cudnnDestroy(cudnn_handle));

  72. 

  73.         cuda_check(cudaMemset(c.raw_ptr, 0, c.layout.span().dist_byte()));

  74.         cuda_check(cudaDeviceSynchronize());

  75. #endif

  76. 

  77.         auto opr = handle_cuda->create_operator<ElemwiseForward>();

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

  79.         cudaProfilerStart();

  80.         opr->exec({a, b}, c);

  81.         cudaProfilerStop();

  82.     }

  83. 

  84. } // anonymous namespace

  85. 

  86. template<typename tag>

  87. class CUDA_ELEMWISE: public CUDA {

  88. };

  89. TYPED_TEST_CASE(CUDA_ELEMWISE, elemwise::test_types);

  90. TYPED_TEST(CUDA_ELEMWISE, run) {

  91.     elemwise::run_test<TypeParam>(this->handle_cuda());

  92. }

  93. 

  94. TEST_F(CUDA, ELEMWISE_IBYTE) {

  95.     Checker<ElemwiseForward> checker(handle_cuda());

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

  97.     UniformIntRNG i_rng{-128, 127};

  98.     UniformIntRNG ui_rng{0, 255};

  99.     checker.set_rng(0, &i_rng);

  100.     auto run_unary = [&](size_t N, Mode mode, DType dtype) {

  101.         checker.set_param(mode).set_dtype(0, dtype);

  102.         checker.execs({{N}, {}});

  103.     };

  104. #define RUN_UNARY_IBYTE(_dt)         \

  105.     run_unary(100, Mode::RELU, _dt); \

  106.     run_unary(100, Mode::ABS, _dt);

  107.     RUN_UNARY_IBYTE(dtype::Int8());

  108.     checker.set_rng(0, &i_rng);

  109.     RUN_UNARY_IBYTE(dtype::Uint8());

  110. #undef RUN_UNARY_IBYTE

  111.     auto run_binary = [&](size_t N, size_t C, size_t H, size_t W, Mode mode,

  112.                           DType dtype) {

  113.         checker.set_param(mode).set_dtype(0, dtype).set_dtype(1, dtype);

  114.         checker.execs({{5}, {5}, {}});

  115.         checker.execs({{4}, {4}, {}});

  116.         checker.execs({{4}, {1}, {}});

  117.         checker.execs({{N, C / 4, H, W, 4}, {N, C / 4, H, W, 4}, {}});

  118.         checker.execs({{N, C / 4, H, W, 4}, {1, C / 4, 1, 1, 4}, {}});

  119.         checker.execs({{N, C / 32, H, W, 32}, {N, C / 32, H, W, 32}, {}});

  120.         checker.execs({{N, C / 32, H, W, 32}, {1, C / 32, 1, 1, 32}, {}});

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

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

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

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

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

  126.     };

  127. #define RUN_BINARY_IBYTE(_dt)                  \

  128.     run_binary(4, 32, 10, 10, Mode::ADD, _dt); \

  129.     run_binary(4, 32, 10, 10, Mode::MUL, _dt); \

  130.     run_binary(4, 32, 10, 10, Mode::MAX, _dt); \

  131.     run_binary(4, 32, 10, 10, Mode::MIN, _dt); \

  132.     run_binary(4, 32, 10, 10, Mode::SUB, _dt);

  133.     checker.set_rng(0, &i_rng).set_rng(1, &i_rng);

  134.     RUN_BINARY_IBYTE(dtype::Int8());

  135.     checker.set_rng(0, &ui_rng).set_rng(1, &ui_rng);

  136.     RUN_BINARY_IBYTE(dtype::Uint8());

  137. #undef RUN_BINARY_IBYTE

  138.     auto run_ternary = [&](size_t N, size_t C, size_t H, size_t W, Mode mode,

  139.                            DType dtype) {

  140.         checker.set_param(mode)

  141.                 .set_dtype(0, dtype)

  142.                 .set_dtype(1, dtype)

  143.                 .set_dtype(2, dtype);

  144.         checker.execs({{5}, {5}, {5}, {}});

  145.         checker.execs({{4}, {4}, {1}, {}});

  146.         checker.execs({{N, C / 4, H, W, 4},

  147.                        {N, C / 4, H, W, 4},

  148.                        {N, C / 4, H, W, 4},

  149.                        {}});

  150.         checker.execs({{N, C / 4, H, W, 4},

  151.                        {1, C / 4, 1, 1, 4},

  152.                        {1, C / 4, 1, 1, 4},

  153.                        {}});

  154.         checker.execs({{N, C / 32, H, W, 32},

  155.                        {N, C / 32, H, W, 32},

  156.                        {N, C / 32, H, W, 32},

  157.                        {}});

  158.         checker.execs({{N, C / 32, H, W, 32},

  159.                        {1, C / 32, 1, 1, 32},

  160.                        {1, C / 32, 1, 1, 32},

  161.                        {}});

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

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

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

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

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

  167.     };

  168. #define RUN_TERNARY_IBYTE(_dt) \

  169.     run_ternary(4, 32, 10, 10, Mode::FUSE_MUL_ADD3, _dt);

  170.     checker.set_rng(0, &i_rng).set_rng(1, &i_rng);

  171.     RUN_TERNARY_IBYTE(dtype::Int8());

  172.     checker.set_rng(0, &ui_rng).set_rng(1, &ui_rng);

  173.     RUN_TERNARY_IBYTE(dtype::Uint8());

  174. #undef RUN_TERNARY_IBYTE

  175. }

  176. 

  177. // from common/elemwise.cpp

  178. TEST_F(CUDA, ELEMWISE_BFLOAT16) {

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

  180.     Checker<ElemwiseForward> checker(handle_cuda());

  181. 

  182.     // unary

  183. #define UNARY_TEST_CASE(_optr)                            \

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

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

  186. 

  187. #define BUILD_UNARY_TEST_CASE_FLOAT \

  188.     UNARY_TEST_CASE(ABS)            \

  189.     UNARY_TEST_CASE(LOG)            \

  190.     UNARY_TEST_CASE(COS)            \

  191.     UNARY_TEST_CASE(SIN)            \

  192.     UNARY_TEST_CASE(FLOOR)          \

  193.     UNARY_TEST_CASE(CEIL)           \

  194.     UNARY_TEST_CASE(SIGMOID)        \

  195.     UNARY_TEST_CASE(EXP)            \

  196.     UNARY_TEST_CASE(TANH)           \

  197.     UNARY_TEST_CASE(FAST_TANH)      \

  198.     UNARY_TEST_CASE(RELU)           \

  199.     UNARY_TEST_CASE(ROUND)

  200. 

  201.     checker.set_dtype(0, dtype::BFloat16());

  202.     checker.set_dtype(1, dtype::BFloat16());

  203.     UniformFloatRNG rng0(1e-2, 6e1);

  204.     checker.set_rng(0, &rng0);

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

  206.     BUILD_UNARY_TEST_CASE_FLOAT

  207. 

  208. #undef UNARY_TEST_CASE

  209. #undef BUILD_UNARY_TEST_CASE_FLOAT

  210. 

  211.     // binary

  212. #define BINARY_COMPLATE_TEST_CASE(_optr)                                    \

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

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

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

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

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

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

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

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

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

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

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

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

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

  226. 

  227. #define BUILD_BINARY_COMPLATE_TEST_CASE \

  228.     BINARY_COMPLATE_TEST_CASE(ADD)      \

  229.     BINARY_COMPLATE_TEST_CASE(MUL)      \

  230.     BINARY_COMPLATE_TEST_CASE(MAX)      \

  231.     BINARY_COMPLATE_TEST_CASE(MIN)      \

  232.     BINARY_COMPLATE_TEST_CASE(SUB)

  233. 

  234.     UniformFloatRNG rng1(1e-5, 7e1);

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

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

  237.     checker.set_dtype(0, dtype::BFloat16());

  238.     checker.set_dtype(1, dtype::BFloat16());

  239.     BUILD_BINARY_COMPLATE_TEST_CASE

  240. 

  241. #undef BINARY_COMPLATE_TEST_CASE

  242. #undef BUILD_BINARY_COMPLATE_TEST_CASE

  243. 

  244.     // ternary

  245. #define TERNARY_COMPLATE_TEST_CASE(_optr)                               \

  246.     checker.set_param(Mode::_optr)                                      \

  247.             .execs({{3, 4, 7}, {3, 4, 7}, {3, 4, 7}, {}});              \

  248.     checker.set_param(Mode::_optr)                                      \

  249.             .execs({{1, 4, 1, 1}, {3, 4, 5, 7}, {1, 4, 1, 1}, {}});     \

  250.     checker.set_param(Mode::_optr)                                      \

  251.             .execs({{1, 4, 1}, {3, 4, 7}, {1, 4, 1}, {}});              \

  252.     checker.set_param(Mode::_optr)                                      \

  253.             .execs({{3, 4, 5, 7}, {3, 4, 5, 7}, {1, 1, 1, 1}, {}});     \

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

  255.     checker.set_param(Mode::_optr)                                      \

  256.             .execs({{1, 2, 1}, {1, 2, 2}, {1, 2, 1}, {}});              \

  257.     checker.set_param(Mode::_optr)                                      \

  258.             .execs({{1, 2, 2}, {1, 2, 2}, {1, 1, 1}, {}});              \

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

  260. 

  261. #define BUILD_TERNARY_COMPLATE_TEST_CASE \

  262.     TERNARY_COMPLATE_TEST_CASE(FUSE_MUL_ADD3)

  263. 

  264.     UniformFloatRNG rng2(1e-5, 7e1);

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

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

  267.     checker.set_dtype(0, dtype::BFloat16());

  268.     checker.set_dtype(1, dtype::BFloat16());

  269.     checker.set_dtype(2, dtype::BFloat16());

  270.     BUILD_TERNARY_COMPLATE_TEST_CASE

  271. 

  272. #undef TERNARY_COMPLATE_TEST_CASE

  273. #undef BUILD_TERNARY_COMPLATE_TEST_CASE

  274. }

  275. 

  276. //! the memory of this test case is too large, sometimes will fail on tx1

  277. TEST_F(CUDA, ELEMWISE_BENCHMARK_DENSE) {

  278.     constexpr size_t A = 256 * 1024 * 64,

  279.               S0 = 16, S1 = 256, S2 = 64, S3 = 64;

  280.     static_assert(A == S0 * S1 * S2 * S3, "bad value");

  281.     SyncedTensor<>

  282.         t0(handle_cuda(), {TensorShape{S0, S1, S2, S3}, dtype::Float32()}),

  283.         t1(handle_cuda(), {TensorShape{S0, S1, S2, S3}, dtype::Float32()});

  284.     UniformFloatRNG rng{-2.f, 2.f};

  285.     rng.gen(t0.tensornd_host());

  286.     run_tensor_add(handle_cuda(),

  287.             t0.tensornd_dev(), t0.tensornd_dev(), t1.tensornd_dev());

  288.     auto p0 = t0.ptr_host(), p1 = t1.ptr_host();

  289.     for (size_t i = 0; i < A; ++ i) {

  290.         ASSERT_EQ(p0[i] + p0[i], p1[i]) << "at index " << i << "/" << A;

  291.     }

  292. }

  293. 

  294. #if MEGDNN_WITH_BENCHMARK

  295. TEST_F(CUDA, ELEMWISE_BENCHMARK_BCAST_101) {

  296.     constexpr size_t A = 511, B = 509, C0 = 23, C1 = 23, C = C0 * C1;

  297.     SyncedTensor<>

  298.         t0(handle_cuda(), {TensorShape{A, B, C0, C1}, dtype::Float32()}),

  299.         t1(handle_cuda(), {TensorShape{1, B, 1, 1}, dtype::Float32()}),

  300.         t2(handle_cuda(), {TensorShape{A, B, C0, C1}, dtype::Float32()});

  301.     UniformFloatRNG rng{-2.f, 2.f};

  302.     rng.gen(t0.tensornd_host());

  303.     rng.gen(t1.tensornd_host());

  304.     run_tensor_add(handle_cuda(),

  305.             t0.tensornd_dev(), t1.tensornd_dev(), t2.tensornd_dev());

  306.     auto p0 = t0.ptr_host(), p1 = t1.ptr_host(), p2 = t2.ptr_host();

  307.     for (size_t i = 0; i < A; ++ i) {

  308.         for (size_t j = 0; j < B; ++ j) {

  309.             for (size_t k = 0; k < C; ++ k) {

  310.                 auto off = i * B * C + j * C + k;

  311.                 ASSERT_EQ(p0[off] + p1[j], p2[off]);

  312.             }

  313.         }

  314.     }

  315. }

  316. 

  317. TEST_F(CUDA, ELEMWISE_BENCHMARK_BCAST_10) {

  318.     constexpr size_t A = 11583, B = 11587;

  319.     SyncedTensor<> t0(handle_cuda(), {TensorShape{A, B}, dtype::Float32()}),

  320.                    t1(handle_cuda(), {TensorShape{1, B}, dtype::Float32()}),

  321.                    t2(handle_cuda(), {TensorShape{A, B}, dtype::Float32()});

  322.     UniformFloatRNG rng{-2.f, 2.f};

  323.     rng.gen(t0.tensornd_host());

  324.     rng.gen(t1.tensornd_host());

  325.     run_tensor_add(handle_cuda(),

  326.             t0.tensornd_dev(), t1.tensornd_dev(), t2.tensornd_dev());

  327.     auto p0 = t0.ptr_host(), p1 = t1.ptr_host(), p2 = t2.ptr_host();

  328.     for (size_t i = 0; i < A; ++ i) {

  329.         for (size_t j = 0; j < B; ++ j) {

  330.             auto off = i * B + j;

  331.             ASSERT_EQ(p0[off] + p1[j], p2[off]);

  332.         }

  333.     }

  334. }

  335. 

  336. TEST_F(CUDA, ELEMWISE_BENCHMARK_BCAST_01) {

  337.     constexpr size_t A = 11583, B = 11587;

  338.     SyncedTensor<> t0(handle_cuda(), {TensorShape{1, A, B}, dtype::Float32()}),

  339.                    t1(handle_cuda(), {TensorShape{1, A, 1}, dtype::Float32()}),

  340.                    t2(handle_cuda(), {TensorShape{1, A, B}, dtype::Float32()});

  341.     UniformFloatRNG rng{-2.f, 2.f};

  342.     rng.gen(t0.tensornd_host());

  343.     rng.gen(t1.tensornd_host());

  344.     run_tensor_add(handle_cuda(),

  345.             t0.tensornd_dev(), t1.tensornd_dev(), t2.tensornd_dev());

  346.     auto p0 = t0.ptr_host(), p1 = t1.ptr_host(), p2 = t2.ptr_host();

  347.     for (size_t i = 0; i < A; ++ i) {

  348.         for (size_t j = 0; j < B; ++ j) {

  349.             auto off = i * B + j;

  350.             ASSERT_EQ(p0[off] + p1[i], p2[off]);

  351.         }

  352.     }

  353. }

  354. 

  355. TEST_F(CUDA, BENCHMARK_ELEMWISE_IBYTE) {

  356.     Benchmarker<ElemwiseForward> bencher(handle_cuda());

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

  358.     auto run_bench = [&](size_t N, size_t C, size_t H, size_t W) {

  359.         size_t nr_times = 100;

  360.         bencher.set_times(nr_times)

  361.                 .set_param(Mode::FUSE_ADD_RELU)

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

  363.                 .set_dtype(1, dtype::Int8());

  364.         auto time = bencher.execs({{N * C * H * W + 1}, {N * C * H * W + 1}, {}}) /

  365.                     nr_times;

  366.         printf("time = %.2fms, bandwidth = %.2fGB/s\n", time,

  367.                (3.0 * (N * C * H * W + 1)) / (time * 1e6));

  368.         time = bencher.execs({{N, C / 4, H, W, 4}, {N, C / 4, H, W, 4}, {}}) /

  369.                nr_times;

  370.         printf("time = %.2fms, bandwidth = %.2fGB/s\n", time,

  371.                (3.0 * N * C * H * W) / (time * 1e6));

  372.         time = bencher.execs({{N, C / 4, H, W, 4}, {1, C / 4, 1, 1, 4}, {}}) /

  373.                nr_times;

  374.         printf("time = %.2fms, bandwidth = %.2fGB/s\n", time,

  375.                (C + 2.0 * N * C * H * W) / (time * 1e6));

  376.         time = bencher.execs({{N, C / 4, H, W, 4}, {1}, {}}) / nr_times;

  377.         printf("time = %.2fms, bandwidth = %.2fGB/s\n", time,

  378.                (2.0 * N * C * H * W + 1) / (time * 1e6));

  379.         time = bencher.execs(

  380.                        {{N, C / 32, H, W, 32}, {N, C / 32, H, W, 32}, {}}) /

  381.                nr_times;

  382.         printf("time = %.2fms, bandwidth = %.2fGB/s\n", time,

  383.                (3.0 * N * C * H * W) / (time * 1e6));

  384.         time = bencher.execs(

  385.                        {{N, C / 32, H, W, 32}, {1, C / 32, 1, 1, 32}, {}}) /

  386.                nr_times;

  387.         printf("time = %.2fms, bandwidth = %.2fGB/s\n", time,

  388.                (C + 2.0 * N * C * H * W) / (time * 1e6));

  389.         bencher.set_dtype(0, dtype::Float32()).set_dtype(1, dtype::Float32());

  390.         time = bencher.execs({{N, C / 4, H, W}, {N, C / 4, H, W}, {}}) /

  391.                nr_times;

  392.         printf("time = %.2fms, bandwidth = %.2fGB/s\n", time,

  393.                (3.0 * N * C * H * W) / (time * 1e6));

  394.         time = bencher.execs({{N, C / 4, H, W}, {1, C / 4, 1, 1}, {}}) /

  395.                nr_times;

  396.         printf("time = %.2fms, bandwidth = %.2fGB/s\n", time,

  397.                (C + 2.0 * N * C * H * W) / (time * 1e6));

  398. 

  399.     };

  400.     run_bench(256, 256, 56, 56);

  401. }

  402. 

  403. TEST_F(CUDA, BENCHMARK_ELEMWISE_MIN_MAX) {

  404.     Benchmarker<ElemwiseForward> bencher(handle_cuda());

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

  406.     UniformIntRNG const_1{1, 1}, rng{-128, 127};

  407.     auto run_bench = [&](size_t N, size_t C, size_t H, size_t W, DType dtype) {

  408.         size_t nr_times = 1000;

  409.         bencher.set_times(nr_times)

  410.                 .set_param(Mode::MIN)

  411.                 .set_rng(0, &rng)

  412.                 .set_rng(1, &rng)

  413.                 .set_dtype(0, dtype)

  414.                 .set_dtype(1, dtype);

  415.         auto time =

  416.                 bencher.execs({{N, C / 4, H, W, 4}, {N, C / 4, H, W, 4}, {}}) /

  417.                 nr_times;

  418.         printf("time = %.2fms, bandwidth = %.2fGB/s\n", time,

  419.                (3.0 * N * C * H * W) / (time * 1e6));

  420.         bencher.set_param(Mode::MAX).set_rng(0, &const_1).set_rng(1, &const_1);

  421.         time = bencher.execs({{N, C / 4, H, W, 4}, {N, C / 4, H, W, 4}, {}}) /

  422.                nr_times;

  423.         printf("time = %.2fms, bandwidth = %.2fGB/s\n", time,

  424.                (3.0 * N * C * H * W) / (time * 1e6));

  425.     };

  426.     run_bench(256, 256, 56, 56, dtype::Int8());

  427. }

  428. #endif

  429. 

  430. // vim: syntax=cpp.doxygen