bld: Upgrade LLVM version to 19.1.0.rc3 (#765)

Author: mtsokol

ci/environment.yml

@@ -11,7 +11,7 @@ dependencies:
   - pytest
   - pytest-cov
   - pytest-xdist
-  - mlir-python-bindings
+  - conda-forge/label/llvm_rc::mlir-python-bindings==19.1.0.rc3
   - pip:
     - finch-tensor >=0.1.31
     - pytest-codspeed

sparse/mlir_backend/__init__.py

@@ -3,7 +3,7 @@
 except ModuleNotFoundError as e:
     raise ImportError(
         "MLIR Python bindings not installed. Run "
-        "`conda install conda-forge::mlir-python-bindings` "
+        "`conda install conda-forge/label/llvm_rc::mlir-python-bindings` "
         "to enable MLIR backend."
     ) from e
 

sparse/mlir_backend/_constructors.py

@@ -1,5 +1,4 @@
 import ctypes
-import ctypes.util
 import functools
 import weakref
 
@@ -61,7 +60,7 @@ def get_module(shape: tuple[int], values_dtype: DType, index_dtype: DType):
             values_dtype = values_dtype.get_mlir_type()
             index_dtype = index_dtype.get_mlir_type()
             index_width = getattr(index_dtype, "width", 0)
-            levels = (sparse_tensor.LevelType.dense, sparse_tensor.LevelType.dense)
+            levels = (sparse_tensor.LevelFormat.dense, sparse_tensor.LevelFormat.dense)
             ordering = ir.AffineMap.get_permutation([0, 1])
             encoding = sparse_tensor.EncodingAttr.get(levels, ordering, ordering, index_width, index_width)
             dense_shaped = ir.RankedTensorType.get(list(shape), values_dtype, encoding)
@@ -71,19 +70,19 @@ def get_module(shape: tuple[int], values_dtype: DType, index_dtype: DType):
 
                 @func.FuncOp.from_py_func(tensor_1d)
                 def assemble(data):
-                    return sparse_tensor.assemble(dense_shaped, data, [])
+                    return sparse_tensor.assemble(dense_shaped, [], data)
 
                 @func.FuncOp.from_py_func(dense_shaped)
                 def disassemble(tensor_shaped):
                     data = tensor.EmptyOp([arith.constant(ir.IndexType.get(), 0)], values_dtype)
                     data, data_len = sparse_tensor.disassemble(
+                        [],
                         tensor_1d,
                         [],
                         index_dtype,
-                        [],
                         tensor_shaped,
-                        data,
                         [],
+                        data,
                     )
                     shape_x = arith.constant(index_dtype, shape[0])
                     shape_y = arith.constant(index_dtype, shape[1])
@@ -154,7 +153,7 @@ def get_module(shape: tuple[int], values_dtype: type[DType], index_dtype: type[D
             values_dtype = values_dtype.get_mlir_type()
             index_dtype = index_dtype.get_mlir_type()
             index_width = getattr(index_dtype, "width", 0)
-            levels = (sparse_tensor.LevelType.dense, sparse_tensor.LevelType.compressed)
+            levels = (sparse_tensor.LevelFormat.dense, sparse_tensor.LevelFormat.compressed)
             ordering = ir.AffineMap.get_permutation([0, 1])
             encoding = sparse_tensor.EncodingAttr.get(levels, ordering, ordering, index_width, index_width)
             csr_shaped = ir.RankedTensorType.get(list(shape), values_dtype, encoding)
@@ -166,25 +165,25 @@ def get_module(shape: tuple[int], values_dtype: type[DType], index_dtype: type[D
 
                 @func.FuncOp.from_py_func(tensor_1d_index, tensor_1d_index, tensor_1d_values)
                 def assemble(pos, crd, data):
-                    return sparse_tensor.assemble(csr_shaped, data, (pos, crd))
+                    return sparse_tensor.assemble(csr_shaped, (pos, crd), data)
 
                 @func.FuncOp.from_py_func(csr_shaped)
                 def disassemble(tensor_shaped):
                     pos = tensor.EmptyOp([arith.constant(ir.IndexType.get(), 0)], index_dtype)
                     crd = tensor.EmptyOp([arith.constant(ir.IndexType.get(), 0)], index_dtype)
                     data = tensor.EmptyOp([arith.constant(ir.IndexType.get(), 0)], values_dtype)
-                    data, pos, crd, data_len, pos_len, crd_len = sparse_tensor.disassemble(
-                        tensor_1d_values,
+                    pos, crd, data, pos_len, crd_len, data_len = sparse_tensor.disassemble(
                         (tensor_1d_index, tensor_1d_index),
-                        index_dtype,
+                        tensor_1d_values,
                         (index_dtype, index_dtype),
+                        index_dtype,
                         tensor_shaped,
-                        data,
                         (pos, crd),
+                        data,
                     )
                     shape_x = arith.constant(index_dtype, shape[0])
                     shape_y = arith.constant(index_dtype, shape[1])
-                    return data, pos, crd, data_len, pos_len, crd_len, shape_x, shape_y
+                    return pos, crd, data, pos_len, crd_len, data_len, shape_x, shape_y
 
                 @func.FuncOp.from_py_func(csr_shaped)
                 def free_tensor(tensor_shaped):
@@ -219,12 +218,12 @@ def assemble(cls, module: ir.Module, arr: sps.csr_array) -> ctypes.c_void_p:
     def disassemble(cls, module: ir.Module, ptr: ctypes.c_void_p, dtype: type[DType]) -> sps.csr_array:
         class Csr(ctypes.Structure):
             _fields_ = [
-                ("data", make_memref_ctype(dtype, 1)),
                 ("pos", make_memref_ctype(Index, 1)),
                 ("crd", make_memref_ctype(Index, 1)),
-                ("data_len", np.ctypeslib.c_intp),
+                ("data", make_memref_ctype(dtype, 1)),
                 ("pos_len", np.ctypeslib.c_intp),
                 ("crd_len", np.ctypeslib.c_intp),
+                ("data_len", np.ctypeslib.c_intp),
                 ("shape_x", np.ctypeslib.c_intp),
                 ("shape_y", np.ctypeslib.c_intp),
             ]

sparse/mlir_backend/_core.py

@@ -1,4 +1,5 @@
 import ctypes
+import ctypes.util
 import os
 import pathlib
 

sparse/mlir_backend/_ops.py

@@ -38,15 +38,15 @@ def add(a, b):
                     with ir.InsertionPoint(overlap):
                         arg0, arg1 = overlap.arguments
                         overlap_res = arith_op(arg0, arg1)
-                        sparse_tensor.YieldOp(result=overlap_res)
+                        sparse_tensor.YieldOp([overlap_res])
                     left_region = res.regions[1].blocks.append(dtype)
                     with ir.InsertionPoint(left_region):
                         (arg0,) = left_region.arguments
-                        sparse_tensor.YieldOp(result=arg0)
+                        sparse_tensor.YieldOp([arg0])
                     right_region = res.regions[2].blocks.append(dtype)
                     with ir.InsertionPoint(right_region):
                         (arg0,) = right_region.arguments
-                        sparse_tensor.YieldOp(result=arg0)
+                        sparse_tensor.YieldOp([arg0])
                     linalg.YieldOp([res])
                 return generic_op.result