code: def test_vrmpy_dense_auto_tensorize(hexagon_launcher):
      """Test VRMPY dense operator."""
      if hexagon_launcher.is_simulator():
          pytest.skip(msg="Tuning on simulator not supported.")
  
      m_size, n_size, k_size = 128, 768, 768
      workload = te.create_prim_func(
          dense_compute(m_size, n_size, k_size)
      )
  
      sch_rules = [
          schedule_rule.MultiLevelTilingWithIntrin(
              VRMPY_u8u8i32_INTRIN,
              structure="SRSRS",
              tile_binds=None,
              max_innermost_factor=64,
              vector_load_lens=None,
              reuse_read=None,
              reuse_write=schedule_rule.ReuseType(
                  req="may",
                  levels=[1, 2],
                  scope="global",
              ),
          ),
          schedule_rule.ParallelizeVectorizeUnroll(
              max_jobs_per_core=16,
              max_vectorize_extent=128,
              unroll_max_steps=[0, 16, 64, 512],
              unroll_explicit=True,
          ),
      ]
  
      postprocs = [
          postproc.RewriteParallelVectorizeUnroll(),
          postproc.RewriteReductionBlock(),
          postproc.RewriteTensorize(vectorize_init_loop=True),
      ]
  
      # Make this to False to compile and run the best tuned schedule
      run_tuning = True
      if run_tuning:
          with tempfile.TemporaryDirectory() as work_dir:
              target = get_hexagon_target("v68")
              database = ms.tir_integration.tune_tir(
                  mod=workload,
                  target=target,
                  max_trials_global=8,
                  num_trials_per_iter=8,
                  work_dir=work_dir,
                  space=ms.space_generator.PostOrderApply(
                      f_block_filter=None,
                      sch_rules=sch_rules,
                      postprocs=postprocs,
                      mutator_probs={},
                  ),
                  builder=get_hexagon_local_builder(),
                  runner=get_hexagon_rpc_runner(
                      hexagon_launcher, number=10
                  ),
              )
              sch = ms.tir_integration.compile_tir(
                  database, workload, target
              )
      else:
          sch = tvm.tir.Schedule(
              ModuleVRMPYAutoTensorize, debug_mask="all"
          )
  
      with hexagon_launcher.create_session() as session:
          verify_dense(
              sch,
              get_hexagon_target("v68"),
              m_size,
              n_size,
              k_size,
              session,
          )
  
imports: import tempfile
  import numpy
  import pytest
  import tvm.testing
  import tvm.topi.testing
  from tvm import meta_schedule
  from tvm import relay, te
  from tvm.contrib.hexagon.meta_schedule import get_hexagon_local_builder, get_hexagon_rpc_runner
  from tvm.meta_schedule import postproc, schedule_rule
  from tvm.meta_schedule.arg_info import TensorInfo
  from tvm.meta_schedule.builder import BuilderInput
  from tvm.meta_schedule.runner import RunnerInput
  from tvm.script import tir
  from tvm.tir import FloatImm
  from tvm.tir.tensor_intrin.hexagon import VRMPY_u8u8i32_INTRIN
  from .infrastructure import get_hexagon_target
label_desc: Use image node_id 6 for calling a global function with example usage: test_vrmpy_dense_auto_tensorize(hexagon_launcher) without return types