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

515 lines
23 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/src/fallback/conv_bias/algos.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 "src/fallback/conv_bias/algos.h"

  13. #include "src/common/opr_delegate.h"

  14. #include "src/fallback/conv_bias/winograd/strategy.h"

  15. #include "src/naive/convolution/helper.h"

  16. 

  17. #include "midout.h"

  18. 

  19. using namespace megdnn;

  20. using namespace fallback;

  21. 

  22. namespace {

  23. 

  24. param::Convolution get_param_convolution(const param::ConvBias param) {

  25.     param::Convolution ret{param.mode,     param.pad_h,

  26.                            param.pad_w,    param.stride_h,

  27.                            param.stride_w, param.dilate_h,

  28.                            param.dilate_w, param::Convolution::Sparse::DENSE,

  29.                            param.format};

  30.     return ret;

  31. }

  32. 

  33. TensorLayoutArray get_layouts(const param::ConvBias& param,

  34.                               const ConvBiasImpl::NCBKernSizeParam& p) {

  35.     megdnn_assert(param.format == param::ConvBias::Format::NCHW);

  36.     UNPACK_CONV_NCB_KERN_SIZES(p);

  37.     MEGDNN_MARK_USED_VAR(SH);

  38.     MEGDNN_MARK_USED_VAR(SW);

  39.     MEGDNN_MARK_USED_VAR(PH);

  40.     MEGDNN_MARK_USED_VAR(PW);

  41.     MEGDNN_MARK_USED_VAR(OW);

  42.     MEGDNN_MARK_USED_VAR(OH);

  43.     MEGDNN_MARK_USED_VAR(N);

  44.     TensorLayout src_layout({1, IC, IH, IW}, p.src_type);

  45.     TensorLayout filter_layout({OC, IC, FH, FW}, p.filter_type);

  46.     TensorLayout bias_layout{{}, p.bias_type};

  47.     if (p.bias_mode == BiasMode::BROADCAST_CHANNEL_BIAS) {

  48.         bias_layout = TensorLayout({1, OC, 1, 1}, p.bias_type);

  49.     } else if (p.bias_mode == BiasMode::BIAS) {

  50.         bias_layout = TensorLayout({1, OC, OH, OW}, p.bias_type);

  51.     }

  52.     TensorLayout dst_layout = TensorLayout({1, OC, OH, OW}, p.dst_type);

  53.     return {src_layout, filter_layout, bias_layout, dst_layout};

  54. }

  55. 

  56. void kern_default(param::ConvBias param, const ConvBiasImpl::NCBKernParam& p) {

  57.     dt_byte* workspace_ptr = static_cast<dt_byte*>(p.workspace_ptr);

  58. 

  59.     auto filter_meta_ptr =

  60.             reinterpret_cast<const ConvBiasForward::CanonizedFilterMeta*>(

  61.                     &p.filter_meta);

  62.     auto filter_meta = *filter_meta_ptr;

  63.     auto layouts = get_layouts(param, p);

  64. 

  65.     TensorND src{reinterpret_cast<dt_byte*>(const_cast<void*>(p.src_ptr)),

  66.                  layouts[0]};

  67.     TensorND filter{const_cast<void*>(p.filter_ptr), layouts[1]};

  68.     auto bias_ptr = reinterpret_cast<dt_byte*>(const_cast<void*>(p.bias_ptr));

  69.     TensorND bias{bias_ptr, layouts[2]};

  70.     TensorND dst{reinterpret_cast<dt_byte*>(const_cast<void*>(p.dst_ptr)),

  71.                  layouts[3]};

  72. 

  73.     auto sfb = dst;

  74.     if (bias.layout.dtype.enumv() != dst.layout.dtype.enumv()) {

  75.         // intermediate result

  76.         sfb = TensorND{workspace_ptr,

  77.                        TensorLayout{dst.layout, bias.layout.dtype}};

  78.     }

  79. #define DISPATCH_RAW(in_dt, bias_dt, out_dt, cmode, func)                      \

  80.     else if (src.layout.dtype.enumv() == DTypeTrait<dtype::in_dt>::enumv &&    \

  81.              filter.layout.dtype.enumv() == DTypeTrait<dtype::in_dt>::enumv && \

  82.              (!bias.layout.dtype.valid() ||                                    \

  83.               bias.layout.dtype.enumv() ==                                     \

  84.                       DTypeTrait<dtype::bias_dt>::enumv) &&                    \

  85.              sfb.layout.dtype.enumv() == DTypeTrait<dtype::out_dt>::enumv &&   \

  86.              param.compute_mode == param::ConvBias::ComputeMode::cmode) {      \

  87.         func(src, filter, bias, sfb, workspace_ptr, filter_meta);              \

  88.     }

  89. #define DISPATCH(in_dt, out_dt)                             \

  90.     DISPATCH_RAW(in_dt, out_dt, out_dt, DEFAULT,            \

  91.                  (megdnn::naive::convolution::forward_bias< \

  92.                          DTypeTrait<dtype::in_dt>::ctype,   \

  93.                          DTypeTrait<dtype::in_dt>::ctype,   \

  94.                          DTypeTrait<dtype::out_dt>::ctype,  \

  95.                          DTypeTrait<dtype::out_dt>::ctype>))

  96.     if (0) {

  97.     }

  98.     DISPATCH(Float32, Float32)

  99.     DISPATCH(Int8, Int16)

  100.     DISPATCH(Int8, Int32)

  101.     DISPATCH(QuantizedS8, QuantizedS32)

  102.     DISPATCH(Quantized8Asymm, QuantizedS32)

  103. #if !MEGDNN_DISABLE_FLOAT16

  104.     DISPATCH(Float16, Float16)

  105.     DISPATCH_RAW(

  106.             Float16, Float16, Float16, FLOAT32,

  107.             (megdnn::naive::convolution::forward_bias<dt_float16, dt_float16,

  108.                                                       dt_float16, dt_float32>))

  109. #endif

  110.     else {

  111.         megdnn_throw(

  112.                 ssprintf("unsupported naive ConvBias(%s, %s, %s) -> %s",

  113.                          src.layout.dtype.name(), filter.layout.dtype.name(),

  114.                          bias.layout.dtype.name(), dst.layout.dtype.name()));

  115.     }

  116. #undef DISPATCH

  117. #undef DISPATCH_RAW

  118. 

  119.     auto res = sfb;

  120.     using NonlineMode = param::ConvBias::NonlineMode;

  121.     switch (param.nonlineMode) {

  122. #define cb(_mode)                                                             \

  123.     case NonlineMode::_mode: {                                                \

  124.         if (res.layout.dtype.category() != DTypeCategory::QUANTIZED) {        \

  125.             auto nonlinear =                                                  \

  126.                     inplace_cpu_handle()->create_operator<ElemwiseForward>(); \

  127.             nonlinear->param().mode = Elemwise::Param::Mode::_mode;           \

  128.             nonlinear->exec({res}, dst);                                      \

  129.         } else {                                                              \

  130.             auto nonlinear = inplace_cpu_handle()                             \

  131.                                      ->create_operator<ElemwiseMultiType>();  \

  132.             nonlinear->param().mode =                                         \

  133.                     ElemwiseMultiType::Param::Mode::Q##_mode;                 \

  134.             nonlinear->exec({res}, dst);                                      \

  135.         }                                                                     \

  136.         break;                                                                \

  137.     }

  138.         cb(RELU);

  139.         cb(H_SWISH);

  140. #undef cb

  141.         case NonlineMode::SIGMOID: {

  142.             megdnn_assert(res.layout.dtype.category() !=

  143.                           DTypeCategory::QUANTIZED);

  144.             auto nonlinear =

  145.                     inplace_cpu_handle()->create_operator<ElemwiseForward>();

  146.             nonlinear->param().mode = Elemwise::Param::Mode::SIGMOID;

  147.             nonlinear->exec({res}, res);

  148.             if (res.raw_ptr != dst.raw_ptr) {

  149.                 inplace_cpu_handle()->create_operator<TypeCvt>()->exec(res,

  150.                                                                        dst);

  151.             }

  152.             break;

  153.         }

  154.         case NonlineMode::IDENTITY: {

  155.             if (res.raw_ptr != dst.raw_ptr) {

  156.                 inplace_cpu_handle()->create_operator<TypeCvt>()->exec(res,

  157.                                                                        dst);

  158.             }

  159.             break;

  160.         }

  161.         default:

  162.             megdnn_assert(false);

  163.     }

  164. }

  165. }  // namespace

  166. 

  167. MIDOUT_DECL(megdnn_fallback_naive)

  168. /* ======================= AlgoNaive ======================== */

  169. 

  170. bool ConvBiasImpl::AlgoNaive::usable(

  171.         ConvBiasImpl* opr, const NCBKernSizeParam&,

  172.         AlgoSelectionStrategy /*algo_selection_strategy*/) const {

  173.     MIDOUT_BEGIN(megdnn_fallback_naive, 0) {

  174.         return opr->param().format == param::ConvBias::Format::NCHW;

  175.     }

  176.     MIDOUT_END();

  177.     return false;

  178. }

  179. 

  180. size_t ConvBiasImpl::AlgoNaive::get_workspace(ConvBiasImpl* opr,

  181.                                               const NCBKernSizeParam& p) const {

  182.     MIDOUT_BEGIN(megdnn_fallback_naive, 1) {

  183.         auto layouts = get_layouts(opr->param(), p);

  184.         //! When group>1 or n>1, this algo will parallel by group and n

  185.         size_t nr_threads = p.nr_threads;

  186.         auto conv_opr =

  187.                 inplace_cpu_handle()->create_operator<ConvolutionForward>();

  188.         conv_opr->param() = get_param_convolution(opr->param());

  189.         if (p.dst_type.enumv() == DTypeEnum::QuantizedS8 ||

  190.             p.dst_type.enumv() == DTypeEnum::Quantized8Asymm) {

  191.             TensorLayout conv_dst_layout;

  192.             conv_opr->deduce_layout(layouts[0], layouts[1], conv_dst_layout);

  193.             WorkspaceBundle bundle(nullptr,

  194.                                    {conv_dst_layout.span().dist_byte()});

  195.             return bundle.total_size_in_bytes() * nr_threads;

  196.         }

  197.         return 0;

  198.     }

  199.     MIDOUT_END();

  200.     return 0;

  201. }

  202. 

  203. SmallVector<ConvBiasImpl::NCBKern> ConvBiasImpl::AlgoNaive::dispatch_kerns(

  204.         ConvBiasImpl* opr, const NCBKernSizeParam& p) const {

  205.     param::ConvBias opr_param = opr->param();

  206.     size_t workspace_size = get_workspace(opr, p);

  207.     //! When group>1 or n>1, this algo will parallel by group and n

  208.     size_t nr_threads = p.nr_threads;

  209.     size_t GROUP = p.filter_meta.group;

  210.     size_t N = p.n;

  211.     size_t workspace_per_thread = workspace_size / nr_threads;

  212.     auto kern = [opr_param, workspace_per_thread](

  213.                         const NCBKernParam& param,

  214.                         const NCBKernIndex& ncb_index) {

  215.         MIDOUT_BEGIN(megdnn_fallback_naive, 2) {

  216.             size_t group_id = ncb_index.ndrange_id[0];

  217.             size_t batch_id = ncb_index.ndrange_id[1];

  218.             size_t thread_id = ncb_index.thread_id;

  219.             auto thread_param = param;

  220.             thread_param.workspace_ptr = reinterpret_cast<void*>(

  221.                     reinterpret_cast<ptrdiff_t>(param.workspace_ptr) +

  222.                     thread_id * workspace_per_thread);

  223.             thread_param.filter_ptr = param.filter<void>(group_id);

  224.             thread_param.dst_ptr = param.dst<void>(batch_id, group_id);

  225.             thread_param.src_ptr = param.src<void>(batch_id, group_id);

  226.             thread_param.bias_ptr = param.bias<void>(batch_id, group_id);

  227.             kern_default(opr_param, thread_param);

  228.         }

  229.         MIDOUT_END();

  230.     };

  231.     return {{kern, {GROUP, N, 1_z}}};

  232. }

  233. 

  234. MIDOUT_DECL(megdnn_fallback_winograd)

  235. /* ======================= AlgoWinogradF32 ======================== */

  236. 

  237. bool ConvBiasImpl::AlgoWinogradF32::usable(

  238.         ConvBiasImpl* opr, const NCBKernSizeParam& param,

  239.         AlgoSelectionStrategy /*algo_selection_strategy*/) const {

  240.     MEGDNN_MARK_USED_VAR(param);

  241.     MEGDNN_MARK_USED_VAR(opr);

  242.     MIDOUT_BEGIN(megdnn_fallback_winograd, 1, 0) {

  243.         using Strategy = fallback::winograd::winograd_2x3_1x1_f;

  244.         Strategy strategy(param.src_type, param.filter_type, param.dst_type);

  245.         auto&& matmul_param = megdnn::winograd::ConvBias<Strategy>(

  246.                                       strategy, UNIT_TILE_SIZE, param)

  247.                                       .get_matmul_kern_param(param);

  248.         return m_matmul_algo->usable(matmul_param) &&

  249.                (opr->param().format == param::ConvBias::Format::NCHW ||

  250.                 (opr->param().format ==

  251.                          param::ConvBias::Format::NCHW_WINOGRAD &&

  252.                  opr->param().output_block_size == 2 &&

  253.                  param.winograd_matmul_format ==

  254.                          param::MatrixMul::Format::DEFAULT)) &&

  255.                opr->param().mode == param::ConvBias::Mode::CROSS_CORRELATION &&

  256.                (param.filter_meta.spatial[0] == param.filter_meta.spatial[1] &&

  257.                 param.filter_meta.spatial[0] == 3) &&

  258.                (param.filter_meta.stride[0] == param.filter_meta.stride[1] &&

  259.                 param.filter_meta.stride[0] == 1) &&

  260.                (param.filter_meta.dilation[0] ==

  261.                         param.filter_meta.dilation[1] &&

  262.                 param.filter_meta.dilation[0] == 1) &&

  263.                param.compute_mode == param::ConvBias::ComputeMode::DEFAULT &&

  264.                param.src_type.enumv() == DTypeEnum::Float32;

  265.     }

  266.     MIDOUT_END();

  267.     return false;

  268. }

  269. 

  270. size_t ConvBiasImpl::AlgoWinogradF32::get_workspace(

  271.         ConvBiasImpl*, const NCBKernSizeParam& p) const {

  272.     MEGDNN_MARK_USED_VAR(p);

  273.     MIDOUT_BEGIN(megdnn_fallback_winograd, 1, 1) {

  274.         fallback::winograd::winograd_2x3_1x1_f strategy(

  275.                 p.src_type, p.filter_type, p.dst_type);

  276.         return megdnn::winograd::ConvBias<

  277.                        fallback::winograd::winograd_2x3_1x1_f>(

  278.                        strategy, UNIT_TILE_SIZE, p)

  279.                 .get_workspace_size(p, m_matmul_algo);

  280.     }

  281.     MIDOUT_END();

  282.     return 0;

  283. }

  284. 

  285. SmallVector<ConvBiasImpl::NCBKern>

  286. ConvBiasImpl::AlgoWinogradF32::dispatch_kerns(

  287.         ConvBiasImpl*, const NCBKernSizeParam& param) const {

  288.     MEGDNN_MARK_USED_VAR(param);

  289.     MIDOUT_BEGIN(megdnn_fallback_winograd, 1, 2) {

  290.         fallback::winograd::winograd_2x3_1x1_f strategy(

  291.                 param.src_type, param.filter_type, param.dst_type);

  292. 

  293.         auto winograd_impl = megdnn::winograd::ConvBias<

  294.                 fallback::winograd::winograd_2x3_1x1_f>(strategy,

  295.                                                         UNIT_TILE_SIZE, param);

  296.         return winograd_impl.get_kerns(param, m_matmul_algo);

  297.     }

  298.     MIDOUT_END();

  299.     return {};

  300. }

  301. 

  302. /* ======================= AlgoWinogradF32 4x4 ======================== */

  303. 

  304. bool ConvBiasImpl::AlgoWinogradF32_4x4::usable(

  305.         ConvBiasImpl* opr, const NCBKernSizeParam& param,

  306.         AlgoSelectionStrategy /*algo_selection_strategy*/) const {

  307.     MEGDNN_MARK_USED_VAR(param);

  308.     MEGDNN_MARK_USED_VAR(opr);

  309.     MIDOUT_BEGIN(megdnn_fallback_winograd, 2, 0) {

  310.         if (param.filter_meta.icpg % 4 != 0 || param.filter_meta.ocpg % 4 != 0)

  311.             return false;

  312.         using Strategy = fallback::winograd::winograd_2x3_4x4_f;

  313.         Strategy strategy(param.src_type, param.filter_type, param.dst_type);

  314.         auto&& matmul_param =

  315.                 megdnn::winograd::ConvBias<Strategy,

  316.                                            param::MatrixMul::Format::MK4>(

  317.                         strategy, UNIT_TILE_SIZE, param)

  318.                         .get_matmul_kern_param(param);

  319.         return m_matmul_algo->usable(matmul_param) &&

  320.                (opr->param().format == param::ConvBias::Format::NCHW ||

  321.                 (opr->param().format ==

  322.                          param::ConvBias::Format::NCHW_WINOGRAD &&

  323.                  opr->param().output_block_size == 2 &&

  324.                  param.winograd_matmul_format ==

  325.                          param::MatrixMul::Format::MK4)) &&

  326.                opr->param().mode == param::ConvBias::Mode::CROSS_CORRELATION &&

  327.                (param.filter_meta.spatial[0] == param.filter_meta.spatial[1] &&

  328.                 param.filter_meta.spatial[0] == 3) &&

  329.                (param.filter_meta.stride[0] == param.filter_meta.stride[1] &&

  330.                 param.filter_meta.stride[0] == 1) &&

  331.                (param.filter_meta.dilation[0] ==

  332.                         param.filter_meta.dilation[1] &&

  333.                 param.filter_meta.dilation[0] == 1) &&

  334.                param.compute_mode == param::ConvBias::ComputeMode::DEFAULT &&

  335.                param.src_type.enumv() == DTypeEnum::Float32;

  336.     }

  337.     MIDOUT_END();

  338.     return false;

  339. }

  340. 

  341. size_t ConvBiasImpl::AlgoWinogradF32_4x4::get_workspace(

  342.         ConvBiasImpl*, const NCBKernSizeParam& p) const {

  343.     MEGDNN_MARK_USED_VAR(p);

  344.     MIDOUT_BEGIN(megdnn_fallback_winograd, 2, 1) {

  345.         fallback::winograd::winograd_2x3_4x4_f strategy(

  346.                 p.src_type, p.filter_type, p.dst_type);

  347.         return megdnn::winograd::ConvBias<

  348.                        fallback::winograd::winograd_2x3_4x4_f,

  349.                        param::MatrixMul::Format::MK4>(strategy, UNIT_TILE_SIZE,

  350.                                                       p)

  351.                 .get_workspace_size(p, m_matmul_algo);

  352.     }

  353.     MIDOUT_END();

  354.     return 0;

  355. }

  356. 

  357. SmallVector<ConvBiasImpl::NCBKern>

  358. ConvBiasImpl::AlgoWinogradF32_4x4::dispatch_kerns(

  359.         ConvBiasImpl*, const NCBKernSizeParam& param) const {

  360.     MEGDNN_MARK_USED_VAR(param);

  361.     MIDOUT_BEGIN(megdnn_fallback_winograd, 2, 2) {

  362.         fallback::winograd::winograd_2x3_4x4_f strategy(

  363.                 param.src_type, param.filter_type, param.dst_type);

  364. 

  365.         auto winograd_impl = megdnn::winograd::ConvBias<

  366.                 fallback::winograd::winograd_2x3_4x4_f,

  367.                 param::MatrixMul::Format::MK4>(strategy, UNIT_TILE_SIZE, param);

  368.         return winograd_impl.get_kerns(param, m_matmul_algo);

  369.     }

  370.     MIDOUT_END();

  371.     return {};

  372. }

  373. 

  374. /* ======================= AlgoWinogradQS8 ======================== */

  375. 

  376. bool ConvBiasImpl::AlgoWinogradQS8::usable(

  377.         ConvBiasImpl* opr, const NCBKernSizeParam& param,

  378.         AlgoSelectionStrategy /*algo_selection_strategy*/) const {

  379.     MEGDNN_MARK_USED_VAR(param);

  380.     MEGDNN_MARK_USED_VAR(opr);

  381.     MIDOUT_BEGIN(megdnn_fallback_winograd, 3, 0) {

  382.         using Strategy = fallback::winograd::winograd_2x3_1x1_qs8;

  383.         Strategy strategy(param.src_type, param.filter_type, param.dst_type);

  384.         auto&& matmul_param = megdnn::winograd::ConvBias<Strategy>(

  385.                                       strategy, UNIT_TILE_SIZE, param)

  386.                                       .get_matmul_kern_param(param);

  387. 

  388.         return m_matmul_algo->usable(matmul_param) &&

  389.                (opr->param().format == param::ConvBias::Format::NCHW ||

  390.                 (opr->param().format ==

  391.                          param::ConvBias::Format::NCHW_WINOGRAD &&

  392.                  opr->param().output_block_size == 2 &&

  393.                  param.winograd_matmul_format ==

  394.                          param::MatrixMul::Format::DEFAULT)) &&

  395.                opr->param().mode == param::ConvBias::Mode::CROSS_CORRELATION &&

  396.                (param.filter_meta.spatial[0] == param.filter_meta.spatial[1] &&

  397.                 param.filter_meta.spatial[0] == 3) &&

  398.                (param.filter_meta.stride[0] == param.filter_meta.stride[1] &&

  399.                 param.filter_meta.stride[0] == 1) &&

  400.                (param.filter_meta.dilation[0] ==

  401.                         param.filter_meta.dilation[1] &&

  402.                 param.filter_meta.dilation[0] == 1) &&

  403.                param.compute_mode == param::ConvBias::ComputeMode::DEFAULT &&

  404.                param.src_type.enumv() == DTypeEnum::QuantizedS8;

  405.     }

  406.     MIDOUT_END();

  407.     return false;

  408. }

  409. 

  410. size_t ConvBiasImpl::AlgoWinogradQS8::get_workspace(

  411.         ConvBiasImpl*, const NCBKernSizeParam& p) const {

  412.     MEGDNN_MARK_USED_VAR(p);

  413.     MIDOUT_BEGIN(megdnn_fallback_winograd, 3, 1) {

  414.         fallback::winograd::winograd_2x3_1x1_qs8 strategy(

  415.                 p.src_type, p.filter_type, p.dst_type);

  416.         return megdnn::winograd::ConvBias<

  417.                        fallback::winograd::winograd_2x3_1x1_qs8>(

  418.                        strategy, UNIT_TILE_SIZE, p)

  419.                 .get_workspace_size(p, m_matmul_algo);

  420.     }

  421.     MIDOUT_END();

  422.     return 0;

  423. }

  424. 

  425. SmallVector<ConvBiasImpl::NCBKern>

  426. ConvBiasImpl::AlgoWinogradQS8::dispatch_kerns(

  427.         ConvBiasImpl*, const NCBKernSizeParam& param) const {

  428.     MEGDNN_MARK_USED_VAR(param);

  429.     MIDOUT_BEGIN(megdnn_fallback_winograd, 3, 2) {

  430.         fallback::winograd::winograd_2x3_1x1_qs8 strategy(

  431.                 param.src_type, param.filter_type, param.dst_type);

  432. 

  433.         auto winograd_impl = megdnn::winograd::ConvBias<

  434.                 fallback::winograd::winograd_2x3_1x1_qs8>(

  435.                 strategy, UNIT_TILE_SIZE, param);

  436.         return winograd_impl.get_kerns(param, m_matmul_algo);

  437.     }

  438.     MIDOUT_END();

  439.     return {};

  440. }

  441. 

  442. /* ======================= AlgoWinogradQS8 8x8 ======================== */

  443. 

  444. bool ConvBiasImpl::AlgoWinogradQS8_8x8::usable(

  445.         ConvBiasImpl* opr, const NCBKernSizeParam& param,

  446.         AlgoSelectionStrategy /*algo_selection_strategy*/) const {

  447.     MEGDNN_MARK_USED_VAR(param);

  448.     MEGDNN_MARK_USED_VAR(opr);

  449.     MIDOUT_BEGIN(megdnn_fallback_winograd, 4, 0) {

  450.         if (param.filter_meta.icpg % 8 != 0 || param.filter_meta.ocpg % 8 != 0)

  451.             return false;

  452.         using Strategy = fallback::winograd::winograd_2x3_8x8_qs8;

  453.         Strategy strategy(param.src_type, param.filter_type, param.dst_type);

  454.         auto&& matmul_param =

  455.                 megdnn::winograd::ConvBias<Strategy,

  456.                                            param::MatrixMul::Format::MK8>(

  457.                         strategy, UNIT_TILE_SIZE, param)

  458.                         .get_matmul_kern_param(param);

  459.         return m_matmul_algo->usable(matmul_param) &&

  460.                (opr->param().format == param::ConvBias::Format::NCHW ||

  461.                 (opr->param().format ==

  462.                          param::ConvBias::Format::NCHW_WINOGRAD &&

  463.                  opr->param().output_block_size == 2 &&

  464.                  param.winograd_matmul_format ==

  465.                          param::MatrixMul::Format::MK8)) &&

  466.                opr->param().mode == param::ConvBias::Mode::CROSS_CORRELATION &&

  467.                (param.filter_meta.spatial[0] == param.filter_meta.spatial[1] &&

  468.                 param.filter_meta.spatial[0] == 3) &&

  469.                (param.filter_meta.stride[0] == param.filter_meta.stride[1] &&

  470.                 param.filter_meta.stride[0] == 1) &&

  471.                (param.filter_meta.dilation[0] ==

  472.                         param.filter_meta.dilation[1] &&

  473.                 param.filter_meta.dilation[0] == 1) &&

  474.                param.compute_mode == param::ConvBias::ComputeMode::DEFAULT &&

  475.                param.src_type.enumv() == DTypeEnum::QuantizedS8;

  476.     }

  477.     MIDOUT_END();

  478.     return false;

  479. }

  480. 

  481. size_t ConvBiasImpl::AlgoWinogradQS8_8x8::get_workspace(

  482.         ConvBiasImpl*, const NCBKernSizeParam& p) const {

  483.     MEGDNN_MARK_USED_VAR(p);

  484.     MIDOUT_BEGIN(megdnn_fallback_winograd, 4, 1) {

  485.         fallback::winograd::winograd_2x3_8x8_qs8 strategy(

  486.                 p.src_type, p.filter_type, p.dst_type);

  487.         return megdnn::winograd::ConvBias<

  488.                        fallback::winograd::winograd_2x3_8x8_qs8,

  489.                        param::MatrixMul::Format::MK8>(strategy, UNIT_TILE_SIZE,

  490.                                                       p)

  491.                 .get_workspace_size(p, m_matmul_algo);

  492.     }

  493.     MIDOUT_END();

  494.     return 0;

  495. }

  496. 

  497. SmallVector<ConvBiasImpl::NCBKern>

  498. ConvBiasImpl::AlgoWinogradQS8_8x8::dispatch_kerns(

  499.         ConvBiasImpl*, const NCBKernSizeParam& param) const {

  500.     MEGDNN_MARK_USED_VAR(param);

  501.     MIDOUT_BEGIN(megdnn_fallback_winograd, 4, 2) {

  502.         fallback::winograd::winograd_2x3_8x8_qs8 strategy(

  503.                 param.src_type, param.filter_type, param.dst_type);

  504. 

  505.         auto winograd_impl = megdnn::winograd::ConvBias<

  506.                 fallback::winograd::winograd_2x3_8x8_qs8,

  507.                 param::MatrixMul::Format::MK8>(strategy, UNIT_TILE_SIZE, param);

  508.         return winograd_impl.get_kerns(param, m_matmul_algo);

  509.     }

  510.     MIDOUT_END();

  511.     return {};

  512. }

  513. 

  514. // vim: syntax=cpp.doxygen