[mlir][sparse] Updating STEA parser/printer to use the name "dimSlices"

[wrengr]

Summary

Depends On D151505

[wrengr]

updating the field name in the STEA-documentation example

[wrengr]

rebase

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorAttrDefs.td

#ELL = #sparse_tensor.encoding<{
       higherOrdering = affine_map<(i, j)[c] -> (c * 4 * i, i, j)>
     }>
     ... tensor<?x?xf64, #ELL> ...
 
     // CSR slice (offset = 0, size = 4, stride = 1 on the first dimension;
     // offset = 0, size = 8, and a dynamic stride on the second dimension).
     #CSR_SLICE = #sparse_tensor.encoding<{
       lvlTypes = [ "dense", "compressed" ],
-      slice = [ (0, 4, 1), (0, 8, ?) ]
+      dimSlices = [ (0, 4, 1), (0, 8, ?) ]
     }>
     ... tensor<?x?xf64, #CSC_SLICE> ...
 
     ```
   }];
 
   // Data in sparse tensor encoding.
   let parameters = (
     ins
     // A level-type for each level of the sparse storage.
     ArrayRefParameter<
       "::mlir::sparse_tensor::DimLevelType",
       "level-types"
       >: $lvlTypes,
     // A mapping from dimension-coordinates to level-coordinates.
     "AffineMap":$dimToLvl,
     // The required bitwidth for position storage.
     "unsigned":$posWidth,
     // The required bitwidth for coordinate storage.
     "unsigned":$crdWidth,
     // A slice attribute for each dimension of the tensor type.
-    // FIXME: The name used here is `dimSlices`, however the
-    // parser/printer uses the name `slice` instead.  Therefore
-    // the parser/printer need to be updated to match.
     ArrayRefParameter<
       "::mlir::sparse_tensor::SparseTensorDimSliceAttr",
       "per dimension slice metadata"
       >: $dimSlices
   );
 
   let builders = [
     AttrBuilder<(ins "ArrayRef<::mlir::sparse_tensor::DimLevelType>":$lvlTypes,

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

if (COND) {                                                                  \
     return {};                                                                 \
   }
 
   RETURN_ON_FAIL(parser.parseLess())
   RETURN_ON_FAIL(parser.parseLBrace())
 
   // Process the data from the parsed dictionary value into struct-like data.
   SmallVector<DimLevelType> lvlTypes;
-  SmallVector<SparseTensorDimSliceAttr> slices;
+  SmallVector<SparseTensorDimSliceAttr> dimSlices;
   AffineMap dimToLvl = {};
   unsigned posWidth = 0;
   unsigned crdWidth = 0;
 
   StringRef attrName;
   // Exactly 6 keys.
   SmallVector<StringRef, 6> keys = {"lvlTypes", "dimToLvl", "posWidth",
-                                    "crdWidth", "slice"};
+                                    "crdWidth", "dimSlices"};
   while (succeeded(parser.parseOptionalKeyword(&attrName))) {
     if (!llvm::is_contained(keys, attrName)) {
       parser.emitError(parser.getNameLoc(), "unexpected key: ") << attrName;
       return {};
     }
 
     // Consume the `=` after keys
     RETURN_ON_FAIL(parser.parseEqual())
if (attrName == "lvlTypes") {
       ERROR_IF(!intAttr, "expected an integral position bitwidth")
       posWidth = intAttr.getInt();
     } else if (attrName == "crdWidth") {
       Attribute attr;
       RETURN_ON_FAIL(parser.parseAttribute(attr))
       auto intAttr = llvm::dyn_cast<IntegerAttr>(attr);
       ERROR_IF(!intAttr, "expected an integral index bitwidth")
       crdWidth = intAttr.getInt();
-    } else if (attrName == "slice") {
+    } else if (attrName == "dimSlices") {
       RETURN_ON_FAIL(parser.parseLSquare())
       // Dispatches to DimSliceAttr to skip mnemonic
       bool finished = false;
       while (auto attr = SparseTensorDimSliceAttr::parse(parser, nullptr)) {
         auto sliceAttr = llvm::cast<SparseTensorDimSliceAttr>(attr);
-        slices.push_back(sliceAttr);
+        dimSlices.push_back(sliceAttr);
         if (parser.parseOptionalComma().failed()) {
           finished = true;
           break;
         }
       }
       // Wrong when parsing slices
       if (!finished)
         return {};
       RETURN_ON_FAIL(parser.parseRSquare())
     }
 
     // Only the last item can omit the comma
     if (parser.parseOptionalComma().failed())
       break;
   }
 
   RETURN_ON_FAIL(parser.parseRBrace())
   RETURN_ON_FAIL(parser.parseGreater())
 #undef ERROR_IF
 #undef RETURN_ON_FAIL
 
   // Construct struct-like storage for attribute.
   return parser.getChecked<SparseTensorEncodingAttr>(
-      parser.getContext(), lvlTypes, dimToLvl, posWidth, crdWidth, slices);
+      parser.getContext(), lvlTypes, dimToLvl, posWidth, crdWidth, dimSlices);
 }
 
 void SparseTensorEncodingAttr::print(AsmPrinter &printer) const {
   // Print the struct-like storage in dictionary fashion.
   printer << "<{ lvlTypes = [ ";
   llvm::interleaveComma(getLvlTypes(), printer, [&](DimLevelType dlt) {
     printer << "\"" << toMLIRString(dlt) << "\"";
   });
   printer << " ]";
   // Print remaining members only for non-default values.
   if (!isIdentity())
     printer << ", dimToLvl = affine_map<" << getDimToLvl() << ">";
   if (getPosWidth())
     printer << ", posWidth = " << getPosWidth();
   if (getCrdWidth())
     printer << ", crdWidth = " << getCrdWidth();
   if (!getDimSlices().empty()) {
-    printer << ", slice = [ ";
+    printer << ", dimSlices = [ ";
     llvm::interleaveComma(getDimSlices(), printer,
                           [&](SparseTensorDimSliceAttr attr) {
                             // Calls SparseTensorDimSliceAttr::print directly to
                             // skip mnemonic.
                             attr.print(printer);
                           });
     printer << " ]";
   }

mlir/test/Dialect/SparseTensor/convert_sparse2sparse.mlir

 
 #TsssPermuted = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed", "compressed" ],
   dimToLvl = affine_map<(i,j,k) -> (k,i,j)>
 }>
 
 #COOSlice = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ],
-  slice = [ (2, 2, 1), (12, 13, 1) ]
+  dimSlices = [ (2, 2, 1), (12, 13, 1) ]
 }>
 
 // CHECK-LABEL: func @sparse_nop_convert(
 //  CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) -> !llvm.ptr<i8>
 //       CHECK: return %[[A]] : !llvm.ptr<i8>
 func.func @sparse_nop_convert(%arg0: tensor<64xf32, #SparseVector>) -> tensor<64xf32, #SparseVector> {
   %0 = sparse_tensor.convert %arg0 : tensor<64xf32, #SparseVector> to tensor<64xf32, #SparseVector>
   return %0 : tensor<64xf32, #SparseVector>

mlir/test/Dialect/SparseTensor/invalid.mlir

func.func @mismatch_values_types(%arg0: tensor<?xf64, #SparseVector>) -> memref<?xf32> {
   %0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf32>
   return %0 : memref<?xf32>
 }
 
 // -----
 
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (1, 4, 1), (1, 4, 2) ]
+  dimSlices = [ (1, 4, 1), (1, 4, 2) ]
 }>
 
 func.func @sparse_slice_offset(%arg0: tensor<2x8xf64, #CSR_SLICE>) -> index {
   // expected-error@+1 {{requested dimension out of bound}}
   %0 = sparse_tensor.slice.offset %arg0 at 2 : tensor<2x8xf64, #CSR_SLICE>
   return %0 : index
 }
 
 // -----
 
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (1, 4, 1), (1, 4, 2) ]
+  dimSlices = [ (1, 4, 1), (1, 4, 2) ]
 }>
 
 func.func @sparse_slice_stride(%arg0: tensor<2x8xf64, #CSR_SLICE>) -> index {
   // expected-error@+1 {{requested dimension out of bound}}
   %0 = sparse_tensor.slice.stride %arg0 at 2 : tensor<2x8xf64, #CSR_SLICE>
   return %0 : index
 }
 
func.func @invalid_out_dense(%arg0: tensor<10xf64>, %arg1: !llvm.ptr<i8>) {
   sparse_tensor.out %arg0, %arg1 : tensor<10xf64>, !llvm.ptr<i8>
   return
 }
 
 // -----
 
 #CSR = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "compressed"],
-  slice = [ (1, 4, 1), (1, 4, 2) ]
+  dimSlices = [ (1, 4, 1), (1, 4, 2) ]
 }>
 
 func.func @sparse_convert_to_slice(%arg0: tensor<10x?xf32>) -> tensor<10x10xf32, #CSR> {
   // expected-error@+1 {{cannot convert to a sparse tensor slice}}
   %0 = sparse_tensor.convert %arg0 : tensor<10x?xf32> to tensor<10x10xf32, #CSR>
   return %0 : tensor<10x10xf32, #CSR>
 }
 

mlir/test/Dialect/SparseTensor/invalid_encoding.mlir

 
 #a = #sparse_tensor.encoding<{key = 1}> // expected-error {{unexpected key: key}}
 func.func private @tensor_invalid_key(%arg0: tensor<16x32xf32, #a>) -> ()
 
 // -----
 
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (-1, ?, 1), (?, 4, 2) ] // expected-error{{expect positive value or ? for slice offset/size/stride}}
+  dimSlices = [ (-1, ?, 1), (?, 4, 2) ] // expected-error{{expect positive value or ? for slice offset/size/stride}}
 }>
 func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>)

mlir/test/Dialect/SparseTensor/pre_rewriting.mlir

 // RUN: mlir-opt %s -pre-sparsification-rewrite | FileCheck %s
 
 #SparseVector = #sparse_tensor.encoding<{
   lvlTypes = ["compressed"]
 }>
 
 #SortedCOO = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ]
 }>
 
 #Slice = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ],
-  slice = [ (?, 1, 1), (?, 3, 1) ]
+  dimSlices = [ (?, 1, 1), (?, 3, 1) ]
 }>
 
 // CHECK-LABEL: func @sparse_nop_cast(
 //  CHECK-SAME: %[[A:.*]]: tensor<?xf32, #sparse_tensor.encoding<{{{.*}}}>>)
 //       CHECK: return %[[A]] : tensor<?xf32, #sparse_tensor.encoding<{{{.*}}}>>
 func.func @sparse_nop_cast(%a : tensor<?xf32, #SparseVector>) -> tensor<?xf32, #SparseVector> {
   %0 = tensor.cast %a : tensor<?xf32, #SparseVector> to tensor<?xf32, #SparseVector>
   %1 = tensor.cast %0 : tensor<?xf32, #SparseVector> to tensor<?xf32, #SparseVector>

mlir/test/Dialect/SparseTensor/roundtrip.mlir

func.func @sparse_values(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xf64> {
   %0 = sparse_tensor.values %arg0 : tensor<128xf64, #SparseVector> to memref<?xf64>
   return %0 : memref<?xf64>
 }
 
 // -----
 
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (1, 4, 1), (1, 4, 2) ]
+  dimSlices = [ (1, 4, 1), (1, 4, 2) ]
 }>
 
 // CHECK-LABEL: func @sparse_slice_offset(
 //  CHECK-SAME: %[[A:.*]]: tensor<2x8xf64, #{{.*}}>)
 //       CHECK: %[[T:.*]] = sparse_tensor.slice.offset %[[A]] at 1 : tensor<2x8xf64, #{{.*}}>
 //       CHECK: return %[[T]] : index
 func.func @sparse_slice_offset(%arg0: tensor<2x8xf64, #CSR_SLICE>) -> index {
   %0 = sparse_tensor.slice.offset %arg0 at 1 : tensor<2x8xf64, #CSR_SLICE>
   return %0 : index
 }
 
 // -----
 
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (1, 4, 1), (1, 4, 2) ]
+  dimSlices = [ (1, 4, 1), (1, 4, 2) ]
 }>
 
 // CHECK-LABEL: func @sparse_slice_stride(
 //  CHECK-SAME: %[[A:.*]]: tensor<2x8xf64, #{{.*}}>)
 //       CHECK: %[[T:.*]] = sparse_tensor.slice.stride %[[A]] at 1 : tensor<2x8xf64, #{{.*}}>
 //       CHECK: return %[[T]] : index
 func.func @sparse_slice_stride(%arg0: tensor<2x8xf64, #CSR_SLICE>) -> index {
   %0 = sparse_tensor.slice.stride %arg0 at 1 : tensor<2x8xf64, #CSR_SLICE>
func.func @sparse_metadata_init() -> !sparse_tensor.storage_specifier<#SparseVector> {
   return %0 : !sparse_tensor.storage_specifier<#SparseVector>
 }
 
 // -----
 
 #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
 #SparseVector_Slice = #sparse_tensor.encoding<{
   lvlTypes = ["compressed"],
-  slice = [ (?, ?, ?) ]
+  dimSlices = [ (?, ?, ?) ]
 }>
 
 // CHECK-LABEL: func @sparse_metadata_init(
 //  CHECK-SAME: %[[A:.*]]: !sparse_tensor.storage_specifier<#{{.*}}>
 //       CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.init with %[[A]] :
 //       CHECK: return %[[T]] : !sparse_tensor.storage_specifier<#{{.*}}>
 func.func @sparse_metadata_init(%src : !sparse_tensor.storage_specifier<#SparseVector>)
                                     -> !sparse_tensor.storage_specifier<#SparseVector_Slice> {
%0 = sparse_tensor.storage_specifier.get %arg0 lvl_sz at 0
        : !sparse_tensor.storage_specifier<#SparseVector>
   return %0 : index
 }
 
 // -----
 
 #SparseVector_Slice = #sparse_tensor.encoding<{
   lvlTypes = ["compressed"],
-  slice = [ (?, ?, ?) ]
+  dimSlices = [ (?, ?, ?) ]
 }>
 
 // CHECK-LABEL: func @sparse_get_md(
 //  CHECK-SAME: %[[A:.*]]: !sparse_tensor.storage_specifier<#{{.*}}>
 //       CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.get %[[A]] dim_offset at 0
 //       CHECK: return %[[T]] : index
 func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector_Slice>) -> index {
   %0 = sparse_tensor.storage_specifier.get %arg0 dim_offset at 0
        : !sparse_tensor.storage_specifier<#SparseVector_Slice>
   return %0 : index
 }
 
 // -----
 
 #SparseVector = #sparse_tensor.encoding<{
   lvlTypes = ["compressed"],
-  slice = [ (?, ?, ?) ]
+  dimSlices = [ (?, ?, ?) ]
 }>
 
 // CHECK-LABEL: func @sparse_get_md(
 //  CHECK-SAME: %[[A:.*]]: !sparse_tensor.storage_specifier<#{{.*}}>
 //       CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.get %[[A]] dim_stride at 0
 //       CHECK: return %[[T]] : index
 func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>) -> index {
   %0 = sparse_tensor.storage_specifier.get %arg0 dim_stride at 0

mlir/test/Dialect/SparseTensor/roundtrip_encoding.mlir

 // CHECK-LABEL: func private @sparse_ell(
 // CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ], dimToLvl = affine_map<(d0, d1)[s0] -> (d0 * (s0 * 4), d0, d1)> }>>
 func.func private @sparse_ell(tensor<?x?xf64, #ELL>)
 
 // -----
 
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (1, 4, 1), (1, 4, 2) ]
+  dimSlices = [ (1, 4, 1), (1, 4, 2) ]
 }>
 
 // CHECK-LABEL: func private @sparse_slice(
-// CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], slice = [ (1, 4, 1), (1, 4, 2) ] }>>
+// CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimSlices = [ (1, 4, 1), (1, 4, 2) ] }>>
 func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>)
 
 // -----
 
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (1, 4, 1), (1, 4, 2) ]
+  dimSlices = [ (1, 4, 1), (1, 4, 2) ]
 }>
 
 // CHECK-LABEL: func private @sparse_slice(
-// CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], slice = [ (1, 4, 1), (1, 4, 2) ] }>>
+// CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimSlices = [ (1, 4, 1), (1, 4, 2) ] }>>
 func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>)
 
 // -----
 
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (1, ?, 1), (?, 4, 2) ]
+  dimSlices = [ (1, ?, 1), (?, 4, 2) ]
 }>
 
 // CHECK-LABEL: func private @sparse_slice(
-// CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], slice = [ (1, ?, 1), (?, 4, 2) ] }>>
+// CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimSlices = [ (1, ?, 1), (?, 4, 2) ] }>>
 func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>)

mlir/test/Dialect/SparseTensor/sparse_extract_slice.mlir

 // RUN: mlir-opt %s --sparse-tensor-codegen --cse |  FileCheck %s
 
 #CSR = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ]
 }>
 
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (0, 4, 1), (0, 8, 1) ]
+  dimSlices = [ (0, 4, 1), (0, 8, 1) ]
 }>
 
 // CHECK-LABEL:   func.func @sparse_slice(
 // CHECK-SAME:                            %[[VAL_0:.*0]]: memref<?xindex>,
 // CHECK-SAME:                            %[[VAL_1:.*1]]: memref<?xindex>,
 // CHECK-SAME:                            %[[VAL_2:.*2]]: memref<?xf64>,
 // CHECK-SAME:                            %[[VAL_3:.*3]]: !sparse_tensor.storage_specifier<#sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>)
 // CHECK:           %[[VAL_4:.*]] = sparse_tensor.storage_specifier.init with %[[VAL_3]]

mlir/test/Dialect/SparseTensor/sparse_foreach.mlir

func.func @sparse_foreach_constant() -> () {
   ^bb0(%arg0: index, %arg1: index, %arg2: f32):
     "test.use" (%arg0, %arg1, %arg2): (index,index,f32)->()
   }
   return
 }
 
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  slice = [ (0, 4, 1), (2, 4, 1) ]
+  dimSlices = [ (0, 4, 1), (2, 4, 1) ]
 }>
 
 #CSR_SLICE_DYN = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  slice = [ (?, ?, ?), (?, ?, ?) ]
+  dimSlices = [ (?, ?, ?), (?, ?, ?) ]
 }>
 
 
 // CHECK-LABEL:   func.func @foreach_print_slice_dyn(
 // CHECK-SAME:                                       %[[VAL_0:.*]]: tensor<?x?xf64,
 // CHECK-DAG:       %[[VAL_1:.*]] = arith.constant 0 : index
 // CHECK-DAG:       %[[VAL_2:.*]] = arith.constant 1 : index
 // CHECK-DAG:       %[[VAL_3:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?x?xf64,

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_foreach_slices.mlir

 // TODO: support slices on lib path
 
 #CSR = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ]
 }>
 
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (1, 4, 1), (1, 4, 2) ]
+  dimSlices = [ (1, 4, 1), (1, 4, 2) ]
 }>
 
 #CSR_SLICE_DYN = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (?, ?, ?), (?, ?, ?) ]
+  dimSlices = [ (?, ?, ?), (?, ?, ?) ]
 }>
 
 #COO = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ]
 }>
 
 #COO_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ],
-  slice = [ (1, 4, 1), (1, 4, 2) ]
+  dimSlices = [ (1, 4, 1), (1, 4, 2) ]
 }>
 
 #COO_SLICE_DYN = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ],
-  slice = [ (?, ?, ?), (?, ?, ?) ]
+  dimSlices = [ (?, ?, ?), (?, ?, ?) ]
 }>
 
 
 
 module {
   func.func @foreach_print_non_slice(%A: tensor<4x4xf64, #CSR>) {
     sparse_tensor.foreach in %A : tensor<4x4xf64, #CSR> do {
     ^bb0(%1: index, %2: index, %v: f64) :

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_matmul_slice.mlir

 // TODO: support lib path.
 
 #DCSR = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ]
 }>
 
 #DCSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  slice = [ (0, 4, 1), (0, 8, 1) ]
+  dimSlices = [ (0, 4, 1), (0, 8, 1) ]
 }>
 
 #CSR = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ]
 }>
 
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (0, 4, 1), (0, 8, 1) ]
+  dimSlices = [ (0, 4, 1), (0, 8, 1) ]
 }>
 
 #COO = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ]
 }>
 
 #CSR_SLICE_1 = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (0, 4, 2), (0, 4, 1) ]
+  dimSlices = [ (0, 4, 2), (0, 4, 1) ]
 }>
 
 #DCSR_SLICE_1 = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  slice = [ (0, 4, 2), (1, 4, 1) ]
+  dimSlices = [ (0, 4, 2), (1, 4, 1) ]
 }>
 
 #COO_SLICE_1 = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ],
-  slice = [ (0, 4, 2), (0, 4, 1) ]
+  dimSlices = [ (0, 4, 2), (0, 4, 1) ]
 }>
 
 #COO_SLICE_2 = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ],
-  slice = [ (0, 4, 2), (1, 4, 1) ]
+  dimSlices = [ (0, 4, 2), (1, 4, 1) ]
 }>
 
 #CSR_SLICE_dyn = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  slice = [ (?, 4, ?), (?, 4, ?) ]
+  dimSlices = [ (?, 4, ?), (?, 4, ?) ]
 }>
 
 #DCSR_SLICE_dyn = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  slice = [ (?, 4, ?), (?, 4, ?) ]
+  dimSlices = [ (?, 4, ?), (?, 4, ?) ]
 }>
 
 module {
   func.func private @printMemrefF64(%ptr : tensor<*xf64>)
   func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface }
 
   //
   // Computes C = A x B with all matrices dynamic sparse slice (SpMSpM) in CSR and DCSR