Huawei_Technology
/
MindSpore-AKG
Not watched
1
0
Fork 0
Code
Releases 1 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
MindSpore-AKG/python/akg/auto_tune/space_generators.py

627 lines
27 kB
Raw Permalink Blame History 

  1. # Copyright 2019 Huawei Technologies Co., Ltd

  2. #

  3. # Licensed under the Apache License, Version 2.0 (the "License");

  4. # you may not use this file except in compliance with the License.

  5. # You may obtain a copy of the License at

  6. #

  7. # http://www.apache.org/licenses/LICENSE-2.0

  8. #

  9. # Unless required by applicable law or agreed to in writing, software

  10. # distributed under the License is distributed on an "AS IS" BASIS,

  11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  12. # See the License for the specific language governing permissions and

  13. # limitations under the License.

  14. 

  15. """space generating functions for operators"""

  16. from functools import partial

  17. from typing import NamedTuple

  18. from collections import namedtuple

  19. from tests.common.test_run import matmul_run

  20. from akg.utils import validation_check as vc_util

  21. from akg.auto_tune.type_definitions import ConvDesc, ConvBackpropDesc, MatmulCubeDesc, ConvConfig, ConvBackpropInputConfig, ConvBackpropFilterConfig, MatmulCubeConfig

  22. from akg.auto_tune.space import ListConfigSpace

  23. from akg.auto_tune.kernel_compiler import compile_kernel

  24. 

  25. 

  26. def _get_space_vector(op_type: str, op_desc):

  27.     """get config space of vector operator"""

  28.     space_res, key, expect, input_for_mod = compile_kernel(op_type, op_desc, None, None, None, 0,

  29.                                                            gen_tiling_spaces=True)

  30. 

  31.     if space_res is None:

  32.         raise RuntimeError('no space returned')

  33.     if 'index' not in space_res or 'tuning_space' not in space_res:

  34.         raise RuntimeError('invalid space returned')

  35.     index_table = space_res['index']

  36.     tiling_spaces = space_res['tuning_space']

  37. 

  38.     if not tiling_spaces:

  39.         raise RuntimeError('empty tiling spaces')

  40. 

  41.     dim_names = ['tiling_' + str(i) for i in range(len(tiling_spaces[0]))]

  42.     input_type = namedtuple(op_type, dim_names)

  43.     space = ListConfigSpace(input_type)

  44.     for tiling_space in tiling_spaces:

  45.         config = input_type(*tiling_space)

  46.         space.add(config)

  47.     return index_table, space, key, expect, input_for_mod

  48. 

  49. 

  50. def _get_space_conv(op_desc: ConvDesc, tunning_attrs):

  51.     """get config space of convolution"""

  52.     if not isinstance(op_desc, ConvDesc):

  53.         raise TypeError('op_desc must be ConvDesc')

  54. 

  55.     stride_ = op_desc.stride

  56.     pad_ = op_desc.pad

  57.     dilation_ = op_desc.dilation

  58.     vc_util.convolution_format_check(op_desc.fmap_shape, op_desc.filter_shape, pad_, stride_, dilation_)

  59.     config_space = ListConfigSpace(ConvConfig)

  60. 

  61.     # if double buff is not enabled, set it's value to 1

  62.     size_scale = 1

  63. 

  64.     l1_max_size = (1024 * 1024) // size_scale

  65.     l0a_max_size = (64 * 1024) // size_scale

  66.     l0b_max_size = (64 * 1024) // size_scale

  67.     l0c_max_size = ((256 - 8) * 1024) // size_scale // 2

  68. 

  69.     _, in_c, in_h, in_w = op_desc.fmap_shape

  70.     k_n, _, k_h, k_w = op_desc.filter_shape

  71.     padding = (pad_[0], pad_[1], pad_[2], pad_[3])

  72.     p_top, p_bottom, p_left, p_right = padding

  73.     s_h, s_w = stride_

  74. 

  75.     in_c = ((in_c - 1) // 16 + 1) * 16

  76.     tile_c = in_c

  77.     tile_co_start = 16

  78. 

  79.     data_len = 2

  80. 

  81.     h_max = in_h + p_top + p_bottom

  82.     win_h = (h_max - k_h) // s_h + 1

  83.     h_max = (h_max - k_h) // s_h * s_h + k_h

  84.     w_max = in_w + p_left + p_right

  85.     win_w = (w_max - k_w) // s_w + 1

  86.     w_max = (w_max - k_w) // s_w * s_w + k_w

  87. 

  88.     bypass_options = [0, 1]

  89. 

  90.     for bypass in bypass_options:

  91.         for tile_h in range(h_max, k_h - 1, -s_h):

  92.             size_h = tile_h

  93.             if tile_h == h_max:

  94.                 w_range = range(w_max, k_w - 1, -s_w)

  95.                 size_h = in_h

  96.             else:

  97.                 w_range = [w_max]

  98.                 win_tile_h = (tile_h - k_h) // s_h + 1

  99.                 h_tiles = (win_h + win_tile_h - 1) // win_tile_h

  100.                 if h_tiles == 2:

  101.                     size_h = max(tile_h - p_top, in_h + p_top - tile_h + k_h - s_h)

  102. 

  103.             for tile_w in w_range:

  104.                 size_w = tile_w

  105.                 if size_w == w_max:

  106.                     size_w = in_w

  107.                 else:

  108.                     win_tile_w = (tile_w - k_w) // s_w + 1

  109.                     w_tiles = (win_w + win_tile_w - 1) // win_tile_w

  110.                     if w_tiles == 2:

  111.                         size_w = max(tile_w - p_left, in_w + p_left - tile_w + k_w - s_w)

  112. 

  113.                 k_n_ = ((k_n - 1) // 16 + 1) * 16

  114.                 co_range = range(k_n_, tile_co_start - 1, -16)

  115.                 for tile_co in co_range:

  116.                     if bypass == 1:

  117.                         if tile_co != k_n:

  118.                             continue

  119.                         l1_size = data_len * (size_h * size_w * in_c)

  120.                     else:

  121.                         l1_size = data_len * (size_h * size_w * in_c +

  122.                                               tile_co * tile_c * k_h * k_w)

  123. 

  124.                     if l1_size > l1_max_size:

  125.                         continue

  126. 

  127.                     tile_co_ = ((tile_co - 1) // 16 + 1) * 16

  128.                     for tile_n in range(tile_co_, 15, -16):

  129.                         k_max = in_c * k_h * k_w

  130.                         k_max_ = ((k_max - 1) // 16 + 1) * 16

  131.                         k_size = l0b_max_size // data_len // tile_n

  132.                         k_size_ = k_size // 16 * 16

  133.                         for tile_k in range(min(k_max_, k_size_), 15, -16):

  134.                             m_max = (int(((tile_h - k_h) // (s_h)) + 1)) * (int(((tile_w - k_w) // (s_w)) + 1))

  135.                             m_max_ = ((m_max - 1) // 16 + 1) * 16

  136.                             m_size1 = l0a_max_size // data_len // tile_k

  137.                             m_size1_ = m_size1 // 16 * 16

  138.                             m_size2 = l0c_max_size // data_len // tile_n

  139.                             m_size2_ = m_size2 // 16 * 16

  140.                             for tile_m in range(min(m_max_, m_size1_, m_size2_), 15, -16):

  141.                                 config_space.add(ConvConfig(tile_h, tile_co, tile_m, tile_k,

  142.                                                             tile_n, tile_w, bypass))

  143. 

  144.     return None, config_space, op_desc.__str__(), None, None

  145. 

  146. 

  147. def _get_space_conv_bn1(op_desc: ConvDesc, tunning_attrs):

  148.     """get config space of convolution"""

  149.     if not isinstance(op_desc, ConvDesc):

  150.         raise TypeError('op_desc must be ConvDesc')

  151. 

  152.     stride_ = op_desc.stride

  153.     pad_ = op_desc.pad

  154.     dilation_ = op_desc.dilation

  155.     vc_util.convolution_format_check(op_desc.fmap_shape, op_desc.filter_shape, pad_, stride_, dilation_)

  156.     config_space = ListConfigSpace(ConvConfig)

  157. 

  158.     # if double buff is not enabled, set it's value to 1

  159.     size_scale = 1

  160. 

  161.     l1_max_size = (1024 * 1024) // size_scale

  162.     l0a_max_size = (64 * 1024) // size_scale

  163.     l0b_max_size = (64 * 1024) // size_scale

  164.     l0c_max_size = ((256 - 8) * 1024) // size_scale // 2 // 4

  165. 

  166.     _, in_c, in_h, in_w = op_desc.fmap_shape

  167.     k_n, _, k_h, k_w = op_desc.filter_shape

  168.     padding = (pad_[0], pad_[1], pad_[2], pad_[3])

  169.     p_top, p_bottom, p_left, p_right = padding

  170.     s_h, s_w = stride_

  171. 

  172.     in_c = ((in_c - 1) // 16 + 1) * 16

  173.     tile_c = in_c

  174.     tile_co_start = 16

  175. 

  176.     data_len = 2

  177. 

  178.     h_max = in_h + p_top + p_bottom

  179.     win_h = (h_max - k_h) // s_h + 1

  180.     h_max = (h_max - k_h) // s_h * s_h + k_h

  181.     w_max = in_w + p_left + p_right

  182.     win_w = (w_max - k_w) // s_w + 1

  183.     w_max = (w_max - k_w) // s_w * s_w + k_w

  184. 

  185.     bypass_options = [0, 1]

  186. 

  187.     for bypass in bypass_options:

  188.         h_range = range(h_max, k_h - 1, -s_h)

  189.         for tile_h in h_range:

  190.             size_h = tile_h

  191.             if tile_h == h_max:

  192.                 w_range = range(w_max, k_w - 1, -s_w)

  193.                 size_h = in_h

  194.             else:

  195.                 w_range = [w_max]

  196.                 win_tile_h = (tile_h - k_h) // s_h + 1

  197.                 h_tiles = (win_h + win_tile_h - 1) // win_tile_h

  198.                 if h_tiles == 2:

  199.                     size_h = max(tile_h - p_top, in_h + p_top - tile_h + k_h - s_h)

  200. 

  201.             for tile_w in w_range:

  202.                 size_w = tile_w

  203.                 if size_w == w_max:

  204.                     size_w = in_w

  205.                 else:

  206.                     win_tile_w = (tile_w - k_w) // s_w + 1

  207.                     w_tiles = (win_w + win_tile_w - 1) // win_tile_w

  208.                     if w_tiles == 2:

  209.                         size_w = max(tile_w - p_left, in_w + p_left - tile_w + k_w - s_w)

  210. 

  211.                 k_n_ = ((k_n - 1) // 16 + 1) * 16

  212.                 co_range = range(k_n_, tile_co_start - 1, -16)

  213.                 for tile_co in co_range:

  214.                     if bypass == 1:

  215.                         if tile_co != k_n:

  216.                             continue

  217.                         l1_size = data_len * (size_h * size_w * in_c)

  218.                     else:

  219.                         l1_size = data_len * (size_h * size_w * in_c +

  220.                                               tile_co * tile_c * k_h * k_w)

  221. 

  222.                     if l1_size > l1_max_size:

  223.                         continue

  224. 

  225.                     tile_co_ = ((tile_co - 1) // 16 + 1) * 16

  226.                     for tile_n in range(tile_co_, 15, -16):

  227.                         k_max = in_c * k_h * k_w

  228.                         k_max_ = ((k_max - 1) // 16 + 1) * 16

  229.                         k_size = l0b_max_size // data_len // tile_n

  230.                         k_size_ = k_size // 16 * 16

  231.                         for tile_k in range(min(k_max_, k_size_), 15, -16):

  232.                             m_max = (int(((tile_h - k_h) // (s_h)) + 1)) * (int(((tile_w - k_w) // (s_w)) + 1))

  233.                             m_max_ = ((m_max - 1) // 16 + 1) * 16

  234.                             m_size1 = l0a_max_size // data_len // tile_k

  235.                             m_size1_ = m_size1 // 16 * 16

  236.                             m_size2 = l0c_max_size // data_len // tile_n

  237.                             m_size2_ = m_size2 // 16 * 16

  238.                             for tile_m in range(min(m_max_, m_size1_, m_size2_), 15, -16):

  239.                                 config_space.add(ConvConfig(tile_h, tile_co, tile_m, tile_k,

  240.                                                             tile_n, tile_w, bypass))

  241. 

  242.     return None, config_space, op_desc.__str__(), None, None

  243. 

  244. 

  245. def _get_space_conv_backprop_input(op_desc: ConvBackpropDesc, tunning_attrs):

  246.     """get config space of convolution backprop input"""

  247.     if not isinstance(op_desc, ConvBackpropDesc):

  248.         raise TypeError('op_desc must be ConvDesc')

  249. 

  250.     stride_ = op_desc.stride

  251.     pad_ = op_desc.pad

  252.     dilation_ = op_desc.dilation

  253.     vc_util.convolution_format_check(op_desc.fmap_shape, op_desc.filter_shape, pad_, stride_, dilation_)

  254.     config_space = ListConfigSpace(ConvBackpropInputConfig)

  255. 

  256.     # if double buff is not enabled, set it's value to 1

  257.     size_scale = 1

  258.     block_size = 16

  259. 

  260.     l1_max_size = (1024 * 1024) // size_scale

  261.     l0a_max_size = (64 * 1024) // size_scale

  262.     l0b_max_size = (64 * 1024) // size_scale

  263.     l0c_max_size = ((256 - 8) * 1024) // size_scale // 2

  264.     ub_max_size = l0c_max_size

  265. 

  266.     _, in_c, in_h, in_w = op_desc.fmap_shape

  267.     k_n, _, k_h, k_w = op_desc.filter_shape

  268. 

  269.     in_c = (in_c + block_size - 1) // block_size * block_size

  270.     k_n = (k_n + block_size - 1) // block_size * block_size

  271. 

  272.     pad_top, pad_bottom, pad_left, pad_right = pad_

  273.     stride_h, stride_w = stride_

  274. 

  275.     out_c = k_n

  276.     out_h = (in_h + pad_top + pad_bottom - k_h) // stride_h + 1

  277.     out_w = (in_w + pad_left + pad_right - k_w) // stride_w + 1

  278. 

  279.     out_h = out_h * stride_h

  280.     out_w = out_w * stride_w

  281. 

  282.     p_top = k_h - pad_[0] - 1

  283.     p_bottom = in_h + pad_[0] - stride_[0] * ((in_h + pad_[0] + pad_[1] - k_h) // stride_[0] + 1)

  284.     p_left = k_w - pad_[2] - 1

  285.     p_right = in_w + pad_[2] - stride_[1] * ((in_w + pad_[2] + pad_[3] - k_w) // stride_[1] + 1)

  286. 

  287.     s_h = 1

  288.     s_w = 1

  289. 

  290.     tile_c = out_c

  291.     tile_co_start = 16

  292. 

  293.     data_len = 2

  294. 

  295.     h_max = out_h + p_top + p_bottom

  296.     win_h = (h_max - k_h) // s_h + 1

  297.     h_max = (h_max - k_h) // s_h * s_h + k_h

  298.     w_max = out_w + p_left + p_right

  299.     win_w = (w_max - k_w) // s_w + 1

  300.     w_max = (w_max - k_w) // s_w * s_w + k_w

  301. 

  302.     for tile_h in range(h_max, k_h - 1, -s_h):

  303.         size_h = tile_h

  304.         if tile_h == h_max:

  305.             w_range = range(w_max, k_w - 1, -s_w)

  306.             size_h = in_h

  307.         else:

  308.             w_range = [w_max]

  309.             win_tile_h = (tile_h - k_h) // s_h + 1

  310.             h_tiles = (win_h + win_tile_h - 1) // win_tile_h

  311.             if h_tiles == 2:

  312.                 size_h = max(tile_h - p_top, in_h + p_top - tile_h + k_h - s_h)

  313. 

  314.         for tile_w in w_range:

  315.             size_w = tile_w

  316.             if size_w == w_max:

  317.                 size_w = in_w

  318.             else:

  319.                 win_tile_w = (tile_w - k_w) // s_w + 1

  320.                 w_tiles = (win_w + win_tile_w - 1) // win_tile_w

  321.                 if w_tiles == 2:

  322.                     size_w = max(tile_w - p_left, in_w + p_left - tile_w + k_w - s_w)

  323. 

  324.             k_n_ = ((k_n - 1) // 16 + 1) * 16

  325.             co_range = range(k_n_, tile_co_start - 1, -16)

  326.             for tile_co in co_range:

  327.                 l1_size = data_len * (size_h * size_w * out_c +

  328.                                       tile_co * tile_c * k_h * k_w)

  329.                 if l1_size > l1_max_size:

  330.                     continue

  331.                 ub_size = data_len * (size_h * size_w * out_c)

  332.                 if ub_size > ub_max_size:

  333.                     continue

  334. 

  335.                 tile_co_ = ((tile_co - 1) // 16 + 1) * 16

  336.                 for tile_n in range(tile_co_, 15, -16):

  337.                     k_max = out_c * k_h * k_w

  338.                     k_base = 16 * k_h * k_w

  339.                     k_max_ = ((k_max - 1) // k_base + 1) * k_base

  340.                     k_size = l0b_max_size // data_len // tile_n

  341.                     k_size_ = k_size // k_base * k_base

  342.                     for tile_k in range(min(k_max_, k_size_), k_base - 1, -k_base):

  343.                         m_max = (int(((tile_h - k_h) // (s_h)) + 1)) * (int(((tile_w - k_w) // (s_w)) + 1))

  344.                         m_max_ = ((m_max - 1) // 16 + 1) * 16

  345.                         m_size1 = l0a_max_size // data_len // tile_k

  346.                         m_size1_ = m_size1 // 16 * 16

  347.                         m_size2 = l0c_max_size // data_len // tile_n

  348.                         m_size2_ = m_size2 // 16 * 16

  349.                         for tile_m in range(min(m_max_, m_size1_, m_size2_), 15, -16):

  350.                             config_space.add(ConvBackpropInputConfig(tile_h, tile_co, tile_m,

  351.                                                                      tile_k, tile_n, tile_w))

  352.     return None, config_space, op_desc.__str__(), None, None

  353. 

  354. 

  355. def _get_space_conv_backprop_filter(op_desc: ConvBackpropDesc, tunning_attrs):

  356.     """get config space of convolution backwprop filter"""

  357.     if not isinstance(op_desc, ConvBackpropDesc):

  358.         raise TypeError('op_desc must be ConvBackpropDesc')

  359. 

  360.     stride_ = op_desc.stride

  361.     pad_ = op_desc.pad

  362.     dilation_ = op_desc.dilation

  363.     vc_util.convolution_format_check(op_desc.fmap_shape, op_desc.filter_shape, pad_, stride_, dilation_)

  364.     config_space = ListConfigSpace(ConvBackpropFilterConfig)

  365. 

  366.     # if double buff is not enabled, set it's value to 1

  367.     size_scale = 1

  368.     block_size = 16

  369. 

  370.     l1_max_size = (1024 * 1024) // size_scale

  371.     l0a_max_size = (64 * 1024) // size_scale

  372.     l0b_max_size = (64 * 1024) // size_scale

  373.     l0c_max_size = ((256 - 8) * 1024) // size_scale // 2

  374. 

  375.     in_n, in_c, in_h, in_w = op_desc.fmap_shape

  376.     cout, _, k_h, k_w = op_desc.filter_shape

  377.     k_n = cout

  378. 

  379.     in_c = (in_c + block_size - 1) // block_size * block_size

  380.     cout = (cout + block_size - 1) // block_size * block_size

  381. 

  382.     pad_top, pad_bottom, pad_left, pad_right = pad_

  383.     s_h, s_w = stride_

  384.     tile_co_start = 16

  385.     tile_ci_start = 16

  386.     data_len = 2

  387.     h_max = in_h + pad_top + pad_bottom

  388.     win_h = (h_max - k_h) // s_h + 1

  389.     h_max = (h_max - k_h) // s_h * s_h + k_h

  390.     w_max = in_w + pad_left + pad_right

  391.     win_w = (w_max - k_w) // s_w + 1

  392.     w_max = (w_max - k_w) // s_w * s_w + k_w

  393. 

  394.     for tile_h in range(h_max, k_h - 1, -s_h):

  395.         size_h = tile_h

  396.         win_tile_h = (tile_h - k_h) // s_h + 1

  397.         # Only one head for cut H axis

  398.         if win_tile_h * s_h < pad_top:

  399.             continue

  400.         # Only one tail for cut H axis

  401.         if (((win_h + win_tile_h - 1) // win_tile_h - 1) * win_tile_h - 1) * s_h + k_h > in_h + pad_top:

  402.             continue

  403.         if tile_h == h_max:

  404.             w_range = range(w_max, k_w - 1, -s_w)

  405.             size_h = in_h

  406.         else:

  407.             w_range = [w_max]

  408.             h_tiles = (win_h + win_tile_h - 1) // win_tile_h

  409.             if h_tiles == 2:

  410.                 size_h = max(tile_h - pad_top, in_h + pad_top - tile_h + k_h - s_h)

  411. 

  412.         for tile_w in w_range:

  413.             size_w = tile_w

  414.             win_tile_w = (tile_w - k_w) // s_w + 1

  415.             # Only one head for cut W axis

  416.             if win_tile_w * s_w < pad_left:

  417.                 continue

  418.             # Only one tail for cut W axis

  419.             if (((win_w + win_tile_w - 1) // win_tile_w - 1) * win_tile_w - 1) * s_w + k_w > in_w + pad_left:

  420.                 continue

  421.             if size_w == w_max:

  422.                 size_w = in_w

  423.             else:

  424.                 w_tiles = (win_w + win_tile_w - 1) // win_tile_w

  425.                 if w_tiles == 2:

  426.                     size_w = max(tile_w - pad_left, in_w + pad_left - tile_w + k_w - s_w)

  427.             for tile_kh in range(k_h, 0, -1):

  428.                 for tile_kw in range(k_w, 0, -1):

  429.                     k_n_ = ((k_n - 1) // 16 + 1) * 16

  430.                     co_range = range(k_n_, tile_co_start - 1, -16)

  431.                     for tile_co in co_range:

  432.                         in_c_ = ((in_c - 1) // 16 + 1) * 16

  433.                         ci_range = range(in_c_, tile_ci_start - 1, -16)

  434.                         for tile_ci in ci_range:

  435.                             tile_batch = 1

  436.                             l1_size = data_len * tile_batch * (tile_co * win_tile_h * win_tile_w +

  437.                                                                tile_ci * size_h * size_w)

  438.                             if l1_size > l1_max_size:

  439.                                 continue

  440. 

  441.                             if (tile_batch != in_n or tile_co != k_n_ or tile_ci != in_c_):

  442.                                 tile_m = tile_co

  443.                                 tile_n = tile_ci * tile_kh * tile_kw

  444.                                 l0c_size = data_len * tile_n * tile_m

  445.                                 if l0c_size > l0c_max_size:

  446.                                     continue

  447.                                 k_max = tile_batch * tile_h * tile_w

  448.                                 k_max_ = ((k_max - 1) // 16 + 1) * 16

  449.                                 k_size1 = l0a_max_size // data_len // tile_m

  450.                                 k_size1_ = k_size1 // 16 * 16

  451.                                 k_size2 = l0b_max_size // data_len // tile_n

  452.                                 k_size2_ = k_size2 // 16 * 16

  453.                                 for tile_k in range(min(k_max_, k_size1_, k_size2_), 15, -16):

  454.                                     config_space.add(ConvBackpropFilterConfig(tile_ci, tile_kh, tile_kw, tile_co,

  455.                                                                               tile_batch, tile_h, tile_w, tile_m,

  456.                                                                               tile_k, tile_n))

  457.                             else:

  458.                                 for tile_n in range(tile_ci * tile_kh * tile_kw, 15, -16):

  459.                                     k_max = tile_batch * tile_h * tile_w

  460.                                     k_max_ = ((k_max - 1) // 16 + 1) * 16

  461.                                     k_size = l0b_max_size // data_len // tile_n

  462.                                     k_size_ = k_size // 16 * 16

  463.                                     for tile_k in range(min(k_max_, k_size_), 15, -16):

  464.                                         m_max = tile_co

  465.                                         m_max_ = ((m_max - 1) // 16 + 1) * 16

  466.                                         m_size1 = l0a_max_size // data_len // tile_k

  467.                                         m_size1_ = m_size1 // 16 * 16

  468.                                         m_size2 = l0c_max_size // data_len // tile_n

  469.                                         m_size2_ = m_size2 // 16 * 16

  470.                                         for tile_m in range(min(m_max_, m_size1_, m_size2_), 15, -16):

  471.                                             config_space.add(ConvBackpropFilterConfig(tile_ci, tile_kh, tile_kw,

  472.                                                                                       tile_co, tile_batch, tile_h,

  473.                                                                                       tile_w, tile_m, tile_k, tile_n))

  474.     return None, config_space, op_desc.__str__(), None, None

  475. 

  476. def gen_bool_list(attr_list):

  477.     bool_list = []

  478.     for _ in attr_list:

  479.         if len(bool_list) == 0:

  480.             bool_list = [[True], [False]]

  481.         else:

  482.             tmp_list = []

  483.             for attr_option in bool_list:

  484.                 tmp = attr_option[:]

  485.                 tmp.append(True)

  486.                 tmp1 = tmp[:]

  487.                 tmp.pop()

  488.                 tmp.append(False)

  489.                 tmp2 = tmp[:]

  490.                 tmp_list.append(tmp1)

  491.                 tmp_list.append(tmp2)

  492.             bool_list = tmp_list

  493.     return bool_list

  494. 

  495. def _get_space_matmul_cube(op_desc: MatmulCubeDesc, tuning_attrs):

  496.     """get config space of matmul_cube"""

  497.     if not isinstance(op_desc, MatmulCubeDesc):

  498.         raise TypeError('op_desc must be MatmulCubeDesc')

  499.     config_attrs =  ['n_l1', 'n_l0', 'm_l1', 'm_l0', 'k_l1', 'k_l0', 'bypass']

  500.     config_attrs.extend(tuning_attrs)

  501.     MatmulCubeConfig = namedtuple('MatmulCubeConfig', config_attrs) 

  502.     config_space = ListConfigSpace(MatmulCubeConfig)

  503.     batch_tuple, m, k, n = matmul_run.extract_dim(op_desc.x_shape, op_desc.y_shape, op_desc.adj_x, op_desc.adj_y)

  504. 

  505.     mmax = (m + 15) // 16

  506.     nmax = (n + 15) // 16

  507.     kmax = (k + 15) // 16

  508. 

  509.     double_buffer = True

  510.     mad_fp32 = True

  511. 

  512.     l1_max_size  = (1024 * 1024)      # L1  MEM 1024KB

  513.     l0a_max_size = (64 * 1024)        # L0A MEM 64KB

  514.     l0b_max_size = (64 * 1024)        # L0B MEM 64KB

  515.     l0c_max_size = (256 * 1024)       # L0C MEM 256KB

  516.     ub_max_size  = ((256 - 8) * 1024) # UB  MEM 248KB, 8KB reserved for compiler

  517. 

  518.     if double_buffer:

  519.         l1_max_size = l1_max_size // 2

  520.         l0a_max_size = l0a_max_size // 2

  521.         l0b_max_size = l0b_max_size // 2

  522.         l0c_max_size = l0c_max_size // 2

  523.         ub_max_size = ub_max_size // 2

  524. 

  525.     if mad_fp32:

  526.         l0c_max_size = l0c_max_size // 2

  527.     if op_desc.out_dtype == 'float32':

  528.         ub_max_size = ub_max_size // 2

  529. 

  530.     bypass_options = [0, 1, 2]

  531. 

  532.     for bypass in bypass_options:

  533.         if (bypass == 2) and ((op_desc.adj_x == False and op_desc.left_format[0].lower() == 'n') or

  534.                               (op_desc.adj_x == True and op_desc.left_format[0].lower() == 'z')):

  535.             continue

  536. 

  537.         if (bypass == 1) and ((op_desc.adj_y == False and op_desc.right_format[0].lower() == 'z') or

  538.                               (op_desc.adj_y == True and op_desc.right_format[0].lower() == 'n')):

  539.             continue

  540. 

  541.         for k_l1 in range(1, kmax + 1):

  542.             if kmax % k_l1 != 0:

  543.                 continue

  544.             for k_l0 in range(1, k_l1 + 1):

  545.                 if k_l1 % k_l0 != 0:

  546.                     continue

  547. 

  548.                 # no need to cut from l1 to l0 for m and n when k is cut

  549.                 for m_l1 in range(1, mmax + 1):

  550.                     if mmax % m_l1 != 0:

  551.                         continue

  552.                     m_l0_range = [m_l1] if k_l1 != kmax else range(1, m_l1 + 1)

  553.                     for m_l0 in m_l0_range:

  554.                         if m_l1 % m_l0 != 0:

  555.                             continue

  556.                         for n_l1 in range(1, nmax + 1):

  557.                             if nmax % n_l1 != 0:

  558.                                 continue

  559.                             n_l0_range = [n_l1] if k_l1 != kmax else range(1, n_l1 + 1)

  560.                             for n_l0 in n_l0_range:

  561.                                 if n_l1 % n_l0 != 0:

  562.                                     continue

  563. 

  564.                                 if m_l0 * 16 * k_l0 * 16 > l0a_max_size:

  565.                                     continue

  566. 

  567.                                 if n_l0 * 16 * k_l0 * 16 > l0b_max_size:

  568.                                     continue

  569. 

  570.                                 if m_l0 * 16 * n_l0 * 16 > l0c_max_size:

  571.                                     continue

  572. 

  573.                                 if m_l0 * 16 * n_l0 * 16 > ub_max_size:

  574.                                     continue

  575. 

  576.                                 if bypass == 2:

  577.                                     l1_size = n_l1 * 16 * k_l1 * 16

  578.                                 elif bypass == 1:

  579.                                     l1_size = m_l1 * 16 * k_l1 * 16

  580.                                 else:

  581.                                     l1_size = (m_l1 * 16 + n_l1 * 16) * k_l1 * 16

  582.                                 if l1_size > l1_max_size:

  583.                                     continue

  584. 

  585.                                 if nmax == 1:

  586.                                     n_l1 = 0

  587.                                     n_l0 = 0

  588.                                 if mmax == 1:

  589.                                     m_l1 = 0

  590.                                     m_l0 = 0

  591.                                 if kmax == 1:

  592.                                     k_l1 = 16

  593.                                     k_l0 = 16

  594.                                 tiling_space = [n_l1, n_l0, m_l1, m_l0, k_l1, k_l0, bypass]

  595.                                 if len(tuning_attrs) == 0:

  596.                                     config_space.add(MatmulCubeConfig(*tiling_space))

  597.                                 else:

  598.                                     attr_options = gen_bool_list(tuning_attrs)

  599.                                     for attr_option in attr_options:

  600.                                         tmp = tiling_space[:]

  601.                                         tmp.extend(attr_option)

  602.                                         config = MatmulCubeConfig(*tmp)

  603.                                         config_space.add(config)

  604.     shape_xx, shape_yy, _, _, k = matmul_run.get_converted_shapes(m, n, k, batch_tuple, op_desc.adj_x, op_desc.adj_y,

  605.                                                                   op_desc.bias, op_desc.left_format,

  606.                                                                   op_desc.right_format, op_desc.out_format)

  607.     return None, config_space, str((shape_xx, shape_yy, op_desc.bias, op_desc.left_format, op_desc.right_format,

  608.                                     op_desc.out_format, op_desc.adj_x, op_desc.adj_y, op_desc.dtype,

  609.                                     op_desc.out_dtype)), None, None

  610. 

  611. 

  612. _get_space_func = {

  613.     'conv': _get_space_conv,

  614.     'conv_bn1': _get_space_conv_bn1,

  615.     'conv_backprop_input': _get_space_conv_backprop_input,

  616.     'conv_backprop_filter': _get_space_conv_backprop_filter,

  617.     'matmul': _get_space_matmul_cube,

  618. }

  619. 

  620. 

  621. def get_space(op_type: str, op_desc: NamedTuple, tuning_attrs=[]):

  622.     """get space of an operator"""

  623.     func = _get_space_func.get(op_type, None)

  624.     if func is None:

  625.         func = partial(_get_space_vector, op_type=op_type)

  626.     return func(op_desc=op_desc, tuning_attrs=tuning_attrs)