code: def test_dense_add_cpu():
      def apply_anchor_trace(sch: Schedule) -> None:
          b0 = sch.get_block(name="T_matmul_NT", func_name="main")
          b1 = sch.get_block(name="root", func_name="main")
          sch.annotate(
              block_or_loop=b0,
              ann_key="meta_schedule.tiling_structure",
              ann_val="SSRSRS",
          )
          l2, l3, l4 = sch.get_loops(block=b0)
          v5, v6, v7, v8 = sch.sample_perfect_tile(
              loop=l2,
              n=4,
              max_innermost_factor=64,
              decision=[2, 8, 4, 2],
          )
          l9, l10, l11, l12 = sch.split(
              loop=l2,
              factors=[v5, v6, v7, v8],
              preserve_unit_iters=True,
          )
          v13, v14, v15, v16 = sch.sample_perfect_tile(
              loop=l3,
              n=4,
              max_innermost_factor=64,
              decision=[2, 1, 1, 64],
          )
          l17, l18, l19, l20 = sch.split(
              loop=l3,
              factors=[v13, v14, v15, v16],
              preserve_unit_iters=True,
          )
          v21, v22 = sch.sample_perfect_tile(
              loop=l4, n=2, max_innermost_factor=64, decision=[128, 1]
          )
          l23, l24 = sch.split(
              loop=l4, factors=[v21, v22], preserve_unit_iters=True
          )
          sch.reorder(l9, l17, l10, l18, l23, l11, l19, l24, l12, l20)
          b25 = sch.cache_write(
              block=b0, write_buffer_index=0, storage_scope="global"
          )
          sch.reverse_compute_at(
              block=b25, loop=l17, preserve_unit_loops=True, index=-1
          )
          sch.annotate(
              block_or_loop=b1,
              ann_key="meta_schedule.parallel",
              ann_val=160,
          )
          sch.annotate(
              block_or_loop=b1,
              ann_key="meta_schedule.vectorize",
              ann_val=64,
          )
          v26 = sch.sample_categorical(
              candidates=[0, 16, 64, 512],
              probs=[0.25, 0.25, 0.25, 0.25],
              decision=0,
          )
          sch.annotate(
              block_or_loop=b1,
              ann_key="meta_schedule.unroll_explicit",
              ann_val=v26,
          )
          sch.enter_postproc()
          b27 = sch.get_block(name="root", func_name="main")
          sch.unannotate(
              block_or_loop=b27, ann_key="meta_schedule.parallel"
          )
          sch.unannotate(
              block_or_loop=b27, ann_key="meta_schedule.vectorize"
          )
          sch.unannotate(
              block_or_loop=b27, ann_key="meta_schedule.unroll_explicit"
          )
          b28, b29 = sch.get_child_blocks(b27)
          (
              l30,
              l31,
              l32,
              l33,
              l34,
              l35,
              l36,
              l37,
              l38,
              l39,
          ) = sch.get_loops(block=b28)
          l40 = sch.fuse(l30, l31, preserve_unit_iters=True)
          sch.parallel(loop=l40)
          l41 = sch.fuse(l39, preserve_unit_iters=True)
          sch.vectorize(loop=l41)
          l42, l43, l44 = sch.get_loops(block=b29)
          l45 = sch.fuse(l42, preserve_unit_iters=True)
          sch.parallel(loop=l45)
          l46 = sch.fuse(l44, preserve_unit_iters=True)
          sch.vectorize(loop=l46)
          b47 = sch.get_block(name="T_matmul_NT", func_name="main")
          l48, l49, l50, l51, l52, l53, l54, l55, l56 = sch.get_loops(
              block=b47
          )
          b57 = sch.decompose_reduction(block=b47, loop=l51)
          b58 = sch.get_block(
              name="T_matmul_NT_update", func_name="main"
          )
          b59 = sch.cache_read(
              block=b58, read_buffer_index=2, storage_scope="global"
          )
          sch.transform_layout(
              block=b58,
              buffer=("read", 2),
              index_map=tvm.tir.IndexMap.from_func(
                  lambda i0, i1: (
                      floordiv(i0, 64),
                      i1,
                      floormod(i0, 64),
                  ),
                  inverse_index_map=lambda i0, i1, i2: (
                      ((i0 * 64) + i2),
                      i1,
                  ),
                  index_dtype="int32",
              ),
              pad_value=None,
          )
          sch.annotate(
              block_or_loop=b59,
              ann_key="meta_schedule.layout_rewrite_preproc",
              ann_val=1,
          )
  
      verify(
          Dense,
          apply_anchor_trace,
          DenseAdd,
          "llvm",
          DenseAdd_scheduled_cpu,
      )
  
imports: import pytest
  import tvm
  import tvm.meta_schedule
  import tvm.testing
  from tvm.script import tir
  from tvm.target import Target
  from tvm.target.codegen import llvm_lookup_intrinsic_id
  from tvm.tir import Schedule, floordiv, floormod
  from tvm.tir.tensor_intrin.cuda import *
  from tvm.tir.tensor_intrin.x86 import VNNI_DOT_16x4_INTRIN
label_desc: Use image node_id 3 for calling a global function with example usage: test_dense_add_cpu() without return types