code: def get_tiling_B_transformed(interleave_A, in_dtype):
      """Compute the tiling information for matrix B', where B'
      is the tiled, interleaved (and transposed) version of matrix B in C=A*B.
  
      The tiling information is chosen to maximize register usage during the
      tile computation.
  
      Please refer to:
      - https://discuss.tvm.apache.org/t/rfc-improve-quantized-convolution-performance-for-armv8-architectures # pylint: disable=line-too-long
      - https://discuss.tvm.apache.org/t/rfc-accelerate-quantized-convolution-through-dot-product
      - https://discuss.tvm.apache.org/t/rfc-improve-quantized-convolution-through-mmla-instruction
      - Conv2DGemmWeightTransformRel in src/relay/op/nn/convolution.h
       In order to have more information
  
      Parameters
      ----------
      interleave_A : bool
          determines if A is expected to be interleaved
      in_dtype : str
          input datatype
  
  
      Returns
      ----------
      tile_N: the output tile size of B' on N axis (N = OC)
      tile_K: the output tile size of B' on K axis (K = KW * KH * IC)
      """
      target = Target.current(allow_none=False)
      if in_dtype in ["int8", "uint8"]:
          if target.features.has_matmul_i8:
              # If smmla/ummla is available,  A must be interleaved.
              # Each load from B' will contain 8 elements
              # and we are loading 12 rows of B' (i.e., 12 columns of B)
              tile_N = 12
              tile_K = 8
          elif target.features.has_dotprod:
              # The number of tile rows of B' vary depending on the
              # strategy:
              # * If we are interleaving A, then we select 12 columns from B'(i.e.,
              #   12 rows from B).
              # * If we are not interleaving A, then we select 16 columns from B'(i.e.,
              #   16 rows from B).
              tile_N = 12 if interleave_A else 16
  
              # Dot product instruction groups 2 (u)int16x8 vectors in
              # groups of 4 and compute the dot product among those groups
              # This means that the number of columns in a tile of B' (i.e.,  the
              # rows of the original matrix B)  need to be 4.
              tile_K = 4
          else:
              # If no acceleration is available, A must be interleaved. In this case
              # we load 4 rows of B' (i.e., 4 columns of B). Each of them will contain 16 elements
              tile_N = 4
              tile_K = 16
      # In non-quantized cases, A is not interleaved.
      elif in_dtype == "float16" and target.features.has_fp16_simd:
          # Each load from B' contains 32 elements (i.e. 32 columns from B)
          # We are loading 4 rows from B', in the dimension of reduction (i.e. 4 rows from B)
          tile_N = 32
          tile_K = 4
      else:
          # Each load from B' contains 16 elements (i.e. 16 columns from B)
          # We are loading 4 rows from B', in the dimension of reduction (i.e. 4 rows from B)
          tile_N = 16
          tile_K = 4
  
      return tile_N, tile_K
  
label_desc: Use image node_id 1 for calling a global function with example usage: get_tiling_B_transformed(interleave_A, in_dtype) and returns: tile_N,  tile_K