code: def dense_compute(tensor_a, tensor_b, bias=None, out_dtype=None):
      """Hexagon's implementation of a sliced dense operator in Topi.
      Uses matmul.
  
      Parameters
      ----------
      tensor_a : tvm.te.Tensor
          data 2-D with shape [batch, in_dim]
  
      tensor_b : tvm.te.Tensor
          weight 2-D with shape [in_dim, out_dim]
  
      bias : Optional[tvm.te.Tensor]
          1-D with shape [out_dim]
  
      out_dtype : Optional[str]
          The output type. This is used for mixed precision.
  
      Returns
      -------
      output : tvm.te.Tensor
          2-D with shape [batch, out_dim]
  
      """
      if bias is not None:
          assert len(bias.shape) == 1
      if out_dtype is None:
          out_dtype = tensor_a.dtype
  
      batch, in_dim = tensor_a.shape
      out_dim, red_dim = tensor_b.shape
  
      # cmp should be done by values
      assert int(in_dim) == int(red_dim)
  
      k = te.reduce_axis((0, in_dim), name="k")
      compute_lambda = lambda n, m: te.sum(
          tensor_a[n, k].astype(out_dtype)
          * tensor_b[k, m].astype(out_dtype),
          axis=k,
      )
      compute_name = "matmul_sliced"
      compute_tag = "matmul"
  
      mat = te.compute(
          (batch, out_dim),
          compute_lambda,
          name=compute_name,
          tag=compute_tag,
          attrs={"layout_free_placeholders": [tensor_b]},
      )
  
      if bias is not None:
          mat = te.compute(
              (batch, out_dim),
              lambda i, j: mat[i, j] + bias[j],
              tag=tag.BROADCAST,
              name="bias",
          )
  
      return mat
  
imports: from tvm import te, tir
  from tvm.topi import tag
  from ..utils import get_layout_transform_fn
label_desc: Use image node_id 1 for calling a global function with example usage: dense_compute(tensor_a, tensor_b, bias, out_dtype) and returns: mat