code: def test_decompose_hw_padding_non_perfect_tiled():
      """Case 3. non-perfect tiling and then decompose"""
  
      @T.prim_func
      def pooling_decompose_3(
          x: T.Buffer((1, 16, 225, 225), "int8"),
          tensor: T.Buffer((1, 16, 225, 225), "int8"),
      ) -> None:
          pad_temp = T.alloc_buffer([1, 16, 231, 231], dtype="int8")
          for i0, i2_0, i3_0 in T.grid(1, 3, 3):
              for ax0, ax1, ax2 in T.grid(16, 86, 86):
                  with T.block("pad_temp_pad_const"):
                      ax0_1 = T.axis.spatial(1, 0)
                      ax1_1 = T.axis.spatial(16, ax0)
                      ax2_1 = T.axis.spatial(231, i2_0 * 80 + ax1)
                      ax3 = T.axis.spatial(231, i3_0 * 80 + ax2)
                      T.where(
                          i2_0 * 80 + ax1 < 231
                          and i3_0 * 80 + ax2 < 231
                      )
                      T.reads()
                      T.writes(pad_temp[ax0_1, ax1_1, ax2_1, ax3])
                      pad_temp[ax0_1, ax1_1, ax2_1, ax3] = T.int8(0)
              for ax0, ax1, ax2 in T.grid(16, 86, 86):
                  with T.block("pad_temp"):
                      ax0_2 = T.axis.spatial(1, 0)
                      ax1_2 = T.axis.spatial(16, ax0)
                      ax2_2 = T.axis.spatial(225, i2_0 * 80 + ax1 - 3)
                      ax3 = T.axis.spatial(225, i3_0 * 80 + ax2 - 3)
                      T.where(
                          3 <= i2_0 * 80 + ax1
                          and i2_0 * 80 + ax1 < 228
                          and 3 <= i3_0 * 80 + ax2
                          and i3_0 * 80 + ax2 < 228
                          and i2_0 * 80 + ax1 < 231
                          and i3_0 * 80 + ax2 < 231
                      )
                      T.reads(x[ax0_2, ax1_2, ax2_2, ax3])
                      T.writes(
                          pad_temp[ax0_2, ax1_2, ax2_2 + 3, ax3 + 3]
                      )
                      pad_temp[ax0_2, ax1_2, ax2_2 + 3, ax3 + 3] = x[
                          ax0_2, ax1_2, ax2_2, ax3
                      ]
              for i1, i2_1, i3_1, i4, i5 in T.grid(16, 80, 80, 7, 7):
                  with T.block("tensor"):
                      ax0_3, ax1_3 = T.axis.remap("SS", [i0, i1])
                      ax2_3 = T.axis.spatial(225, i2_0 * 80 + i2_1)
                      ax3 = T.axis.spatial(225, i3_0 * 80 + i3_1)
                      rv0, rv1 = T.axis.remap("RR", [i4, i5])
                      T.where(
                          i2_0 * 80 + i2_1 < 225
                          and i3_0 * 80 + i3_1 < 225
                      )
                      T.reads(
                          pad_temp[ax0_3, ax1_3, ax2_3 + rv0, ax3 + rv1]
                      )
                      T.writes(tensor[ax0_3, ax1_3, ax2_3, ax3])
                      with T.init():
                          tensor[ax0_3, ax1_3, ax2_3, ax3] = T.int8(0)
                      tensor[ax0_3, ax1_3, ax2_3, ax3] = (
                          tensor[ax0_3, ax1_3, ax2_3, ax3]
                          + pad_temp[
                              ax0_3, ax1_3, ax2_3 + rv0, ax3 + rv1
                          ]
                      )
  
      sch = tir.Schedule(sum_pool_2d, debug_mask="all")
      block = sch.get_block("tensor")
      pad = sch.get_block("pad_temp")
      n, c, h, w, kh, kw = sch.get_loops(block)
      ho, hi = sch.split(h, [None, 80])
      wo, wi = sch.split(w, [None, 80])
      sch.reorder(n, ho, wo, c, hi, wi, kh, kw)
      sch.compute_at(sch.get_block("pad_temp"), wo)
      sch.decompose_padding(pad, sch.get_loops(pad)[3])
      check_decompose_padding(
          sum_pool_2d,
          sch.mod["main"],
          pooling_decompose_3,
          check_run=True,
      )
  
file_path: tvm/tests/python/tir-schedule/test_tir_schedule_decompose_padding.py
imports: import numpy
  import tvm
  import tvm.testing
  from tvm import tir
  from tvm.tir.schedule.testing import assert_structural_equal_ignore_global_symbol
  from tvm.script import tir
label_desc: Use image node_id 8 for calling a global function with example usage: test_decompose_hw_padding_non_perfect_tiled() without return types