[mlir][benchmark] Fix import in sparse benchmark.

[ingomueller-net]

Summary

The benchmark currently fails to run because it cannot find the func
symbol when using a FuncOp. I suppose that the breakage was introduced
by the extraction of the func dialect from the builtin dialect that
wasn't reflected in the benchmark yet.

[ingomueller-net]

Hold on, I am not sure whether this fixes all problems :S

[ingomueller-net]

Updating D129738: [mlir][benchmark] Fix import in sparse benchmark.

The update also fixes problems in common.py, which I had not seen
previously. Those must have been introduced in an attempt to port the
file to the new organization of the func dialect, but that attempt
introduced a name clash on the name func.

Also, the benchmark only runs with the following work-around, which I
assume to be a bug in the python bindings of BlockArgumentList:

patch
diff --git a/mlir/benchmark/python/common.py b/mlir/benchmark/python/common.py
index 3d80892b0fb8..864b456fe817 100644
--- a/mlir/benchmark/python/common.py
+++ b/mlir/benchmark/python/common.py
@@ -94,10 +94,9 @@ def emit_benchmark_wrapped_main_func(kernel_func, timer_func):
         loop = scf.ForOp(zero, n_iterations, one, iter_args)
         with ir.InsertionPoint(loop.body):
             start = func.CallOp(timer_func, [])
-            call = func.CallOp(
-                kernel_func,
-                wrapped_func.arguments[:-num_results - 1] + loop.inner_iter_args
-            )
+            args = [a for a in wrapped_func.arguments[:-num_results - 1]] + \
+                [a for a in loop.inner_iter_args]
+            call = func.CallOp(kernel_func, args)
             end = func.CallOp(timer_func, [])
             time_taken = arith.SubIOp(end, start)
             memref.StoreOp(time_taken, timer_buffer, [loop.induction_variable])

[aartbik]

Thanks for fixing. At the moment, this code is not look at by many but I plan to change that. It explains why nobody had seen this yet ;-)

mlir/benchmark/python/benchmark_sparse.py

 """This file contains benchmarks for sparse tensors. In particular, it
 contains benchmarks for both mlir sparse tensor dialect and numpy so that they
 can be compared against each other.
 """
 import ctypes
 import numpy as np
 import os
 import re
 import time
 
 from mlir import ir
 from mlir import runtime as rt
-from mlir.dialects import builtin
+from mlir.dialects import func
 from mlir.dialects.linalg.opdsl import lang as dsl
 from mlir.execution_engine import ExecutionEngine
 
 from common import create_sparse_np_tensor
 from common import emit_timer_func
 from common import emit_benchmark_wrapped_main_func
 from common import get_kernel_func_from_module
 from common import setup_passes

mlir/benchmark/python/common.py

 """Common utilities that are useful for all the benchmarks."""
 import numpy as np
 
 import mlir.all_passes_registration
 
 from mlir import ir
 from mlir.dialects import arith
-from mlir.dialects import builtin
 from mlir.dialects import func
 from mlir.dialects import memref
 from mlir.dialects import scf
 from mlir.passmanager import PassManager
 
 
 def setup_passes(mlir_module):
     """Setup pass pipeline parameters for benchmark functions.
def emit_timer_func() -> func.FuncOp:
     """
     i64_type = ir.IntegerType.get_signless(64)
     nanoTime = func.FuncOp(
         "nanoTime", ([], [i64_type]), visibility="private")
     nanoTime.attributes["llvm.emit_c_interface"] = ir.UnitAttr.get()
     return nanoTime
 
 
-def emit_benchmark_wrapped_main_func(func, timer_func):
+def emit_benchmark_wrapped_main_func(kernel_func, timer_func):
     """Takes a function and a timer function, both represented as FuncOp
     objects, and returns a new function. This new function wraps the call to
     the original function between calls to the timer_func and this wrapping
     in turn is executed inside a loop. The loop is executed
-    len(func.type.results) times. This function can be used to create a
-    "time measuring" variant of a function.
+    len(kernel_func.type.results) times. This function can be used to
+    create a "time measuring" variant of a function.
     """
     i64_type = ir.IntegerType.get_signless(64)
     memref_of_i64_type = ir.MemRefType.get([-1], i64_type)
     wrapped_func = func.FuncOp(
         # Same signature and an extra buffer of indices to save timings.
         "main",
-        (func.arguments.types + [memref_of_i64_type], func.type.results),
+        (kernel_func.arguments.types + [memref_of_i64_type],
+         kernel_func.type.results),
         visibility="public"
     )
     wrapped_func.attributes["llvm.emit_c_interface"] = ir.UnitAttr.get()
 
-    num_results = len(func.type.results)
+    num_results = len(kernel_func.type.results)
     with ir.InsertionPoint(wrapped_func.add_entry_block()):
         timer_buffer = wrapped_func.arguments[-1]
         zero = arith.ConstantOp.create_index(0)
         n_iterations = memref.DimOp(ir.IndexType.get(), timer_buffer, zero)
         one = arith.ConstantOp.create_index(1)
         iter_args = list(wrapped_func.arguments[-num_results - 1:-1])
         loop = scf.ForOp(zero, n_iterations, one, iter_args)
         with ir.InsertionPoint(loop.body):
             start = func.CallOp(timer_func, [])
             call = func.CallOp(
-                func,
+                kernel_func,
                 wrapped_func.arguments[:-num_results - 1] + loop.inner_iter_args
             )
             end = func.CallOp(timer_func, [])
             time_taken = arith.SubIOp(end, start)
             memref.StoreOp(time_taken, timer_buffer, [loop.induction_variable])
             scf.YieldOp(list(call.results))
         func.ReturnOp(loop)
 
     return wrapped_func