1# RUN: SUPPORT_LIB=%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
2# RUN:   %PYTHON %s | FileCheck %s
3
4import ctypes
5import errno
6import itertools
7import os
8import sys
9
10from typing import List, Callable
11
12import numpy as np
13
14from mlir import ir
15from mlir import runtime as rt
16
17from mlir.dialects import builtin
18from mlir.dialects import func
19from mlir.dialects import sparse_tensor as st
20
21_SCRIPT_PATH = os.path.dirname(os.path.abspath(__file__))
22sys.path.append(_SCRIPT_PATH)
23from tools import sparse_compiler
24
25# ===----------------------------------------------------------------------=== #
26
27# TODO: move this boilerplate to its own module, so it can be used by
28# other tests and programs.
29class TypeConverter:
30  """Converter between NumPy types and MLIR types."""
31
32  def __init__(self, context: ir.Context):
33    # Note 1: these are numpy "scalar types" (i.e., the values of
34    # np.sctypeDict) not numpy "dtypes" (i.e., the np.dtype class).
35    #
36    # Note 2: we must construct the MLIR types in the same context as the
37    # types that'll be passed to irtype_to_sctype() or irtype_to_dtype();
38    # otherwise, those methods will raise a KeyError.
39    types_list = [
40      (np.float64, ir.F64Type.get(context=context)),
41      (np.float32, ir.F32Type.get(context=context)),
42      (np.int64, ir.IntegerType.get_signless(64, context=context)),
43      (np.int32, ir.IntegerType.get_signless(32, context=context)),
44      (np.int16, ir.IntegerType.get_signless(16, context=context)),
45      (np.int8, ir.IntegerType.get_signless(8, context=context)),
46    ]
47    self._sc2ir = dict(types_list)
48    self._ir2sc = dict(( (ir,sc) for sc,ir in types_list ))
49
50  def dtype_to_irtype(self, dtype: np.dtype) -> ir.Type:
51    """Returns the MLIR equivalent of a NumPy dtype."""
52    try:
53      return self.sctype_to_irtype(dtype.type)
54    except KeyError as e:
55      raise KeyError(f'Unknown dtype: {dtype}') from e
56
57  def sctype_to_irtype(self, sctype) -> ir.Type:
58    """Returns the MLIR equivalent of a NumPy scalar type."""
59    if sctype in self._sc2ir:
60      return self._sc2ir[sctype]
61    else:
62      raise KeyError(f'Unknown sctype: {sctype}')
63
64  def irtype_to_dtype(self, tp: ir.Type) -> np.dtype:
65    """Returns the NumPy dtype equivalent of an MLIR type."""
66    return np.dtype(self.irtype_to_sctype(tp))
67
68  def irtype_to_sctype(self, tp: ir.Type):
69    """Returns the NumPy scalar-type equivalent of an MLIR type."""
70    if tp in self._ir2sc:
71      return self._ir2sc[tp]
72    else:
73      raise KeyError(f'Unknown ir.Type: {tp}')
74
75  def get_RankedTensorType_of_nparray(self, nparray: np.ndarray) -> ir.RankedTensorType:
76    """Returns the ir.RankedTensorType of a NumPy array.  Note that NumPy
77    arrays can only be converted to/from dense tensors, not sparse tensors."""
78    # TODO: handle strides as well?
79    return ir.RankedTensorType.get(nparray.shape,
80                                   self.dtype_to_irtype(nparray.dtype))
81
82# ===----------------------------------------------------------------------=== #
83
84class StressTest:
85  def __init__(self, tyconv: TypeConverter):
86    self._tyconv = tyconv
87    self._roundtripTp = None
88    self._module = None
89    self._engine = None
90
91  def _assertEqualsRoundtripTp(self, tp: ir.RankedTensorType):
92    assert self._roundtripTp is not None, \
93        'StressTest: uninitialized roundtrip type'
94    if tp != self._roundtripTp:
95      raise AssertionError(
96          f"Type is not equal to the roundtrip type.\n"
97          f"\tExpected: {self._roundtripTp}\n"
98          f"\tFound:    {tp}\n")
99
100  def build(self, types: List[ir.Type]):
101    """Builds the ir.Module.  The module has only the @main function,
102    which will convert the input through the list of types and then back
103    to the initial type.  The roundtrip type must be a dense tensor."""
104    assert self._module is None, 'StressTest: must not call build() repeatedly'
105    self._module = ir.Module.create()
106    with ir.InsertionPoint(self._module.body):
107      tp0 = types.pop(0)
108      self._roundtripTp = tp0
109      # TODO: assert dense? assert element type is recognised by the TypeConverter?
110      types.append(tp0)
111      funcTp = ir.FunctionType.get(inputs=[tp0], results=[tp0])
112      funcOp = func.FuncOp(name='main', type=funcTp)
113      funcOp.attributes['llvm.emit_c_interface'] = ir.UnitAttr.get()
114      with ir.InsertionPoint(funcOp.add_entry_block()):
115        arg0 = funcOp.entry_block.arguments[0]
116        self._assertEqualsRoundtripTp(arg0.type)
117        v = st.ConvertOp(types.pop(0), arg0)
118        for tp in types:
119          w = st.ConvertOp(tp, v)
120          # Release intermediate tensors before they fall out of scope.
121          st.ReleaseOp(v.result)
122          v = w
123        self._assertEqualsRoundtripTp(v.result.type)
124        func.ReturnOp(v)
125    return self
126
127  def writeTo(self, filename):
128    """Write the ir.Module to the given file.  If the file already exists,
129    then raises an error.  If the filename is None, then is a no-op."""
130    assert self._module is not None, \
131        'StressTest: must call build() before writeTo()'
132    if filename is None:
133      # Silent no-op, for convenience.
134      return self
135    if os.path.exists(filename):
136      raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), filename)
137    with open(filename, 'w') as f:
138      f.write(str(self._module))
139    return self
140
141  def compile(self, compiler):
142    """Compile the ir.Module."""
143    assert self._module is not None, \
144        'StressTest: must call build() before compile()'
145    assert self._engine is None, \
146        'StressTest: must not call compile() repeatedly'
147    self._engine = compiler.compile_and_jit(self._module)
148    return self
149
150  def run(self, np_arg0: np.ndarray) -> np.ndarray:
151    """Runs the test on the given numpy array, and returns the resulting
152    numpy array."""
153    assert self._engine is not None, \
154        'StressTest: must call compile() before run()'
155    self._assertEqualsRoundtripTp(
156        self._tyconv.get_RankedTensorType_of_nparray(np_arg0))
157    np_out = np.zeros(np_arg0.shape, dtype=np_arg0.dtype)
158    self._assertEqualsRoundtripTp(
159        self._tyconv.get_RankedTensorType_of_nparray(np_out))
160    mem_arg0 = ctypes.pointer(ctypes.pointer(rt.get_ranked_memref_descriptor(np_arg0)))
161    mem_out = ctypes.pointer(ctypes.pointer(rt.get_ranked_memref_descriptor(np_out)))
162    self._engine.invoke('main', mem_out, mem_arg0)
163    return rt.ranked_memref_to_numpy(mem_out[0])
164
165# ===----------------------------------------------------------------------=== #
166
167def main():
168  """
169  USAGE: python3 test_stress.py [raw_module.mlir [compiled_module.mlir]]
170
171  The environment variable SUPPORT_LIB must be set to point to the
172  libmlir_c_runner_utils shared library.  There are two optional
173  arguments, for debugging purposes.  The first argument specifies where
174  to write out the raw/generated ir.Module.  The second argument specifies
175  where to write out the compiled version of that ir.Module.
176  """
177  support_lib = os.getenv('SUPPORT_LIB')
178  assert support_lib is not None, 'SUPPORT_LIB is undefined'
179  if not os.path.exists(support_lib):
180    raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), support_lib)
181
182  # CHECK-LABEL: TEST: test_stress
183  print("\nTEST: test_stress")
184  with ir.Context() as ctx, ir.Location.unknown():
185    vl = 1
186    e = False
187    sparsification_options = (
188        f'parallelization-strategy=none '
189        f'vectorization-strategy=none '
190        f'vl={vl} '
191        f'enable-simd-index32={e}')
192    compiler = sparse_compiler.SparseCompiler(
193        options=sparsification_options, opt_level=0, shared_libs=[support_lib])
194    f64 = ir.F64Type.get()
195    # Be careful about increasing this because
196    #     len(types) = 1 + 2^rank * rank! * len(bitwidths)^2
197    shape = range(2, 6)
198    rank = len(shape)
199    # All combinations.
200    levels = list(itertools.product(*itertools.repeat(
201      [st.DimLevelType.dense, st.DimLevelType.compressed], rank)))
202    # All permutations.
203    orderings = list(map(ir.AffineMap.get_permutation,
204      itertools.permutations(range(rank))))
205    bitwidths = [0]
206    # The first type must be a dense tensor for numpy conversion to work.
207    types = [ir.RankedTensorType.get(shape, f64)]
208    for level in levels:
209      for ordering in orderings:
210        for pwidth in bitwidths:
211          for iwidth in bitwidths:
212            attr = st.EncodingAttr.get(level, ordering, pwidth, iwidth)
213            types.append(ir.RankedTensorType.get(shape, f64, attr))
214    #
215    # For exhaustiveness we should have one or more StressTest, such
216    # that their paths cover all 2*n*(n-1) directed pairwise combinations
217    # of the `types` set.  However, since n is already superexponential,
218    # such exhaustiveness would be prohibitive for a test that runs on
219    # every commit.  So for now we'll just pick one particular path that
220    # at least hits all n elements of the `types` set.
221    #
222    tyconv = TypeConverter(ctx)
223    size = 1
224    for d in shape:
225      size *= d
226    np_arg0 = np.arange(size, dtype=tyconv.irtype_to_dtype(f64)).reshape(*shape)
227    np_out = (
228        StressTest(tyconv).build(types).writeTo(
229            sys.argv[1] if len(sys.argv) > 1 else None).compile(compiler)
230        .writeTo(sys.argv[2] if len(sys.argv) > 2 else None).run(np_arg0))
231    # CHECK: Passed
232    if np.allclose(np_out, np_arg0):
233      print('Passed')
234    else:
235      sys.exit('FAILURE')
236
237if __name__ == '__main__':
238  main()
239