code: def test_two_elementwise_blockize_reverse_compute_at():
      @T.prim_func
      def before_blockize_rca(
          A: T.Buffer((128, 128), "float32"),
          C: T.Buffer((128, 128), "float32"),
      ) -> None:
          B = T.alloc_buffer([128, 128], dtype="float32")
          for i, j in T.grid(8, 8):
              with T.block("B_o"):
                  vi, vj = T.axis.remap("SS", [i, j])
                  T.reads(
                      A[vi * 16 : vi * 16 + 16, vj * 16 : vj * 16 + 16]
                  )
                  T.writes(
                      B[vi * 16 : vi * 16 + 16, vj * 16 : vj * 16 + 16]
                  )
                  for i_1, j_1 in T.grid(16, 16):
                      with T.block("B"):
                          vi_i, vj_i = T.axis.remap("SS", [i_1, j_1])
                          T.reads(A[vi * 16 + vi_i, vj * 16 + vj_i])
                          T.writes(B[vi * 16 + vi_i, vj * 16 + vj_i])
                          B[vi * 16 + vi_i, vj * 16 + vj_i] = (
                              A[vi * 16 + vi_i, vj * 16 + vj_i] * 2.0
                          )
              for ax0, ax1 in T.grid(16, 16):
                  with T.block("C"):
                      vi = T.axis.spatial(128, i * 16 + ax0)
                      vj = T.axis.spatial(128, j * 16 + ax1)
                      T.reads(B[vi, vj])
                      T.writes(C[vi, vj])
                      C[vi, vj] = B[vi, vj] + 1.0
  
      @T.prim_func
      def after_blockize_rca(
          A: T.Buffer((128, 128), "float32"),
          C: T.Buffer((128, 128), "float32"),
      ) -> None:
          B = T.alloc_buffer([128, 128], dtype="float32")
          for i, j in T.grid(8, 8):
              with T.block("B_o"):
                  vi, vj = T.axis.remap("SS", [i, j])
                  T.reads(
                      A[vi * 16 : vi * 16 + 16, vj * 16 : vj * 16 + 16]
                  )
                  T.writes(
                      B[vi * 16 : vi * 16 + 16, vj * 16 : vj * 16 + 16]
                  )
                  for i_1, j_1 in T.grid(16, 16):
                      with T.block("B"):
                          vi_i, vj_i = T.axis.remap("SS", [i_1, j_1])
                          T.reads(A[vi * 16 + vi_i, vj * 16 + vj_i])
                          T.writes(B[vi * 16 + vi_i, vj * 16 + vj_i])
                          B[vi * 16 + vi_i, vj * 16 + vj_i] = (
                              A[vi * 16 + vi_i, vj * 16 + vj_i] * 2.0
                          )
              with T.block("C_o"):
                  vi, vj = T.axis.remap("SS", [i, j])
                  T.reads(
                      B[vi * 16 : vi * 16 + 16, vj * 16 : vj * 16 + 16]
                  )
                  T.writes(
                      C[vi * 16 : vi * 16 + 16, vj * 16 : vj * 16 + 16]
                  )
                  for ax0, ax1 in T.grid(16, 16):
                      with T.block("C"):
                          vi_i, vj_i = T.axis.remap("SS", [ax0, ax1])
                          T.reads(B[vi * 16 + vi_i, vj * 16 + vj_i])
                          T.writes(C[vi * 16 + vi_i, vj * 16 + vj_i])
                          C[vi * 16 + vi_i, vj * 16 + vj_i] = (
                              B[vi * 16 + vi_i, vj * 16 + vj_i] + 1.0
                          )
  
      func = before_blockize_rca
      s = tir.Schedule(func, debug_mask="all")
      _, _, x, _ = s.get_loops(s.get_block("C"))
      s.blockize(x)
      tvm.ir.assert_structural_equal(
          s.mod["main"],
          after_blockize_rca.with_attr(
              "global_symbol", "before_blockize_rca"
          ),
      )
      verify_trace_roundtrip(sch=s, mod=func)
  
file_path: tvm/tests/python/tir-schedule/test_tir_schedule_blockize.py
imports: import tvm
  import tvm.testing
  from tvm import tir
  from tvm.script import tir
  from tvm.tir.schedule.testing import verify_trace_roundtrip
  import pytest
label_desc: Use image node_id 4 for calling a global function with example usage: test_two_elementwise_blockize_reverse_compute_at() without return types