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

388 lines
17 kB
Raw Blame History 

  1. #include "src/cuda/conv_bias/algo.h"

  2. #include "src/cuda/utils.h"

  3. 

  4. using namespace megdnn;

  5. using namespace cuda;

  6. 

  7. ConvBiasForwardImpl::AlgoPack::AlgoPack() {

  8.     non_cudnn_algos.push_back(&chanwise);

  9.     non_cudnn_algos.push_back(&chanwise_small);

  10.     non_cudnn_algos.push_back(&depthwise_large_filter);

  11. 

  12.     non_cudnn_algos.push_back(&inplace_matmul);

  13.     non_cudnn_algos.push_back(&matmul);

  14.     non_cudnn_algos.push_back(&matmul8x8x32);

  15.     non_cudnn_algos.push_back(&batched_matmul);

  16.     non_cudnn_algos.push_back(&int1_simple);

  17. 

  18. #if CUDNN_VERSION >= 8020

  19.     all_algos.push_back(&cudnn_conv_v8);

  20.     all_algos.push_back(&cudnn_conv_bias_activation_v8);

  21. #endif

  22. 

  23.     fill_cudnn_algos();

  24.     for (auto&& algo : cudnn_conv_bias_activations) {

  25.         all_algos.push_back(&algo);

  26.     }

  27. 

  28.     //! add conv+nonlinear algos

  29.     std::vector<AlgoBase*> conv_algos;

  30.     conv_algos.push_back(&chanwise);

  31.     conv_algos.push_back(&chanwise_small);

  32.     conv_algos.push_back(&depthwise_large_filter);

  33.     conv_algos.push_back(&chanwise8x8x32);

  34.     for (auto&& algo : cudnn_convs) {

  35.         conv_algos.push_back(&algo);

  36.     }

  37.     conv_algos.push_back(&inplace_matmul);

  38.     conv_algos.push_back(&matmul);

  39.     conv_algos.push_back(&matmul8x8x32);

  40.     conv_algos.push_back(&batched_matmul);

  41.     conv_algos.push_back(&group);

  42.     conv_algos.push_back(&int1_simple);

  43. 

  44.     for (auto&& algo : conv_algos) {

  45.         all_algos.push_back(algo);

  46.     }

  47. 

  48.     all_algos.push_back(&bfloat16);

  49.     bfloat16_algos.push_back(&bfloat16);

  50. 

  51.     size_t all_algo_size = all_algos.size();

  52. #if CUDA_VERSION >= 10000

  53.     fill_imma_algos();

  54.     all_algos.push_back(&wmma_quint4x4x32);

  55.     for (auto&& algo : int8_nchw4_imma) {

  56.         all_algos.push_back(&algo);

  57.     }

  58.     for (auto&& algo : int8_chwn4_imma) {

  59.         all_algos.push_back(&algo);

  60.     }

  61.     for (auto&& algo : int8_chwn4_imma_reorder_filter) {

  62.         all_algos.push_back(&algo);

  63.     }

  64.     for (auto&& algo : int8_chwn4_imma_unroll_width) {

  65.         all_algos.push_back(&algo);

  66.     }

  67. #if CUDA_VERSION >= 10020

  68.     for (auto&& algo : int8_nchw32_imma) {

  69.         all_algos.push_back(&algo);

  70.     }

  71.     for (auto&& algo : int8_nhwc_imma) {

  72.         all_algos.push_back(&algo);

  73.     }

  74.     for (auto&& algo : int4_int4_nchw64_imma) {

  75.         all_algos.push_back(&algo);

  76.     }

  77.     for (auto&& algo : uint4_int4_nchw64_imma) {

  78.         all_algos.push_back(&algo);

  79.     }

  80.     for (auto&& algo : int4_int4_nhwc_imma) {

  81.         all_algos.push_back(&algo);

  82.     }

  83.     for (auto&& algo : uint4_int4_nhwc_imma) {

  84.         all_algos.push_back(&algo);

  85.     }

  86. #endif

  87. #endif

  88.     fill_dp4a_algos();

  89.     for (auto&& algo : int8_nchw4_dotprod) {

  90.         all_algos.push_back(&algo);

  91.     }

  92.     fill_dwconv_algos();

  93.     all_algos.push_back(&int8_chwn4_dotprod);

  94.     all_algos.push_back(&fallback_nchw_qs8);

  95.     for (size_t i = all_algo_size; i < all_algos.size(); ++i) {

  96.         non_cudnn_algos.push_back(all_algos[i]);

  97.     }

  98. 

  99.     for (auto&& algo : all_algos) {

  100.         m_all_algos_map.emplace(algo->info().desc, algo);

  101.     }

  102. }

  103. 

  104. ConvBiasForwardImpl::AlgoPack ConvBiasForwardImpl::sm_algo_pack;

  105. 

  106. MEGDNN_DEF_GET_ALGO_FROM_DESC(ConvBiasForwardImpl)

  107. 

  108. ConvBiasForwardImpl::AlgoBase::SizeArgs::SizeArgs(

  109.         const ConvBiasForwardImpl* o, const TensorLayout& src,

  110.         const TensorLayout& filter, const TensorLayout& bias, const TensorLayout& z,

  111.         const TensorLayout& dst, const PreprocessedFilter* preprocessed_filter)

  112.         : SizeArgs(

  113.                   o, src, filter, o->make_canonized_filter_meta(src.ndim, filter), bias,

  114.                   z, dst, preprocessed_filter) {}

  115. 

  116. ConvBiasForwardImpl::AlgoBase::SizeArgs::SizeArgs(

  117.         const ConvBiasForwardImpl* o, const TensorLayout& src,

  118.         const TensorLayout& filter, const CanonizedFilterMeta& filter_meta,

  119.         const TensorLayout& bias, const TensorLayout& z, const TensorLayout& dst,

  120.         const PreprocessedFilter* preprocessed_filter)

  121.         : BiasForwardSizeArgs{concrete_handle(o->handle()),

  122.                               &src,

  123.                               &filter,

  124.                               &bias,

  125.                               &z,

  126.                               filter_meta,

  127.                               &dst,

  128.                               o->param().nonlineMode},

  129.           opr{o},

  130.           preprocessed_filter{preprocessed_filter} {}

  131. 

  132. ConvBiasForwardImpl::AlgoBase::ExecArgs::ExecArgs(

  133.         ConvBiasForwardImpl* opr, _megdnn_tensor_in src, _megdnn_tensor_in filter,

  134.         _megdnn_tensor_in bias, _megdnn_tensor_in z, _megdnn_tensor_out dst,

  135.         _megdnn_workspace workspace, const PreprocessedFilter* preprocessed_filter)

  136.         : SizeArgs(

  137.                   opr, src.layout, filter.layout, bias.layout, z.layout, dst.layout,

  138.                   preprocessed_filter),

  139.           src_tensor{&src},

  140.           filter_tensor{&filter},

  141.           bias_tensor{&bias},

  142.           z_tensor{&z},

  143.           dst_tensor{&dst},

  144.           workspace{workspace} {}

  145. 

  146. std::string ConvBiasForwardImpl::AlgoBase::SizeArgs::to_string() const {

  147.     auto&& fm = filter_meta;

  148.     MEGDNN_MARK_USED_VAR(fm);

  149.     std::string nonlinear_mode_str;

  150.     switch (nonlinear_mode) {

  151.         case param::ConvBias::NonlineMode::RELU:

  152.             nonlinear_mode_str = "RELU";

  153.             break;

  154.         case param::ConvBias::NonlineMode::SIGMOID:

  155.             nonlinear_mode_str = "SIGMOID";

  156.             break;

  157.         case param::ConvBias::NonlineMode::IDENTITY:

  158.             nonlinear_mode_str = "IDENTITY";

  159.             break;

  160.         case param::ConvBias::NonlineMode::H_SWISH:

  161.             nonlinear_mode_str = "H_SWISH";

  162.             break;

  163.         default:

  164.             megdnn_throw("invalid conv bias nonlinear mode");

  165.     }

  166.     return ssprintf(

  167.             "src=%s, filter=%s, bias=%s, z=%s, dst=%s, "

  168.             "pad=%ux%u, stride=%ux%u, dilate=%ux%u, xcorr=%d, dtype=%s,%s, "

  169.             "nonlinear_mode=%s",

  170.             src_layout->to_string().c_str(), filter_layout->to_string().c_str(),

  171.             bias_layout->to_string().c_str(), z_layout->to_string().c_str(),

  172.             dst_layout->to_string().c_str(), fm.padding[0], fm.padding[1], fm.stride[0],

  173.             fm.stride[1], fm.dilation[0], fm.dilation[1], !fm.should_flip,

  174.             src_layout->dtype.name(), dst_layout->dtype.name(),

  175.             nonlinear_mode_str.c_str());

  176. }

  177. 

  178. param::Convolution ConvBiasForwardImpl::AlgoBase::get_param_convolution(

  179.         const SizeArgs& args) const {

  180.     param::Convolution::Mode mode;

  181.     param::Convolution::Sparse sparse = args.filter_meta.group > 1

  182.                                               ? param::Convolution::Sparse::GROUP

  183.                                               : param::Convolution::Sparse::DENSE;

  184.     if (args.filter_meta.should_flip) {

  185.         mode = param::Convolution::Mode::CONVOLUTION;

  186.     } else {

  187.         mode = param::Convolution::Mode::CROSS_CORRELATION;

  188.     }

  189.     return param::Convolution{

  190.             mode,

  191.             args.filter_meta.padding[0],

  192.             args.filter_meta.padding[1],

  193.             args.filter_meta.stride[0],

  194.             args.filter_meta.stride[1],

  195.             args.filter_meta.dilation[1],

  196.             args.filter_meta.dilation[0],

  197.             sparse,

  198.             args.filter_meta.format,

  199.             args.opr->param().compute_mode};

  200. }

  201. 

  202. void ConvBiasForwardImpl::AlgoPack::fill_cudnn_algos() {

  203.     for (auto&& algo : CudnnAlgoPack::conv_fwd_algos()) {

  204.         cudnn_conv_bias_activations.push_back(algo.first);

  205.         cudnn_convs.push_back(algo.first);

  206.     }

  207. }

  208. 

  209. #if CUDA_VERSION >= 10000

  210. void ConvBiasForwardImpl::AlgoPack::fill_imma_algos() {

  211.     int8_chwn4_imma.push_back(

  212.             {AlgoInt8CHWN4IMMAImplicitGemm::MMATileSize::IMMA16x16x16});

  213.     int8_chwn4_imma.push_back(

  214.             {AlgoInt8CHWN4IMMAImplicitGemm::MMATileSize::IMMA32x8x16});

  215.     int8_chwn4_imma.push_back(

  216.             {AlgoInt8CHWN4IMMAImplicitGemm::MMATileSize::IMMA8x32x16});

  217.     int8_nchw4_imma.push_back(

  218.             {AlgoInt8NCHW4IMMAImplicitGemm::MMATileSize::IMMA16x16x16});

  219.     int8_nchw4_imma.push_back(

  220.             {AlgoInt8NCHW4IMMAImplicitGemm::MMATileSize::IMMA32x8x16});

  221.     int8_nchw4_imma.push_back(

  222.             {AlgoInt8NCHW4IMMAImplicitGemm::MMATileSize::IMMA8x32x16});

  223.     int8_chwn4_imma_reorder_filter.push_back(

  224.             {AlgoInt8CHWN4IMMAImplicitGemmReorderFilter::MMATileSize::IMMA16x16x16});

  225.     int8_chwn4_imma_reorder_filter.push_back(

  226.             {AlgoInt8CHWN4IMMAImplicitGemmReorderFilter::MMATileSize::IMMA32x8x16});

  227.     int8_chwn4_imma_reorder_filter.push_back(

  228.             {AlgoInt8CHWN4IMMAImplicitGemmReorderFilter::MMATileSize::IMMA8x32x16});

  229.     int8_chwn4_imma_unroll_width.push_back(

  230.             {AlgoInt8CHWN4IMMAImplicitGemmUnrollWidth::MMATileSize::IMMA16x16x16});

  231.     int8_chwn4_imma_unroll_width.push_back(

  232.             {AlgoInt8CHWN4IMMAImplicitGemmUnrollWidth::MMATileSize::IMMA32x8x16});

  233.     int8_chwn4_imma_unroll_width.push_back(

  234.             {AlgoInt8CHWN4IMMAImplicitGemmUnrollWidth::MMATileSize::IMMA8x32x16});

  235. #if CUDA_VERSION >= 10020

  236.     {

  237.         using AlgoParam = AlgoInt8NCHW32IMMAImplicitGemm::AlgoParam;

  238.         int8_nchw32_imma.emplace_back(AlgoParam{128, 256, 64, 64, 64, 64, 8, 8, 16, 2});

  239.         int8_nchw32_imma.emplace_back(AlgoParam{256, 128, 64, 64, 64, 64, 8, 8, 16, 2});

  240.         int8_nchw32_imma.emplace_back(AlgoParam{128, 128, 64, 64, 64, 64, 8, 8, 16, 2});

  241.         int8_nchw32_imma.emplace_back(AlgoParam{128, 64, 64, 64, 32, 64, 8, 8, 16, 2});

  242.         int8_nchw32_imma.emplace_back(AlgoParam{64, 128, 64, 32, 64, 64, 8, 8, 16, 2});

  243.         int8_nchw32_imma.emplace_back(AlgoParam{128, 64, 32, 64, 32, 32, 8, 8, 16, 1});

  244.         int8_nchw32_imma.emplace_back(AlgoParam{128, 32, 32, 64, 32, 32, 8, 8, 16, 1});

  245.         int8_nchw32_imma.emplace_back(AlgoParam{64, 128, 32, 32, 64, 32, 8, 8, 16, 1});

  246.         int8_nchw32_imma.emplace_back(AlgoParam{32, 128, 32, 32, 64, 32, 8, 8, 16, 1});

  247.     }

  248.     {

  249.         using AlgoParam = AlgoInt8NHWCIMMAImplicitGemm::AlgoParam;

  250.         int8_nhwc_imma.emplace_back(AlgoParam{64, 16, 32, 64, 16, 32, 8, 8, 16, 2, 16});

  251.         int8_nhwc_imma.emplace_back(AlgoParam{64, 16, 32, 64, 16, 32, 8, 8, 16, 2, 8});

  252.         int8_nhwc_imma.emplace_back(AlgoParam{64, 16, 32, 64, 16, 32, 8, 8, 16, 2, 4});

  253.         int8_nhwc_imma.emplace_back(

  254.                 AlgoParam{128, 32, 32, 64, 32, 32, 8, 8, 16, 1, 16});

  255.         int8_nhwc_imma.emplace_back(AlgoParam{128, 32, 32, 64, 32, 32, 8, 8, 16, 1, 8});

  256.         int8_nhwc_imma.emplace_back(AlgoParam{128, 32, 32, 64, 32, 32, 8, 8, 16, 1, 4});

  257.     }

  258.     {

  259.         using AlgoParam = AlgoInt4Int4NCHW64IMMAImplicitGemm::AlgoParam;

  260.         int4_int4_nchw64_imma.emplace_back(

  261.                 AlgoParam{128, 128, 128, 64, 64, 128, 8, 8, 32, 2});

  262.         int4_int4_nchw64_imma.emplace_back(

  263.                 AlgoParam{128, 256, 128, 64, 64, 128, 8, 8, 32, 2});

  264.         int4_int4_nchw64_imma.emplace_back(

  265.                 AlgoParam{128, 64, 128, 64, 64, 128, 8, 8, 32, 2});

  266.         int4_int4_nchw64_imma.emplace_back(

  267.                 AlgoParam{128, 64, 64, 64, 64, 64, 8, 8, 32, 1});

  268.     }

  269.     {

  270.         using AlgoParam = AlgoUInt4Int4NCHW64IMMAImplicitGemm::AlgoParam;

  271.         uint4_int4_nchw64_imma.emplace_back(

  272.                 AlgoParam{128, 128, 128, 64, 64, 128, 8, 8, 32, 2});

  273.         uint4_int4_nchw64_imma.emplace_back(

  274.                 AlgoParam{128, 256, 128, 64, 64, 128, 8, 8, 32, 2});

  275.         uint4_int4_nchw64_imma.emplace_back(

  276.                 AlgoParam{128, 64, 128, 64, 64, 128, 8, 8, 32, 2});

  277.         uint4_int4_nchw64_imma.emplace_back(

  278.                 AlgoParam{128, 64, 64, 64, 64, 64, 8, 8, 32, 1});

  279.     }

  280.     {

  281.         using AlgoParam = AlgoInt4Int4NHWCIMMAImplicitGemm::AlgoParam;

  282.         int4_int4_nhwc_imma.emplace_back(

  283.                 AlgoParam{128, 16, 64, 128, 16, 64, 8, 8, 32, 2, 32});

  284.         int4_int4_nhwc_imma.emplace_back(

  285.                 AlgoParam{128, 16, 64, 128, 16, 64, 8, 8, 32, 2, 16});

  286.         int4_int4_nhwc_imma.emplace_back(

  287.                 AlgoParam{128, 16, 64, 128, 16, 64, 8, 8, 32, 2, 8});

  288.         int4_int4_nhwc_imma.emplace_back(

  289.                 AlgoParam{128, 32, 64, 64, 32, 64, 8, 8, 32, 1, 32});

  290.         int4_int4_nhwc_imma.emplace_back(

  291.                 AlgoParam{128, 32, 64, 64, 32, 64, 8, 8, 32, 1, 16});

  292.         int4_int4_nhwc_imma.emplace_back(

  293.                 AlgoParam{128, 32, 64, 64, 32, 64, 8, 8, 32, 1, 8});

  294.         int4_int4_nhwc_imma.emplace_back(

  295.                 AlgoParam{128, 64, 64, 64, 64, 64, 8, 8, 32, 1, 32});

  296.         int4_int4_nhwc_imma.emplace_back(

  297.                 AlgoParam{128, 64, 64, 64, 64, 64, 8, 8, 32, 1, 16});

  298.         int4_int4_nhwc_imma.emplace_back(

  299.                 AlgoParam{128, 64, 64, 64, 64, 64, 8, 8, 32, 1, 8});

  300.     }

  301.     {

  302.         using AlgoParam = AlgoUInt4Int4NHWCIMMAImplicitGemm::AlgoParam;

  303.         uint4_int4_nhwc_imma.emplace_back(

  304.                 AlgoParam{128, 16, 64, 128, 16, 64, 8, 8, 32, 2, 32});

  305.         uint4_int4_nhwc_imma.emplace_back(

  306.                 AlgoParam{128, 16, 64, 128, 16, 64, 8, 8, 32, 2, 16});

  307.         uint4_int4_nhwc_imma.emplace_back(

  308.                 AlgoParam{128, 16, 64, 128, 16, 64, 8, 8, 32, 2, 8});

  309.         uint4_int4_nhwc_imma.emplace_back(

  310.                 AlgoParam{128, 32, 64, 64, 32, 64, 8, 8, 32, 1, 32});

  311.         uint4_int4_nhwc_imma.emplace_back(

  312.                 AlgoParam{128, 32, 64, 64, 32, 64, 8, 8, 32, 1, 16});

  313.         uint4_int4_nhwc_imma.emplace_back(

  314.                 AlgoParam{128, 32, 64, 64, 32, 64, 8, 8, 32, 1, 8});

  315.         uint4_int4_nhwc_imma.emplace_back(

  316.                 AlgoParam{128, 64, 64, 64, 64, 64, 8, 8, 32, 1, 32});

  317.         uint4_int4_nhwc_imma.emplace_back(

  318.                 AlgoParam{128, 64, 64, 64, 64, 64, 8, 8, 32, 1, 16});

  319.         uint4_int4_nhwc_imma.emplace_back(

  320.                 AlgoParam{128, 64, 64, 64, 64, 64, 8, 8, 32, 1, 8});

  321.     }

  322. #endif

  323. }

  324. #endif

  325. 

  326. void ConvBiasForwardImpl::AlgoPack::fill_dwconv_algos() {

  327.     using AlgoParam = AlgoCutlassConvolutionBase::AlgoParam;

  328.     /// preferred algo

  329.     f32_implicit_bmm.emplace_back(AlgoParam{64, 128, 8, 32, 64, 8, 1, 1, 1, 2});

  330.     f32_implicit_bmm.emplace_back(AlgoParam{128, 128, 8, 32, 64, 8, 1, 1, 1, 2});

  331.     f32_implicit_bmm.emplace_back(AlgoParam{128, 64, 8, 64, 32, 8, 1, 1, 1, 2});

  332.     f32_implicit_bmm.emplace_back(AlgoParam{128, 32, 8, 64, 32, 8, 1, 1, 1, 2});

  333.     f32_implicit_bmm.emplace_back(AlgoParam{32, 128, 8, 32, 64, 8, 1, 1, 1, 2});

  334.     f32_implicit_bmm.emplace_back(AlgoParam{64, 64, 8, 32, 64, 8, 1, 1, 1, 2});

  335.     f32_implicit_bmm.emplace_back(AlgoParam{32, 64, 8, 32, 64, 8, 1, 1, 1, 2});

  336.     f32_implicit_bmm.emplace_back(AlgoParam{32, 32, 8, 32, 32, 8, 1, 1, 1, 2});

  337.     f32_implicit_bmm.emplace_back(AlgoParam{64, 32, 8, 64, 32, 8, 1, 1, 1, 2});

  338.     for (auto&& algo : f32_implicit_bmm) {

  339.         all_algos.push_back(&algo);

  340.     }

  341. #if CUDA_VERSION >= 10010

  342.     /// preferred algo

  343.     f16_implicit_bmm.emplace_back(AlgoParam{64, 128, 32, 32, 32, 32, 8, 8, 4, 2});

  344.     f16_implicit_bmm.emplace_back(AlgoParam{128, 128, 32, 32, 32, 32, 8, 8, 4, 2});

  345.     f16_implicit_bmm.emplace_back(AlgoParam{128, 256, 32, 64, 64, 32, 8, 8, 4, 2});

  346.     f16_implicit_bmm.emplace_back(AlgoParam{128, 64, 32, 32, 32, 32, 8, 8, 4, 2});

  347.     f16_implicit_bmm.emplace_back(AlgoParam{64, 64, 32, 32, 32, 32, 8, 8, 4, 2});

  348.     for (auto&& algo : f16_implicit_bmm) {

  349.         all_algos.push_back(&algo);

  350.     }

  351. #endif

  352. }

  353. 

  354. void ConvBiasForwardImpl::AlgoPack::fill_dp4a_algos() {

  355.     using AlgoParam = AlgoInt8NCHW4DotProdImplicitGemm::AlgoParam;

  356.     int8_nchw4_dotprod.emplace_back(AlgoParam{128, 128, 32, 64, 32, 32, 1, 1, 4, 2});

  357.     int8_nchw4_dotprod.emplace_back(AlgoParam{128, 64, 32, 64, 32, 32, 1, 1, 4, 2});

  358.     int8_nchw4_dotprod.emplace_back(AlgoParam{64, 128, 32, 64, 32, 32, 1, 1, 4, 2});

  359.     int8_nchw4_dotprod.emplace_back(AlgoParam{32, 128, 32, 32, 64, 32, 1, 1, 4, 2});

  360.     int8_nchw4_dotprod.emplace_back(AlgoParam{128, 32, 32, 64, 32, 32, 1, 1, 4, 2});

  361.     int8_nchw4_dotprod.emplace_back(AlgoParam{32, 64, 32, 32, 64, 32, 1, 1, 4, 2});

  362.     int8_nchw4_dotprod.emplace_back(AlgoParam{64, 32, 32, 64, 32, 32, 1, 1, 4, 2});

  363.     int8_nchw4_dotprod.emplace_back(AlgoParam{16, 128, 16, 16, 128, 16, 1, 1, 4, 1});

  364.     int8_nchw4_dotprod.emplace_back(AlgoParam{16, 64, 8, 16, 64, 8, 1, 1, 4, 2});

  365. }

  366. 

  367. ConvBiasForwardImpl::AlgoBase* ConvBiasForwardImpl::AlgoPack::cudnn_conv_from_enum(

  368.         cudnnConvolutionFwdAlgo_t algo) {

  369.     for (auto&& i : cudnn_convs) {

  370.         if (i.cudnn_enum() == algo)

  371.             return &i;

  372.     }

  373.     megdnn_throw(ssprintf(

  374.             "can not find cudnn conv fwd algorithm %d", static_cast<int>(algo)));

  375. }

  376. 

  377. ConvBiasForwardImpl::AlgoBase* ConvBiasForwardImpl::AlgoPack::

  378.         cudnn_conv_bias_act_from_enum(cudnnConvolutionFwdAlgo_t algo) {

  379.     for (auto&& i : cudnn_conv_bias_activations) {

  380.         if (i.cudnn_enum() == algo)

  381.             return &i;

  382.     }

  383.     megdnn_throw(ssprintf(

  384.             "can not find cudnn conv bias act algorithm %d", static_cast<int>(algo)));

  385. }

  386. 

  387. // vim: syntax=cpp.doxygen