code: def verify_dense(
      sch, target, m_size, n_size, k_size, hexagon_session
  ):
      """Verify dense operator."""
      f = tvm.build(sch.mod["main"], target=target, name="dense")
      mod = hexagon_session.load_module(f)
      dev = hexagon_session.device
  
      a_np = np.random.uniform(1, 10, size=(m_size, k_size)).astype(
          "uint8"
      )
      b_np = np.random.uniform(1, 10, size=(n_size, k_size)).astype(
          "uint8"
      )
      c_np = np.dot(
          a_np.astype("int32"), b_np.transpose().astype("int32")
      )
  
      pack_width = np.random.uniform(
          1, 10, size=(n_size // 32, (k_size // 4), 32, 4)
      ).astype("uint8")
  
      for r_idx in range(n_size // 32):
          for k_output in range(k_size // 4):
              for s_idx in range(32):
                  for t_idx in range(4):
                      pack_width[r_idx][k_output][s_idx][t_idx] = b_np[
                          r_idx * 32 + s_idx
                      ][k_output * 4 + t_idx]
  
      a = tvm.nd.array(a_np, dev)
      b = tvm.nd.array(pack_width, dev)
      c = tvm.nd.array(np.zeros((m_size, n_size), dtype="int32"), dev)
  
      mod(a, b, c)
      np.testing.assert_equal(c.numpy(), c_np)
  
      evaluator = mod.time_evaluator(mod.entry_name, dev, number=10)
      gflops = (n_size * m_size * k_size) * 2 / 1e9
      time_ms = evaluator(a, b, c).mean * 1e3
      print("%f ms, %f GOPS" % (time_ms, gflops / (time_ms / 1e3)))
  
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 4 for calling a global function with example usage: verify_dense(sch, target, m_size, n_size, k_size, hexagon_session) without return types