code: def dense_si(data, indices, indptr, weight, bias=None):
      # pylint: disable=invalid-name
      """The implementation of dense in topi, assuming sparse input.
  
      Parameters
      ----------
      data : tvm.te.Tensor
          1-D with shape [num_nonzeros]
  
      indices : tvm.te.Tensor
          1-D with shape [num_nonzeros]
  
      indptr : tvm.te.Tensor
          1-D with shape [m+1]
  
      weight : tvm.te.Tensor
          2-D with shape [k, n]
  
      bias : tvm.te.Tensor, optional
          1-D with shape [m]
  
      Returns
      -------
      output : tvm.te.Tensor
          2-D with shape [m, n]
      """
      assert (
          len(data.shape) == 1
          and len(indices.shape) == 1
          and len(indptr.shape) == 1
          and len(weight.shape) == 2
      ), "only support 2-dim dense"
      assert isinstance(
          weight, te.tensor.Tensor
      ), f"weight matrix is assumed to be tvm.te.Tensor, but weight is `{type(weight)}`"
      if bias is not None:
          assert len(bias.shape) == 1
      dtype = data.dtype
      M = simplify(indptr.shape[0] - 1)
      N, _ = weight.shape
  
      def dense_default_ir(data, indices, indptr, weight, out):
          """Define IR for Dense"""
          dtype = data.dtype
          irb = tvm.tir.ir_builder.create()
          data_ptr = irb.buffer_ptr(data)
          indices_ptr = irb.buffer_ptr(indices)
          indptr_ptr = irb.buffer_ptr(indptr)
          weight_ptr = irb.buffer_ptr(weight)
          out_ptr = irb.buffer_ptr(out)
          M = simplify(indptr.shape[0] - 1)
          N, K = weight.shape
          with irb.for_range(0, N, kind="vectorize", name="n") as n:
              with irb.for_range(0, M, kind="parallel", name="m") as m:
                  dot = irb.allocate(
                      dtype, (1,), name="dot", scope="local"
                  )
                  out_ptr[m * N + n] = tvm.tir.const(0, dtype)
                  dot[0] = tvm.tir.const(0, dtype)
                  row_start = indptr_ptr[m]
                  row_elems = indptr_ptr[m + 1] - row_start
                  with irb.for_range(0, row_elems, name="k") as k:
                      elem = row_start + k
                      dot[0] += (
                          data_ptr[elem]
                          * weight_ptr[indices_ptr[elem] + n * K]
                      )
                  out_ptr[m * N + n] += dot[0]
          return irb.get()
  
      oshape = (M, N)
      matmul = te.extern(
          oshape,
          [data, indices, indptr, weight],
          lambda ins, outs: dense_default_ir(
              ins[0], ins[1], ins[2], ins[3], outs[0]
          ),
          tag="dense",
          dtype=dtype,
          name="out",
      )
      if bias is not None:
          matmul = te.compute(
              oshape,
              lambda i, j: matmul[i, j] + bias[j],
              tag=tag.BROADCAST,
          )
      return matmul
  
file_path: tvm/python/tvm/topi/sparse/dense.py
imports: from __future__ import absolute_import
  import tvm
  from tvm import te
  from ..None import tag
  from ..utils import simplify
label_desc: Use image node_id 1 for calling a global function with example usage: dense_si(data, indices, indptr, weight, bias) and returns: matmul, irb