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

486 lines
22 kB
Raw Blame History 

  1. /**

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

  13. #include "megdnn/oprs/nn.h"

  14. 

  15. #include "src/common/utils.h"

  16. #include "src/cuda/cudnn_with_check.h"

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

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

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

  20. #include "test/common/workspace_wrapper.h"

  21. #include "test/cuda/benchmark.h"

  22. #include "test/cuda/conv_test_utils.h"

  23. #include "test/cuda/fixture.h"

  24. #include "test/cuda/utils.h"

  25. 

  26. #define V1(x) #x

  27. #define V(x)  V1(x)

  28. 

  29. namespace megdnn {

  30. namespace test {

  31. namespace conv {

  32. 

  33. #if MEGDNN_WITH_BENCHMARK

  34. 

  35. std::vector<BenchArgs> get_resnet50_bench_args(size_t batch) {

  36.     std::vector<BenchArgs> args;

  37.     args.emplace_back(BenchArgs{batch, 64, 56, 56, 256, 1, 1});

  38.     args.emplace_back(BenchArgs{batch, 256, 56, 56, 32, 3, 1});

  39.     args.emplace_back(BenchArgs{batch, 256, 56, 56, 32, 3, 2});

  40.     args.emplace_back(BenchArgs{batch, 4, 256, 256, 32, 7, 2});

  41. 

  42.     args.emplace_back(BenchArgs{batch, 256, 56, 56, 64, 1, 1});

  43.     args.emplace_back(BenchArgs{batch, 64, 56, 56, 64, 1, 1});

  44.     args.emplace_back(BenchArgs{batch, 64, 56, 56, 64, 3, 1});

  45.     args.emplace_back(BenchArgs{batch, 64, 56, 56, 64, 3, 2});

  46.     args.emplace_back(BenchArgs{batch, 256, 56, 56, 64, 3, 2});

  47. 

  48.     args.emplace_back(BenchArgs{batch, 256, 56, 56, 512, 1, 2});

  49.     args.emplace_back(BenchArgs{batch, 256, 56, 56, 128, 1, 2});

  50.     args.emplace_back(BenchArgs{batch, 512, 28, 28, 128, 1, 1});

  51.     args.emplace_back(BenchArgs{batch, 128, 28, 28, 128, 3, 1});

  52.     args.emplace_back(BenchArgs{batch, 128, 28, 28, 512, 1, 1});

  53. 

  54.     args.emplace_back(BenchArgs{batch, 512, 28, 28, 1024, 1, 2});

  55.     args.emplace_back(BenchArgs{batch, 512, 28, 28, 256, 1, 2});

  56.     args.emplace_back(BenchArgs{batch, 1024, 14, 14, 256, 1, 1});

  57.     args.emplace_back(BenchArgs{batch, 256, 14, 14, 256, 3, 1});

  58.     args.emplace_back(BenchArgs{batch, 256, 14, 14, 1024, 1, 1});

  59.     args.emplace_back(BenchArgs{batch, 256, 14, 14, 1024, 1, 2});

  60. 

  61.     args.emplace_back(BenchArgs{batch, 1024, 14, 14, 2048, 1, 2});

  62.     args.emplace_back(BenchArgs{batch, 1024, 14, 14, 512, 1, 2});

  63.     args.emplace_back(BenchArgs{batch, 2048, 7, 7, 512, 1, 1});

  64.     args.emplace_back(BenchArgs{batch, 512, 7, 7, 512, 3, 1});

  65.     args.emplace_back(BenchArgs{batch, 512, 7, 7, 2048, 1, 1});

  66.     return args;

  67. }

  68. 

  69. std::vector<BenchArgs> get_detection_bench_args(size_t batch) {

  70.     std::vector<BenchArgs> args;

  71.     args.emplace_back(BenchArgs{batch, 4, 736, 1280, 8, 3, 2});

  72.     args.emplace_back(BenchArgs{batch, 32, 184, 320, 16, 3, 1});

  73.     args.emplace_back(BenchArgs{batch, 16, 184, 320, 32, 3, 1});

  74.     args.emplace_back(BenchArgs{batch, 8, 184, 320, 16, 3, 1});

  75.     args.emplace_back(BenchArgs{batch, 8, 184, 320, 32, 3, 1});

  76.     args.emplace_back(BenchArgs{batch, 64, 92, 160, 32, 3, 1});

  77.     args.emplace_back(BenchArgs{batch, 32, 184, 320, 64, 3, 2});

  78.     args.emplace_back(BenchArgs{batch, 32, 184, 320, 32, 3, 2});

  79.     args.emplace_back(BenchArgs{batch, 32, 92, 160, 64, 3, 1});

  80.     args.emplace_back(BenchArgs{batch, 64, 92, 160, 8, 3, 1});

  81.     args.emplace_back(BenchArgs{batch, 64, 92, 160, 128, 3, 2});

  82.     args.emplace_back(BenchArgs{batch, 128, 46, 80, 32, 3, 1});

  83.     args.emplace_back(BenchArgs{batch, 128, 46, 80, 256, 3, 2});

  84.     args.emplace_back(BenchArgs{batch, 128, 46, 80, 8, 3, 1});

  85.     args.emplace_back(BenchArgs{batch, 64, 92, 160, 32, 3, 2});

  86.     args.emplace_back(BenchArgs{batch, 32, 46, 80, 128, 3, 1});

  87.     args.emplace_back(BenchArgs{batch, 8, 46, 80, 32, 3, 1});

  88.     args.emplace_back(BenchArgs{batch, 64, 23, 40, 256, 3, 1});

  89.     args.emplace_back(BenchArgs{batch, 256, 23, 40, 64, 3, 1});

  90.     args.emplace_back(BenchArgs{batch, 128, 46, 80, 64, 3, 2});

  91.     args.emplace_back(BenchArgs{batch, 256, 23, 40, 8, 3, 1});

  92.     args.emplace_back(BenchArgs{batch, 8, 23, 40, 32, 3, 2});

  93.     args.emplace_back(BenchArgs{batch, 8, 12, 20, 8, 3, 1});

  94.     args.emplace_back(BenchArgs{batch, 8, 12, 20, 8, 3, 2});

  95.     args.emplace_back(BenchArgs{batch, 8, 6, 10, 8, 3, 1});

  96.     return args;

  97. }

  98. 

  99. std::vector<BenchArgs> get_det_first_bench_args(size_t batch) {

  100.     std::vector<BenchArgs> args;

  101.     args.emplace_back(BenchArgs{batch, 4, 736, 1280, 16, 3, 2});

  102.     args.emplace_back(BenchArgs{batch, 16, 384, 640, 16, 3, 1});

  103.     args.emplace_back(BenchArgs{batch, 16, 384, 640, 32, 3, 2});

  104.     args.emplace_back(BenchArgs{batch, 32, 184, 320, 32, 3, 1});

  105.     args.emplace_back(BenchArgs{batch, 32, 184, 320, 32, 1, 1});

  106.     return args;

  107. }

  108. 

  109. void benchmark_target_algo(

  110.         Handle* handle, const std::vector<BenchArgs>& args, DType src_dtype,

  111.         DType filter_dtype, DType bias_dtype, DType dst_dtype, const char* algo,

  112.         param::ConvBias::Format format) {

  113.     megdnn_assert(src_dtype.enumv() == filter_dtype.enumv());

  114.     CUBenchmarker<ConvBiasForward> benchmarker(handle);

  115.     CUBenchmarker<ConvBiasForward> benchmarker_cudnn(handle);

  116.     size_t RUNS = 1000;

  117.     benchmarker.set_display(false).set_times(RUNS);

  118.     benchmarker_cudnn.set_display(false).set_times(RUNS);

  119. 

  120. #define CUDNN_VERSION_STRING \

  121.     "v" V(CUDNN_MAJOR) "." V(CUDNN_MINOR) "." V(CUDNN_PATCHLEVEL)

  122.     benchmarker_cudnn.set_before_exec_callback(

  123.             conv_bias::ConvBiasAlgoChecker<ConvBiasForward>(

  124.                     "DEFAULT:CUDNN:ConvBiasActivation:CUDNN_CONVOLUTION_FWD_"

  125.                     "ALGO_IMPLICIT_PRECOMP_"

  126.                     "GEMM" CUDNN_VERSION_STRING));

  127. 

  128.     benchmarker.set_dtype(0, src_dtype)

  129.             .set_dtype(1, filter_dtype)

  130.             .set_dtype(2, bias_dtype)

  131.             .set_dtype(3, dst_dtype)

  132.             .set_dtype(4, dst_dtype);

  133.     benchmarker_cudnn.set_dtype(0, src_dtype)

  134.             .set_dtype(1, filter_dtype)

  135.             .set_dtype(2, bias_dtype)

  136.             .set_dtype(3, dst_dtype)

  137.             .set_dtype(4, dst_dtype);

  138. 

  139.     using Param = ConvBias::Param;

  140.     using Format = Param::Format;

  141.     // helper function to change format

  142.     auto get_tensor_shape = [](TensorShape shape, Format format) -> TensorShape {

  143.         TensorShape ret;

  144.         if (format == Format::NCHW4) {

  145.             ret = static_cast<TensorShape>(

  146.                     TensorLayout{shape, dtype::Int8()}

  147.                             .reshape({shape[0], shape[1] / 4, 4, shape[2], shape[3]})

  148.                             .dimshuffle({0, 1, 3, 4, 2}));

  149.         } else if (format == Format::CHWN4) {

  150.             ret = static_cast<TensorShape>(

  151.                     TensorLayout{shape, dtype::Int8()}

  152.                             .reshape({shape[0], shape[1] / 4, 4, shape[2], shape[3]})

  153.                             .dimshuffle({1, 3, 4, 0, 2}));

  154.         }

  155.         return ret;

  156.     };

  157. 

  158.     for (auto&& arg : args) {

  159.         Param param;

  160.         param.pad_h = param.pad_w = arg.f / 2;

  161.         param.stride_h = param.stride_w = arg.s;

  162.         param.format = format;

  163. 

  164.         size_t ho = infer_conv_shape(arg.hi, arg.f, arg.s, arg.f / 2);

  165.         size_t wo = infer_conv_shape(arg.wi, arg.f, arg.s, arg.f / 2);

  166. 

  167.         benchmarker.set_param(param);

  168.         if (!algo) {

  169.             benchmarker.proxy()->target_execution_policy.algo.reset();

  170.         }

  171.         TensorShape src{arg.n, arg.ci, arg.hi, arg.wi},

  172.                 filter{arg.co, arg.ci, arg.f, arg.f}, bias{1, arg.co, 1, 1},

  173.                 z{arg.n, arg.co, ho, wo}, dst = z;

  174.         float time_in_ms = 0.f;

  175.         if (algo) {

  176.             time_in_ms =

  177.                     algo_benchmark<ConvBiasForward, OprProxy<ConvBiasForward>, CUTimer>(

  178.                             benchmarker,

  179.                             {get_tensor_shape(src, format),

  180.                              get_tensor_shape(filter, format),

  181.                              get_tensor_shape(bias, format),

  182.                              {},

  183.                              {}},

  184.                             algo) /

  185.                     RUNS;

  186.         } else {

  187.             time_in_ms = benchmarker.execs(

  188.                                  {get_tensor_shape(src, format),

  189.                                   get_tensor_shape(filter, format),

  190.                                   get_tensor_shape(bias, format),

  191.                                   {},

  192.                                   {}}) /

  193.                          RUNS;

  194.         }

  195.         Format format_cudnn = Format::NCHW4;

  196.         param.format = format_cudnn;

  197.         benchmarker_cudnn.set_param(param);

  198.         auto time_in_ms_cudnn = benchmarker_cudnn.execs(

  199.                                         {get_tensor_shape(src, format_cudnn),

  200.                                          get_tensor_shape(filter, format_cudnn),

  201.                                          get_tensor_shape(bias, format_cudnn),

  202.                                          {},

  203.                                          {}}) /

  204.                                 RUNS;

  205.         float flo = 2.0 * arg.n * arg.co * ho * wo * arg.ci * arg.f * arg.f / (1e12);

  206.         printf("src=%s, filter=%s, dst=%s, time(algo=%s)=%.2f %.2fTops, "

  207.                "time(cudnn)=%.2f %.2fTops, "

  208.                "perf(algo=%s)/perf(cudnn)=%.2f\n",

  209.                src.to_string().c_str(), filter.to_string().c_str(),

  210.                dst.to_string().c_str(), algo, time_in_ms, (flo / (time_in_ms * 1e-3)),

  211.                time_in_ms_cudnn, (flo / (time_in_ms_cudnn * 1e-3)), algo,

  212.                time_in_ms_cudnn / time_in_ms);

  213.         printf("bench with z tensor\n");

  214.         if (algo) {

  215.             time_in_ms =

  216.                     algo_benchmark<ConvBiasForward, OprProxy<ConvBiasForward>, CUTimer>(

  217.                             benchmarker,

  218.                             {get_tensor_shape(src, format),

  219.                              get_tensor_shape(filter, format),

  220.                              get_tensor_shape(bias, format),

  221.                              get_tensor_shape(z, format),

  222.                              {}},

  223.                             algo) /

  224.                     RUNS;

  225.         } else {

  226.             time_in_ms = benchmarker.execs(

  227.                                  {get_tensor_shape(src, format),

  228.                                   get_tensor_shape(filter, format),

  229.                                   get_tensor_shape(bias, format),

  230.                                   get_tensor_shape(z, format),

  231.                                   {}}) /

  232.                          RUNS;

  233.         }

  234.         time_in_ms_cudnn = benchmarker_cudnn.execs(

  235.                                    {get_tensor_shape(src, format_cudnn),

  236.                                     get_tensor_shape(filter, format_cudnn),

  237.                                     get_tensor_shape(bias, format_cudnn),

  238.                                     get_tensor_shape(z, format_cudnn),

  239.                                     {}}) /

  240.                            RUNS;

  241.         printf("src=%s, filter=%s, dst=%s, time(algo=%s)=%.2f %.2fTops, "

  242.                "time(cudnn)=%.2f %.2fTops, "

  243.                "perf(algo=%s)/perf(cudnn)=%.2f\n",

  244.                src.to_string().c_str(), filter.to_string().c_str(),

  245.                dst.to_string().c_str(), algo, time_in_ms, (flo / (time_in_ms * 1e-3)),

  246.                time_in_ms_cudnn, (flo / (time_in_ms_cudnn * 1e-3)), algo,

  247.                time_in_ms_cudnn / time_in_ms);

  248.     }

  249. }

  250. 

  251. void benchmark_target_algo_with_cudnn_tsc(

  252.         Handle* handle, const std::vector<BenchArgs>& args, DType src_dtype,

  253.         DType filter_dtype, DType bias_dtype, DType dst_dtype, const char* algo,

  254.         param::ConvBias::Format format, bool with_cudnn, const char* change_cudnn_algo,

  255.         param::ConvBias::Format change_cudnn_format, DType change_cudnn_src_dtype,

  256.         DType change_cudnn_filter_dtype, DType change_cudnn_bias_dtype,

  257.         DType change_cudnn_dst_dtype) {

  258.     megdnn_assert(

  259.             (src_dtype.enumv() == filter_dtype.enumv()) ||

  260.             (src_dtype.enumv() == DTypeEnum::Quantized4Asymm &&

  261.              filter_dtype.enumv() == DTypeEnum::QuantizedS4));

  262.     CUBenchmarker<ConvBiasForward> benchmarker(handle);

  263.     CUBenchmarker<ConvBiasForward> benchmarker_cudnn(handle);

  264.     size_t RUNS = 200;

  265.     benchmarker.set_display(false).set_times(RUNS);

  266.     benchmarker.set_dtype(0, src_dtype)

  267.             .set_dtype(1, filter_dtype)

  268.             .set_dtype(2, bias_dtype)

  269.             .set_dtype(3, dst_dtype)

  270.             .set_dtype(4, dst_dtype);

  271. 

  272.     benchmarker_cudnn.set_display(false).set_times(RUNS);

  273. 

  274.     std::unique_ptr<OprProxy<ConvBiasForward>> proxy{

  275.             new OprProxy<ConvBiasForward>{true}};

  276. 

  277.     if (!algo) {

  278.         benchmarker.set_proxy(proxy);

  279.     }

  280.     if (change_cudnn_algo) {

  281.         benchmarker_cudnn.set_dtype(0, change_cudnn_src_dtype)

  282.                 .set_dtype(1, change_cudnn_filter_dtype)

  283.                 .set_dtype(2, change_cudnn_bias_dtype)

  284.                 .set_dtype(3, change_cudnn_dst_dtype)

  285.                 .set_dtype(4, change_cudnn_dst_dtype);

  286.     } else {

  287.         benchmarker_cudnn.set_dtype(0, src_dtype)

  288.                 .set_dtype(1, filter_dtype)

  289.                 .set_dtype(2, bias_dtype)

  290.                 .set_dtype(3, dst_dtype)

  291.                 .set_dtype(4, dst_dtype);

  292.         benchmarker_cudnn.set_before_exec_callback(

  293.                 conv_bias::ConvBiasAlgoChecker<ConvBiasForward>(

  294.                         "DEFAULT:CUDNN:ConvBiasActivation:CUDNN_CONVOLUTION_"

  295.                         "FWD_"

  296.                         "ALGO_IMPLICIT_PRECOMP_GEMM" CUDNN_VERSION_STRING));

  297.     }

  298. #undef CUDNN_VERSION_STRING

  299. 

  300.     using Param = ConvBias::Param;

  301.     using Format = Param::Format;

  302.     // helper function to change format

  303.     auto get_tensor_shape = [](TensorShape shape, DType dtype,

  304.                                Format format) -> TensorShape {

  305.         TensorShape ret;

  306.         if (format == Format::NCHW4) {

  307.             ret = static_cast<TensorShape>(

  308.                     TensorLayout{shape, dtype}

  309.                             .reshape({shape[0], shape[1] / 4, 4, shape[2], shape[3]})

  310.                             .dimshuffle({0, 1, 3, 4, 2}));

  311.         } else if (format == Format::NCHW32) {

  312.             ret = static_cast<TensorShape>(

  313.                     TensorLayout{shape, dtype}

  314.                             .reshape({shape[0], shape[1] / 32, 32, shape[2], shape[3]})

  315.                             .dimshuffle({0, 1, 3, 4, 2}));

  316.         } else if (format == Format::NCHW64) {

  317.             ret = static_cast<TensorShape>(

  318.                     TensorLayout{shape, dtype}

  319.                             .reshape({shape[0], shape[1] / 64, 64, shape[2], shape[3]})

  320.                             .dimshuffle({0, 1, 3, 4, 2}));

  321.         } else if (format == Format::CHWN4) {

  322.             ret = static_cast<TensorShape>(

  323.                     TensorLayout{shape, dtype}

  324.                             .reshape({shape[0], shape[1] / 4, 4, shape[2], shape[3]})

  325.                             .dimshuffle({1, 3, 4, 0, 2}));

  326.         } else if (format == Format::NHWC) {

  327.             ret = static_cast<TensorShape>(

  328.                     TensorLayout{shape, dtype}.dimshuffle({0, 2, 3, 1}));

  329.         }

  330.         return ret;

  331.     };

  332. 

  333.     for (auto&& arg : args) {

  334.         Param param;

  335.         param.pad_h = param.pad_w = arg.f / 2;

  336.         param.stride_h = param.stride_w = arg.s;

  337.         param.format = format;

  338. 

  339.         size_t ho = infer_conv_shape(arg.hi, arg.f, arg.s, arg.f / 2);

  340.         size_t wo = infer_conv_shape(arg.wi, arg.f, arg.s, arg.f / 2);

  341. 

  342.         benchmarker.set_param(param);

  343.         if (!algo) {

  344.             benchmarker.proxy()->target_execution_policy.algo.reset();

  345.         }

  346.         TensorShape src{arg.n, arg.ci, arg.hi, arg.wi},

  347.                 filter{arg.co, arg.ci, arg.f, arg.f}, bias{1, arg.co, 1, 1},

  348.                 z{arg.n, arg.co, ho, wo}, dst = z;

  349.         // skip testcase which cannot enable nchw32 tensorcore

  350.         if (format == Format::NCHW32 && (arg.co % 32 != 0 || arg.ci % 32 != 0))

  351.             continue;

  352.         // skip testcase which cannot enable nchw32 tensorcore

  353.         if (format == Format::NCHW64 && (arg.co % 64 != 0 || arg.ci % 64 != 0))

  354.             continue;

  355.         // skip testcase which cannot enable nchw4/chwn4 tensorcore

  356.         if ((format == Format::CHWN4 || format == Format::NCHW4) && (arg.ci % 16 != 0))

  357.             continue;

  358.         // skip testcase which cannot enable nhwc tensorcore

  359.         if ((format == Format::NHWC) && (arg.ci % 4 != 0 || arg.co % 4 != 0))

  360.             continue;

  361.         Format format_cudnn =

  362.                 arg.ci % 32 == 0 && arg.co % 32 == 0 ? Format::NCHW32 : Format::NCHW4;

  363.         if (change_cudnn_algo) {

  364.             format_cudnn = change_cudnn_format;

  365.         }

  366. 

  367.         param.format = format_cudnn;

  368.         benchmarker_cudnn.set_param(param);

  369. 

  370.         float time_in_ms = 0.f;

  371.         if (algo) {

  372.             time_in_ms =

  373.                     algo_benchmark<ConvBiasForward, OprProxy<ConvBiasForward>, CUTimer>(

  374.                             benchmarker,

  375.                             {get_tensor_shape(src, src_dtype, format),

  376.                              get_tensor_shape(filter, filter_dtype, format),

  377.                              get_tensor_shape(bias, bias_dtype, format),

  378.                              {},

  379.                              {}},

  380.                             algo) /

  381.                     RUNS;

  382.         } else {

  383.             time_in_ms = benchmarker.execs(

  384.                                  {get_tensor_shape(src, src_dtype, format),

  385.                                   get_tensor_shape(filter, filter_dtype, format),

  386.                                   get_tensor_shape(bias, bias_dtype, format),

  387.                                   {},

  388.                                   {}}) /

  389.                          RUNS;

  390.         }

  391.         float time_in_ms_cudnn = 0;

  392.         if (with_cudnn) {

  393.             if (change_cudnn_algo) {

  394.                 time_in_ms_cudnn =

  395.                         algo_benchmark<

  396.                                 ConvBiasForward, OprProxy<ConvBiasForward>, CUTimer>(

  397.                                 benchmarker_cudnn,

  398.                                 {get_tensor_shape(src, src_dtype, format_cudnn),

  399.                                  get_tensor_shape(filter, filter_dtype, format_cudnn),

  400.                                  get_tensor_shape(bias, bias_dtype, format_cudnn),

  401.                                  {},

  402.                                  {}},

  403.                                 change_cudnn_algo) /

  404.                         RUNS;

  405.             } else {

  406.                 time_in_ms_cudnn =

  407.                         benchmarker_cudnn.execs(

  408.                                 {get_tensor_shape(src, src_dtype, format_cudnn),

  409.                                  get_tensor_shape(filter, filter_dtype, format_cudnn),

  410.                                  get_tensor_shape(bias, bias_dtype, format_cudnn),

  411.                                  {},

  412.                                  {}}) /

  413.                         RUNS;

  414.             }

  415.         }

  416. 

  417.         float flo = 2.0 * arg.n * arg.co * ho * wo * arg.ci * arg.f * arg.f / (1e12);

  418.         printf("src=%s, filter=%s, dst=%s, time(algo=%s)=%.2f %.2fTops, "

  419.                "time(cudnn)=%.2f %.2fTops, "

  420.                "perf(algo=%s)/perf(cudnn)=%.2f\n",

  421.                src.to_string().c_str(), filter.to_string().c_str(),

  422.                dst.to_string().c_str(), algo, time_in_ms, (flo / (time_in_ms * 1e-3)),

  423.                time_in_ms_cudnn, (flo / (time_in_ms_cudnn * 1e-3)), algo,

  424.                time_in_ms_cudnn / time_in_ms);

  425.         printf("bench with z tensor\n");

  426.         if (algo) {

  427.             time_in_ms =

  428.                     algo_benchmark<ConvBiasForward, OprProxy<ConvBiasForward>, CUTimer>(

  429.                             benchmarker,

  430.                             {get_tensor_shape(src, src_dtype, format),

  431.                              get_tensor_shape(filter, filter_dtype, format),

  432.                              get_tensor_shape(bias, bias_dtype, format),

  433.                              get_tensor_shape(z, src_dtype, format),

  434.                              {}},

  435.                             algo) /

  436.                     RUNS;

  437.         } else {

  438.             time_in_ms = benchmarker.execs(

  439.                                  {get_tensor_shape(src, src_dtype, format),

  440.                                   get_tensor_shape(filter, filter_dtype, format),

  441.                                   get_tensor_shape(bias, bias_dtype, format),

  442.                                   get_tensor_shape(z, src_dtype, format),

  443.                                   {}}) /

  444.                          RUNS;

  445.         }

  446.         time_in_ms_cudnn = 0;

  447.         if (with_cudnn) {

  448.             if (change_cudnn_algo) {

  449.                 time_in_ms_cudnn =

  450.                         algo_benchmark<

  451.                                 ConvBiasForward, OprProxy<ConvBiasForward>, CUTimer>(

  452.                                 benchmarker_cudnn,

  453.                                 {get_tensor_shape(src, src_dtype, format_cudnn),

  454.                                  get_tensor_shape(filter, filter_dtype, format_cudnn),

  455.                                  get_tensor_shape(bias, bias_dtype, format_cudnn),

  456.                                  get_tensor_shape(z, src_dtype, format_cudnn),

  457.                                  {}},

  458.                                 change_cudnn_algo) /

  459.                         RUNS;

  460.             } else {

  461.                 time_in_ms_cudnn =

  462.                         benchmarker_cudnn.execs(

  463.                                 {get_tensor_shape(src, src_dtype, format_cudnn),

  464.                                  get_tensor_shape(filter, filter_dtype, format_cudnn),

  465.                                  get_tensor_shape(bias, bias_dtype, format_cudnn),

  466.                                  get_tensor_shape(z, src_dtype, format_cudnn),

  467.                                  {}}) /

  468.                         RUNS;

  469.             }

  470.         }

  471.         printf("src=%s, filter=%s, dst=%s, time(algo=%s)=%.2f %.2fTops, "

  472.                "time(cudnn)=%.2f %.2fTops, "

  473.                "perf(algo=%s)/perf(cudnn)=%.2f\n",

  474.                src.to_string().c_str(), filter.to_string().c_str(),

  475.                dst.to_string().c_str(), algo, time_in_ms, (flo / (time_in_ms * 1e-3)),

  476.                time_in_ms_cudnn, (flo / (time_in_ms_cudnn * 1e-3)), algo,

  477.                time_in_ms_cudnn / time_in_ms);

  478.     }

  479. }

  480. #endif

  481. }  // namespace conv

  482. }  // namespace test

  483. }  // namespace megdnn

  484. #undef V1

  485. #undef V