[mlir][sparse] Adjusting DimLevelType numeric values for faster predicates

[wrengr]

Summary

This differential adjusts the numeric values for DimLevelType values: using the low-order two bits for recording the "No" and "Nu" properties, and the high-order bits for the formats per se. (The choice of encoding may seem a bit peculiar, since the bits are mapped to negative properties rather than positive properties. But this was done in order to preserve the collation order of DimLevelType values. If we don't care about collation order, then we may prefer to flip the semantics of the property bits, so that they're less surprising to readers.)

Using distinguished bits for the properties and formats enables faster implementation for the predicates detecting those properties/formats, which matters because this is in the runtime library itself (rather than on the codegen side of things). This differential pushes through the changes to the enum values, and optimizes the basic predicates. However it does not optimize all the places where we check compound predicates (e.g., "is compressed or singleton"), to help reduce rebasing conflict with D134933. Those optimizations will be done after this differential and D134933 are landed.

[wrengr]

incorporated the fix from D135034

[wrengr]

rebase

[wrengr]

git-clang-format

[wrengr]

Fixing mlir/test/CAPI/sparse_tensor.c

[wrengr]

Rebasing (to hopefully fix the unrelated Flang build errors)

mlir/include/mlir-c/Dialect/SparseTensor.h

 
 /// Dimension level types (and properties) that define sparse tensors.
 /// See the documentation in SparseTensorAttrDefs.td for their meaning.
 ///
 /// These correspond to SparseTensorEncodingAttr::DimLevelType in the C++ API.
 /// If updating, keep them in sync and update the static_assert in the impl
 /// file.
 enum MlirSparseTensorDimLevelType {
-  MLIR_SPARSE_TENSOR_DIM_LEVEL_DENSE,
-  MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED,
-  MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_NU,
-  MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_NO,
-  MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_NU_NO,
-  MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON,
-  MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NU,
-  MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NO,
-  MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NU_NO,
+  MLIR_SPARSE_TENSOR_DIM_LEVEL_DENSE = 4,             // 0b001_00
+  MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED = 8,        // 0b010_00
+  MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_NU = 9,     // 0b010_01
+  MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_NO = 10,    // 0b010_10
+  MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_NU_NO = 11, // 0b010_11
+  MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON = 16,        // 0b100_00
+  MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NU = 17,     // 0b100_01
+  MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NO = 18,     // 0b100_10
+  MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NU_NO = 19,  // 0b100_11
 };
 
 //===----------------------------------------------------------------------===//
 // SparseTensorEncodingAttr
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a sparse_tensor.encoding attribute.
 MLIR_CAPI_EXPORTED bool

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

def SparseTensorEncodingAttr : SparseTensor_Attr<"SparseTensorEncoding",
 
   let extraClassDeclaration = [{
     // Dimension level types. By default, each type has the unique and
     // ordered properties. Alternatives properties are indicated by
     // Nu (not-unique) and No (not-ordered).
     //
     // TODO: separate type and property in encoding
     //
-    enum class DimLevelType {
-      Dense,
-      Compressed, CompressedNu, CompressedNo, CompressedNuNo,
-      Singleton, SingletonNu, SingletonNo, SingletonNuNo,
+    enum class DimLevelType : uint8_t {
+      Dense            = 4,  // 0b001_00
+      Compressed       = 8,  // 0b010_00
+      CompressedNu     = 9,  // 0b010_01
+      CompressedNo     = 10, // 0b010_10
+      CompressedNuNo   = 11, // 0b010_11
+      Singleton        = 16, // 0b100_00
+      SingletonNu      = 17, // 0b100_01
+      SingletonNo      = 18, // 0b100_10
+      SingletonNuNo    = 19, // 0b100_11
     };
   }];
 }
 
 def IsSparseTensorPred
   : CPred<"!!::mlir::sparse_tensor::getSparseTensorEncoding($_self)">;
 
 // The following four follow the same idiom as `TensorOf`, `AnyTensor`,

mlir/include/mlir/ExecutionEngine/SparseTensor/Enums.h

enum class MLIR_SPARSETENSOR_EXPORT Action : uint32_t {
   kToCOO = 5,
   kToIterator = 6,
 };
 
 /// This enum mimics `SparseTensorEncodingAttr::DimLevelType` for
 /// breaking dependency cycles.  `SparseTensorEncodingAttr::DimLevelType`
 /// is the source of truth and this enum should be kept consistent with it.
 enum class MLIR_SPARSETENSOR_EXPORT DimLevelType : uint8_t {
-  kDense = 0,
-  kCompressed = 1,
-  kCompressedNu = 2,
-  kCompressedNo = 3,
-  kCompressedNuNo = 4,
-  kSingleton = 5,
-  kSingletonNu = 6,
-  kSingletonNo = 7,
-  kSingletonNuNo = 8,
+  kDense = 4,           // 0b001_00
+  kCompressed = 8,      // 0b010_00
+  kCompressedNu = 9,    // 0b010_01
+  kCompressedNo = 10,   // 0b010_10
+  kCompressedNuNo = 11, // 0b010_11
+  kSingleton = 16,      // 0b100_00
+  kSingletonNu = 17,    // 0b100_01
+  kSingletonNo = 18,    // 0b100_10
+  kSingletonNuNo = 19,  // 0b100_11
 };
 
 /// Check if the `DimLevelType` is dense.
 constexpr MLIR_SPARSETENSOR_EXPORT bool isDenseDLT(DimLevelType dlt) {
   return dlt == DimLevelType::kDense;
 }
 
 /// Check if the `DimLevelType` is compressed (regardless of properties).
 constexpr MLIR_SPARSETENSOR_EXPORT bool isCompressedDLT(DimLevelType dlt) {
-  switch (dlt) {
-  case DimLevelType::kCompressed:
-  case DimLevelType::kCompressedNu:
-  case DimLevelType::kCompressedNo:
-  case DimLevelType::kCompressedNuNo:
-    return true;
-  default:
-    return false;
-  }
+  return static_cast<uint8_t>(dlt) &
+         static_cast<uint8_t>(DimLevelType::kCompressed);
 }
 
 /// Check if the `DimLevelType` is singleton (regardless of properties).
 constexpr MLIR_SPARSETENSOR_EXPORT bool isSingletonDLT(DimLevelType dlt) {
-  switch (dlt) {
-  case DimLevelType::kSingleton:
-  case DimLevelType::kSingletonNu:
-  case DimLevelType::kSingletonNo:
-  case DimLevelType::kSingletonNuNo:
-    return true;
-  default:
-    return false;
-  }
+  return static_cast<uint8_t>(dlt) &
+         static_cast<uint8_t>(DimLevelType::kSingleton);
 }
 
 /// Check if the `DimLevelType` is ordered (regardless of storage format).
 constexpr MLIR_SPARSETENSOR_EXPORT bool isOrderedDLT(DimLevelType dlt) {
-  switch (dlt) {
-  case DimLevelType::kCompressedNo:
-  case DimLevelType::kCompressedNuNo:
-  case DimLevelType::kSingletonNo:
-  case DimLevelType::kSingletonNuNo:
-    return false;
-  default:
-    return true;
-  }
+  return !(static_cast<uint8_t>(dlt) & 2);
 }
 
 /// Check if the `DimLevelType` is unique (regardless of storage format).
 constexpr MLIR_SPARSETENSOR_EXPORT bool isUniqueDLT(DimLevelType dlt) {
-  switch (dlt) {
-  case DimLevelType::kCompressedNu:
-  case DimLevelType::kCompressedNuNo:
-  case DimLevelType::kSingletonNu:
-  case DimLevelType::kSingletonNuNo:
-    return false;
-  default:
-    return true;
-  }
+  return !(static_cast<uint8_t>(dlt) & 1);
 }
 
+// Ensure the above predicates work as intended.
+static_assert((!isCompressedDLT(DimLevelType::kDense) &&
+               isCompressedDLT(DimLevelType::kCompressed) &&
+               isCompressedDLT(DimLevelType::kCompressedNu) &&
+               isCompressedDLT(DimLevelType::kCompressedNo) &&
+               isCompressedDLT(DimLevelType::kCompressedNuNo) &&
+               !isCompressedDLT(DimLevelType::kSingleton) &&
+               !isCompressedDLT(DimLevelType::kSingletonNu) &&
+               !isCompressedDLT(DimLevelType::kSingletonNo) &&
+               !isCompressedDLT(DimLevelType::kSingletonNuNo)),
+              "isCompressedDLT definition is broken");
+
+static_assert((!isSingletonDLT(DimLevelType::kDense) &&
+               !isSingletonDLT(DimLevelType::kCompressed) &&
+               !isSingletonDLT(DimLevelType::kCompressedNu) &&
+               !isSingletonDLT(DimLevelType::kCompressedNo) &&
+               !isSingletonDLT(DimLevelType::kCompressedNuNo) &&
+               isSingletonDLT(DimLevelType::kSingleton) &&
+               isSingletonDLT(DimLevelType::kSingletonNu) &&
+               isSingletonDLT(DimLevelType::kSingletonNo) &&
+               isSingletonDLT(DimLevelType::kSingletonNuNo)),
+              "isSingletonDLT definition is broken");
+
+static_assert((isOrderedDLT(DimLevelType::kDense) &&
+               isOrderedDLT(DimLevelType::kCompressed) &&
+               isOrderedDLT(DimLevelType::kCompressedNu) &&
+               !isOrderedDLT(DimLevelType::kCompressedNo) &&
+               !isOrderedDLT(DimLevelType::kCompressedNuNo) &&
+               isOrderedDLT(DimLevelType::kSingleton) &&
+               isOrderedDLT(DimLevelType::kSingletonNu) &&
+               !isOrderedDLT(DimLevelType::kSingletonNo) &&
+               !isOrderedDLT(DimLevelType::kSingletonNuNo)),
+              "isOrderedDLT definition is broken");
+
+static_assert((isUniqueDLT(DimLevelType::kDense) &&
+               isUniqueDLT(DimLevelType::kCompressed) &&
+               !isUniqueDLT(DimLevelType::kCompressedNu) &&
+               isUniqueDLT(DimLevelType::kCompressedNo) &&
+               !isUniqueDLT(DimLevelType::kCompressedNuNo) &&
+               isUniqueDLT(DimLevelType::kSingleton) &&
+               !isUniqueDLT(DimLevelType::kSingletonNu) &&
+               isUniqueDLT(DimLevelType::kSingletonNo) &&
+               !isUniqueDLT(DimLevelType::kSingletonNuNo)),
+              "isUniqueDLT definition is broken");
+
 } // namespace sparse_tensor
 } // namespace mlir
 
 #endif // MLIR_EXECUTIONENGINE_SPARSETENSOR_ENUMS_H

mlir/include/mlir/ExecutionEngine/SparseTensor/Storage.h

void forallElements(ElementConsumer<V> yield, uint64_t parentPos,
                       uint64_t d) {
     // Recover the `<P,I,V>` type parameters of `src`.
     const auto &src = static_cast<const StorageImpl &>(this->src);
     if (d == Base::getRank()) {
       assert(parentPos < src.values.size() &&
              "Value position is out of bounds");
       // TODO: <https://github.com/llvm/llvm-project/issues/54179>
       yield(this->cursor, src.values[parentPos]);
-    } else if (src.isCompressedDim(d)) {
+      return;
+    }
+    const auto dlt = src.getDimType(d);
+    if (isCompressedDLT(dlt)) {
       // Look up the bounds of the `d`-level segment determined by the
       // `d-1`-level position `parentPos`.
       const std::vector<P> &pointersD = src.pointers[d];
       assert(parentPos + 1 < pointersD.size() &&
              "Parent pointer position is out of bounds");
       const uint64_t pstart = static_cast<uint64_t>(pointersD[parentPos]);
       const uint64_t pstop = static_cast<uint64_t>(pointersD[parentPos + 1]);
       // Loop-invariant code for looking up the `d`-level coordinates/indices.
       const std::vector<I> &indicesD = src.indices[d];
       assert(pstop <= indicesD.size() && "Index position is out of bounds");
       uint64_t &cursorReordD = this->cursor[this->reord[d]];
       for (uint64_t pos = pstart; pos < pstop; ++pos) {
         cursorReordD = static_cast<uint64_t>(indicesD[pos]);
         forallElements(yield, pos, d + 1);
       }
-    } else if (src.isSingletonDim(d)) {
-      MLIR_SPARSETENSOR_FATAL("unsupported dimension level type");
-    } else { // Dense dimension.
-      assert(src.isDenseDim(d)); // TODO: reuse the ASSERT_DENSE_DIM message
+    } else if (isSingletonDLT(dlt)) {
+      MLIR_SPARSETENSOR_FATAL("unsupported dimension level type: %d\n",
+                              static_cast<uint8_t>(dlt));
+    } else {
+      assert(isDenseDLT(dlt)); // TODO: reuse the ASSERT_DENSE_DIM message
       const uint64_t sz = src.getDimSizes()[d];
       const uint64_t pstart = parentPos * sz;
       uint64_t &cursorReordD = this->cursor[this->reord[d]];
       for (uint64_t i = 0; i < sz; ++i) {
         cursorReordD = i;
         forallElements(yield, pstart + i, d + 1);
       }
     }

mlir/lib/ExecutionEngine/SparseTensor/NNZ.cpp

case DimLevelType::kDense:
       break;
     case DimLevelType::kSingleton:
       // Singleton after Compressed causes no problems for allocating
       // `nnz` nor for the yieldPos loop.  This remains true even
       // when adding support for multiple compressed dimensions or
       // for dense-after-compressed.
       break;
     default:
-      MLIR_SPARSETENSOR_FATAL("unsupported dimension level type");
+      MLIR_SPARSETENSOR_FATAL("unsupported dimension level type: %d\n",
+                              static_cast<uint8_t>(dimTypes[r]));
     }
     sz = detail::checkedMul(sz, dimSizes[r]);
   }
 }
 
 /// Lexicographically enumerates all indicies for dimensions strictly
 /// less than `stopDim`, and passes their nnz statistic to the callback.
 /// Since our use-case only requires the statistic not the coordinates

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

#ifndef NDEBUG
   for (uint64_t i = 0; i < rank; ++i) {
     const uint64_t j = perm[i];
     if (j >= rank || seen[j])
       MLIR_SPARSETENSOR_FATAL("Not a permutation of 0..%" PRIu64 "\n", rank);
     seen[j] = true;
   }
 
   // Verify that the sparsity values are supported.
+  // TODO: update this check to match what we actually support.
   for (uint64_t i = 0; i < rank; ++i)
     if (sparsity[i] != DimLevelType::kDense &&
         sparsity[i] != DimLevelType::kCompressed)
-      MLIR_SPARSETENSOR_FATAL("Unsupported sparsity value %d\n",
-                              static_cast<int>(sparsity[i]));
+      MLIR_SPARSETENSOR_FATAL("unsupported dimension level type: %d\n",
+                              static_cast<uint8_t>(sparsity[i]));
 #endif
 
   // Convert external format to internal COO.
   auto *coo = SparseTensorCOO<V>::newSparseTensorCOO(rank, shape, perm, nse);
   std::vector<uint64_t> idx(rank);
   for (uint64_t i = 0, base = 0; i < nse; i++) {
     for (uint64_t r = 0; r < rank; r++)
       idx[perm[r]] = indices[base + r];

mlir/test/CAPI/sparse_tensor.c

MlirAttribute originalAttr =
       mlirAttributeParseGet(ctx, mlirStringRefCreateFromCString(originalAsm));
   // CHECK: isa: 1
   fprintf(stderr, "isa: %d\n",
           mlirAttributeIsASparseTensorEncodingAttr(originalAttr));
   MlirAffineMap dimOrdering =
       mlirSparseTensorEncodingAttrGetDimOrdering(originalAttr);
   // CHECK: (d0, d1, d2) -> (d0, d1, d2)
   mlirAffineMapDump(dimOrdering);
-  // CHECK: level_type: 0
-  // CHECK: level_type: 1
-  // CHECK: level_type: 1
+  // CHECK: level_type: 4
+  // CHECK: level_type: 8
+  // CHECK: level_type: 8
   int numLevelTypes = mlirSparseTensorEncodingGetNumDimLevelTypes(originalAttr);
   enum MlirSparseTensorDimLevelType *levelTypes =
       malloc(sizeof(enum MlirSparseTensorDimLevelType) * numLevelTypes);
   for (int i = 0; i < numLevelTypes; ++i) {
     levelTypes[i] =
         mlirSparseTensorEncodingAttrGetDimLevelType(originalAttr, i);
     fprintf(stderr, "level_type: %d\n", levelTypes[i]);
   }

mlir/test/Dialect/SparseTensor/conversion_sparse2dense.mlir

 }>
 
 // CHECK-LABEL: func @sparse_convert_1d(
 //  CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<13xi32>
 //   CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index
 //   CHECK-DAG: %[[I13:.*]] = arith.constant 13 : index
 //   CHECK-DAG: %[[AttrsS:.*]] = memref.alloca() : memref<1xi8>
 //   CHECK-DAG: %[[AttrsD:.*]] = memref.cast %[[AttrsS]] : memref<1xi8> to memref<?xi8>
-//   CHECK-DAG: %[[Attr0:.*]] = arith.constant 0 : i8
-//   CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I0]]] : memref<1xi8>
+//   CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8
+//   CHECK-DAG: memref.store %[[DenseDLT]], %[[AttrsS]][%[[I0]]] : memref<1xi8>
 //   CHECK-DAG: %[[SizesS:.*]] = memref.alloca() : memref<1xindex>
 //   CHECK-DAG: %[[SizesD:.*]] = memref.cast %[[SizesS]] : memref<1xindex> to memref<?xindex>
 //   CHECK-DAG: memref.store %[[I13]], %[[SizesS]][%[[I0]]] : memref<1xindex>
 //   CHECK-DAG: %[[PermS:.*]] = memref.alloca() : memref<1xindex>
 //   CHECK-DAG: %[[PermD:.*]] = memref.cast %[[PermS]] : memref<1xindex> to memref<?xindex>
 //   CHECK-DAG: memref.store %[[I0]], %[[PermS]][%[[I0]]] : memref<1xindex>
 //   CHECK-DAG: %[[zeroI32:.*]] = arith.constant 0 : i32
 //   CHECK-DAG: %[[ElemTpActionToIter:.*]] = arith.constant 6 : i32
func.func @sparse_convert_1d(%arg0: tensor<13xi32, #SparseVector>) -> tensor<13xi32> {
   return %0 : tensor<13xi32>
 }
 
 // CHECK-LABEL: func @sparse_convert_1d_dyn(
 //  CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<?xi32>
 //   CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index
 //   CHECK-DAG: %[[AttrsS:.*]] = memref.alloca() : memref<1xi8>
 //   CHECK-DAG: %[[AttrsD:.*]] = memref.cast %[[AttrsS]] : memref<1xi8> to memref<?xi8>
-//   CHECK-DAG: %[[Attr0:.*]] = arith.constant 0 : i8
-//   CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I0]]] : memref<1xi8>
+//   CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8
+//   CHECK-DAG: memref.store %[[DenseDLT]], %[[AttrsS]][%[[I0]]] : memref<1xi8>
 //   CHECK-DAG: %[[SizesS:.*]] = memref.alloca() : memref<1xindex>
 //   CHECK-DAG: %[[SizesD:.*]] = memref.cast %[[SizesS]] : memref<1xindex> to memref<?xindex>
 //   CHECK-DAG: %[[SizeI0:.*]] = call @sparseDimSize(%[[Arg]], %[[I0]]) : (!llvm.ptr<i8>, index) -> index
 //   CHECK-DAG: memref.store %[[SizeI0]], %[[SizesS]][%[[I0]]] : memref<1xindex>
 //   CHECK-DAG: %[[PermS:.*]] = memref.alloca() : memref<1xindex>
 //   CHECK-DAG: %[[PermD:.*]] = memref.cast %[[PermS]] : memref<1xindex> to memref<?xindex>
 //   CHECK-DAG: memref.store %[[I0]], %[[PermS]][%[[I0]]] : memref<1xindex>
 //   CHECK-DAG: %[[zeroI32:.*]] = arith.constant 0 : i32

 // CHECK-LABEL: func @sparse_convert_2d(
 //  CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<2x4xf64>
 //   CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index
 //   CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index
 //   CHECK-DAG: %[[I2:.*]] = arith.constant 2 : index
 //   CHECK-DAG: %[[I4:.*]] = arith.constant 4 : index
 //   CHECK-DAG: %[[AttrsS:.*]] = memref.alloca() : memref<2xi8>
 //   CHECK-DAG: %[[AttrsD:.*]] = memref.cast %[[AttrsS]] : memref<2xi8> to memref<?xi8>
-//   CHECK-DAG: %[[Attr0:.*]] = arith.constant 0 : i8
-//   CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I0]]] : memref<2xi8>
-//   CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I1]]] : memref<2xi8>
+//   CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8
+//   CHECK-DAG: memref.store %[[DenseDLT]], %[[AttrsS]][%[[I0]]] : memref<2xi8>
+//   CHECK-DAG: memref.store %[[DenseDLT]], %[[AttrsS]][%[[I1]]] : memref<2xi8>
 //   CHECK-DAG: %[[SizesS:.*]] = memref.alloca() : memref<2xindex>
 //   CHECK-DAG: %[[SizesD:.*]] = memref.cast %[[SizesS]] : memref<2xindex> to memref<?xindex>
 //   CHECK-DAG: memref.store %[[I2]], %[[SizesS]][%[[I0]]] : memref<2xindex>
 //   CHECK-DAG: memref.store %[[I4]], %[[SizesS]][%[[I1]]] : memref<2xindex>
 //   CHECK-DAG: %[[PermS:.*]] = memref.alloca() : memref<2xindex>
 //   CHECK-DAG: %[[PermD:.*]] = memref.cast %[[PermS]] : memref<2xindex> to memref<?xindex>
 //   CHECK-DAG: memref.store %[[I0]], %[[PermS]][%[[I0]]] : memref<2xindex>
 //   CHECK-DAG: memref.store %[[I1]], %[[PermS]][%[[I1]]] : memref<2xindex>

 
 // CHECK-LABEL: func @sparse_convert_2d_dyn0(
 //  CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<?x4xf64>
 //   CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index
 //   CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index
 //   CHECK-DAG: %[[I4:.*]] = arith.constant 4 : index
 //   CHECK-DAG: %[[AttrsS:.*]] = memref.alloca() : memref<2xi8>
 //   CHECK-DAG: %[[AttrsD:.*]] = memref.cast %[[AttrsS]] : memref<2xi8> to memref<?xi8>
-//   CHECK-DAG: %[[Attr0:.*]] = arith.constant 0 : i8
-//   CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I0]]] : memref<2xi8>
-//   CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I1]]] : memref<2xi8>
+//   CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8
+//   CHECK-DAG: memref.store %[[DenseDLT]], %[[AttrsS]][%[[I0]]] : memref<2xi8>
+//   CHECK-DAG: memref.store %[[DenseDLT]], %[[AttrsS]][%[[I1]]] : memref<2xi8>
 //   CHECK-DAG: %[[SizesS:.*]] = memref.alloca() : memref<2xindex>
 //   CHECK-DAG: %[[SizesD:.*]] = memref.cast %[[SizesS]] : memref<2xindex> to memref<?xindex>
 //   CHECK-DAG: %[[SizeI0:.*]] = call @sparseDimSize(%[[Arg]], %[[I0]]) : (!llvm.ptr<i8>, index) -> index
 //   CHECK-DAG: memref.store %[[SizeI0]], %[[SizesS]][%[[I0]]] : memref<2xindex>
 //   CHECK-DAG: memref.store %[[I4]], %[[SizesS]][%[[I1]]] : memref<2xindex>
 //   CHECK-DAG: %[[PermS:.*]] = memref.alloca() : memref<2xindex>
 //   CHECK-DAG: %[[PermD:.*]] = memref.cast %[[PermS]] : memref<2xindex> to memref<?xindex>
 //   CHECK-DAG: memref.store %[[I0]], %[[PermS]][%[[I0]]] : memref<2xindex>

 
 // CHECK-LABEL: func @sparse_convert_2d_dyn1(
 //  CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<2x?xf64>
 //   CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index
 //   CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index
 //   CHECK-DAG: %[[I2:.*]] = arith.constant 2 : index
 //   CHECK-DAG: %[[AttrsS:.*]] = memref.alloca() : memref<2xi8>
 //   CHECK-DAG: %[[AttrsD:.*]] = memref.cast %[[AttrsS]] : memref<2xi8> to memref<?xi8>
-//   CHECK-DAG: %[[Attr0:.*]] = arith.constant 0 : i8
-//   CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I0]]] : memref<2xi8>
-//   CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I1]]] : memref<2xi8>
+//   CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8
+//   CHECK-DAG: memref.store %[[DenseDLT]], %[[AttrsS]][%[[I0]]] : memref<2xi8>
+//   CHECK-DAG: memref.store %[[DenseDLT]], %[[AttrsS]][%[[I1]]] : memref<2xi8>
 //   CHECK-DAG: %[[SizesS:.*]] = memref.alloca() : memref<2xindex>
 //   CHECK-DAG: %[[SizesD:.*]] = memref.cast %[[SizesS]] : memref<2xindex> to memref<?xindex>
 //   CHECK-DAG: %[[SizeI1:.*]] = call @sparseDimSize(%[[Arg]], %[[I1]]) : (!llvm.ptr<i8>, index) -> index
 //   CHECK-DAG: memref.store %[[I2]], %[[SizesS]][%[[I0]]] : memref<2xindex>
 //   CHECK-DAG: memref.store %[[SizeI1]], %[[SizesS]][%[[I1]]] : memref<2xindex>
 //   CHECK-DAG: %[[PermS:.*]] = memref.alloca() : memref<2xindex>
 //   CHECK-DAG: %[[PermD:.*]] = memref.cast %[[PermS]] : memref<2xindex> to memref<?xindex>
 //   CHECK-DAG: memref.store %[[I0]], %[[PermS]][%[[I0]]] : memref<2xindex>

 }
 
 // CHECK-LABEL: func @sparse_convert_2d_dyn2(
 //  CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<?x?xf64>
 //   CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index
 //   CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index
 //   CHECK-DAG: %[[AttrsS:.*]] = memref.alloca() : memref<2xi8>
 //   CHECK-DAG: %[[AttrsD:.*]] = memref.cast %[[AttrsS]] : memref<2xi8> to memref<?xi8>
-//   CHECK-DAG: %[[Attr0:.*]] = arith.constant 0 : i8
-//   CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I0]]] : memref<2xi8>
-//   CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I1]]] : memref<2xi8>
+//   CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8
+//   CHECK-DAG: memref.store %[[DenseDLT]], %[[AttrsS]][%[[I0]]] : memref<2xi8>
+//   CHECK-DAG: memref.store %[[DenseDLT]], %[[AttrsS]][%[[I1]]] : memref<2xi8>
 //   CHECK-DAG: %[[SizesS:.*]] = memref.alloca() : memref<2xindex>
 //   CHECK-DAG: %[[SizesD:.*]] = memref.cast %[[SizesS]] : memref<2xindex> to memref<?xindex>
 //   CHECK-DAG: %[[SizeI0:.*]] = call @sparseDimSize(%[[Arg]], %[[I0]]) : (!llvm.ptr<i8>, index) -> index
 //   CHECK-DAG: %[[SizeI1:.*]] = call @sparseDimSize(%[[Arg]], %[[I1]]) : (!llvm.ptr<i8>, index) -> index
 //   CHECK-DAG: memref.store %[[SizeI0]], %[[SizesS]][%[[I0]]] : memref<2xindex>
 //   CHECK-DAG: memref.store %[[SizeI1]], %[[SizesS]][%[[I1]]] : memref<2xindex>
 //   CHECK-DAG: %[[PermS:.*]] = memref.alloca() : memref<2xindex>
 //   CHECK-DAG: %[[PermD:.*]] = memref.cast %[[PermS]] : memref<2xindex> to memref<?xindex>

 //  CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<2x3x4xf64>
 //   CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index
 //   CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index
 //   CHECK-DAG: %[[I2:.*]] = arith.constant 2 : index
 //   CHECK-DAG: %[[I3:.*]] = arith.constant 3 : index
 //   CHECK-DAG: %[[I4:.*]] = arith.constant 4 : index
 //   CHECK-DAG: %[[AttrsS:.*]] = memref.alloca() : memref<3xi8>
 //   CHECK-DAG: %[[AttrsD:.*]] = memref.cast %[[AttrsS]] : memref<3xi8> to memref<?xi8>
-//   CHECK-DAG: %[[Attr0:.*]] = arith.constant 0 : i8
-//   CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I0]]] : memref<3xi8>
-//   CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I1]]] : memref<3xi8>
-//   CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I2]]] : memref<3xi8>
+//   CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8
+//   CHECK-DAG: memref.store %[[DenseDLT]], %[[AttrsS]][%[[I0]]] : memref<3xi8>
+//   CHECK-DAG: memref.store %[[DenseDLT]], %[[AttrsS]][%[[I1]]] : memref<3xi8>
+//   CHECK-DAG: memref.store %[[DenseDLT]], %[[AttrsS]][%[[I2]]] : memref<3xi8>
 //   CHECK-DAG: %[[SizesS:.*]] = memref.alloca() : memref<3xindex>
 //   CHECK-DAG: %[[SizesD:.*]] = memref.cast %[[SizesS]] : memref<3xindex> to memref<?xindex>
 //   CHECK-DAG: memref.store %[[I2]], %[[SizesS]][%[[I0]]] : memref<3xindex>
 //   CHECK-DAG: memref.store %[[I3]], %[[SizesS]][%[[I1]]] : memref<3xindex>
 //   CHECK-DAG: memref.store %[[I4]], %[[SizesS]][%[[I2]]] : memref<3xindex>
 //   CHECK-DAG: %[[PermS:.*]] = memref.alloca() : memref<3xindex>
 //   CHECK-DAG: %[[PermD:.*]] = memref.cast %[[PermS]] : memref<3xindex> to memref<?xindex>
 //   CHECK-DAG: memref.store %[[I0]], %[[PermS]][%[[I0]]] : memref<3xindex>

mlir/test/Dialect/SparseTensor/sparse_concat.mlir

 // RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s
 
 #SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}>
 
 #SparseMatrix_P = #sparse_tensor.encoding<{
   dimLevelType = [ "compressed", "compressed" ],
   dimOrdering = affine_map<(i,j) -> (j,i)>
 }>
 
 // CHECK-LABEL: func.func @concat_mix_dense(
 // CHECK-SAME:    %[[TMP_arg0:.*]]: tensor<2x4xf64>,
 // CHECK-SAME:    %[[TMP_arg1:.*]]: !llvm.ptr<i8>)
 // CHECK-DAG:     %[[TMP_c2:.*]] = arith.constant 2 : index
 // CHECK-DAG:     %[[TMP_c6_i32:.*]] = arith.constant 6 : i32
 // CHECK-DAG:     %[[TMP_c1_i32:.*]] = arith.constant 1 : i32
 // CHECK-DAG:     %[[TMP_c0_i32:.*]] = arith.constant 0 : i32
-// CHECK-DAG:     %[[TMP_c1_i8:.*]] = arith.constant 1 : i8
+// CHECK-DAG:     %[[TMP_c8_i8:.*]] = arith.constant 8 : i8
 // CHECK-DAG:     %[[TMP_c3:.*]] = arith.constant 3 : index
 // CHECK-DAG:     %[[TMP_c1:.*]] = arith.constant 1 : index
 // CHECK-DAG:     %[[TMP_cst:.*]] = arith.constant 0.000000e+00 : f64
 // CHECK-DAG:     %[[TMP_c0:.*]] = arith.constant 0 : index
 // CHECK-DAG:     %[[TMP_c4:.*]] = arith.constant 4 : index
 // CHECK:         %[[TMP_0:.*]] = memref.alloc() : memref<5x4xf64>
 // CHECK:         linalg.fill ins(%[[TMP_cst]] : f64) outs(%[[TMP_0]] : memref<5x4xf64>)
 // CHECK:         scf.for %[[TMP_arg2:.*]] = %[[TMP_c0]] to %[[TMP_c2]] step %[[TMP_c1]] {
 // CHECK:           scf.for %[[TMP_arg3:.*]] = %[[TMP_c0]] to %[[TMP_c4]] step %[[TMP_c1]] {
 // CHECK:             %[[TMP_12:.*]] = tensor.extract %[[TMP_arg0]][%[[TMP_arg2]], %[[TMP_arg3]]] : tensor<2x4xf64>
 // CHECK:             %[[TMP_13:.*]] = arith.cmpf une, %[[TMP_12]], %[[TMP_cst]] : f64
 // CHECK:             scf.if %[[TMP_13]] {
 // CHECK:               memref.store %[[TMP_12]], %[[TMP_0]][%[[TMP_arg2]], %[[TMP_arg3]]] : memref<5x4xf64>
 // CHECK:             }
 // CHECK:           }
 // CHECK:         }
 // CHECK:         %[[TMP_1:.*]] = memref.alloca() : memref<2xi8>
 // CHECK:         %[[TMP_2:.*]] = memref.cast %[[TMP_1]] : memref<2xi8> to memref<?xi8>
-// CHECK:         memref.store %[[TMP_c1_i8]], %[[TMP_1]][%[[TMP_c0]]] : memref<2xi8>
-// CHECK:         memref.store %[[TMP_c1_i8]], %[[TMP_1]][%[[TMP_c1]]] : memref<2xi8>
+// CHECK:         memref.store %[[TMP_c8_i8]], %[[TMP_1]][%[[TMP_c0]]] : memref<2xi8>
+// CHECK:         memref.store %[[TMP_c8_i8]], %[[TMP_1]][%[[TMP_c1]]] : memref<2xi8>
 // CHECK:         %[[TMP_3:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:         %[[TMP_4:.*]] = memref.cast %[[TMP_3]] : memref<2xindex> to memref<?xindex>
 // CHECK:         memref.store %[[TMP_c3]], %[[TMP_3]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:         memref.store %[[TMP_c4]], %[[TMP_3]][%[[TMP_c1]]] : memref<2xindex>
 // CHECK:         %[[TMP_5:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:         %[[TMP_6:.*]] = memref.cast %[[TMP_5]] : memref<2xindex> to memref<?xindex>
 // CHECK:         memref.store %[[TMP_c0]], %[[TMP_5]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:         memref.store %[[TMP_c1]], %[[TMP_5]][%[[TMP_c1]]] : memref<2xindex>

 // CHECK-DAG:     %[[TMP_cst:.*]] = arith.constant 0.000000e+00 : f64
 // CHECK-DAG:     %[[TMP_c4_i32:.*]] = arith.constant 4 : i32
 // CHECK-DAG:     %[[TMP_c1_i32:.*]] = arith.constant 1 : i32
 // CHECK-DAG:     %[[TMP_c0_i32:.*]] = arith.constant 0 : i32
 // CHECK-DAG:     %[[TMP_c1:.*]] = arith.constant 1 : index
 // CHECK-DAG:     %[[TMP_c0:.*]] = arith.constant 0 : index
 // CHECK-DAG:     %[[TMP_c5:.*]] = arith.constant 5 : index
 // CHECK-DAG:     %[[TMP_c4:.*]] = arith.constant 4 : index
-// CHECK-DAG:     %[[TMP_c1_i8:.*]] = arith.constant 1 : i8
+// CHECK-DAG:     %[[TMP_c8_i8:.*]] = arith.constant 8 : i8
 // CHECK:         %[[TMP_0:.*]] = memref.alloca() : memref<2xi8>
 // CHECK:         %[[TMP_1:.*]] = memref.cast %[[TMP_0]] : memref<2xi8> to memref<?xi8>
-// CHECK:         memref.store %[[TMP_c1_i8]], %[[TMP_0]][%[[TMP_c0]]] : memref<2xi8>
-// CHECK:         memref.store %[[TMP_c1_i8]], %[[TMP_0]][%[[TMP_c1]]] : memref<2xi8>
+// CHECK:         memref.store %[[TMP_c8_i8]], %[[TMP_0]][%[[TMP_c0]]] : memref<2xi8>
+// CHECK:         memref.store %[[TMP_c8_i8]], %[[TMP_0]][%[[TMP_c1]]] : memref<2xi8>
 // CHECK:         %[[TMP_2:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:         %[[TMP_3:.*]] = memref.cast %[[TMP_2]] : memref<2xindex> to memref<?xindex>
 // CHECK:         memref.store %[[TMP_c5]], %[[TMP_2]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:         memref.store %[[TMP_c4]], %[[TMP_2]][%[[TMP_c1]]] : memref<2xindex>
 // CHECK:         %[[TMP_4:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:         %[[TMP_5:.*]] = memref.cast %[[TMP_4]] : memref<2xindex> to memref<?xindex>
 // CHECK:         memref.store %[[TMP_c0]], %[[TMP_4]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:         memref.store %[[TMP_c1]], %[[TMP_4]][%[[TMP_c1]]] : memref<2xindex>

 // CHECK:             scf.if %[[TMP_23]] {
 // CHECK:               memref.store %[[TMP_22]], %[[TMP_8]][] : memref<f64>
 // CHECK:               %[[TMP_24:.*]] = func.call @addEltF64(%[[TMP_7]], %[[TMP_8]], %[[TMP_10]], %[[TMP_5]]) : (!llvm.ptr<i8>, memref<f64>, memref<?xindex>, memref<?xindex>) -> !llvm.ptr<i8>
 // CHECK:             }
 // CHECK:           }
 // CHECK:         }
 // CHECK:         %[[TMP_11:.*]] = memref.alloca() : memref<2xi8>
 // CHECK:         %[[TMP_12:.*]] = memref.cast %[[TMP_11]] : memref<2xi8> to memref<?xi8>
-// CHECK:         memref.store %[[TMP_c1_i8]], %[[TMP_11]][%[[TMP_c0]]] : memref<2xi8>
-// CHECK:         memref.store %[[TMP_c1_i8]], %[[TMP_11]][%[[TMP_c1]]] : memref<2xi8>
+// CHECK:         memref.store %[[TMP_c8_i8]], %[[TMP_11]][%[[TMP_c0]]] : memref<2xi8>
+// CHECK:         memref.store %[[TMP_c8_i8]], %[[TMP_11]][%[[TMP_c1]]] : memref<2xi8>
 // CHECK:         %[[TMP_13:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:         %[[TMP_14:.*]] = memref.cast %[[TMP_13]] : memref<2xindex> to memref<?xindex>
 // CHECK:         memref.store %[[TMP_c3]], %[[TMP_13]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:         memref.store %[[TMP_c4]], %[[TMP_13]][%[[TMP_c1]]] : memref<2xindex>
 // CHECK:         %[[TMP_15:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:         %[[TMP_16:.*]] = memref.cast %[[TMP_15]] : memref<2xindex> to memref<?xindex>
 // CHECK:         memref.store %[[TMP_c0]], %[[TMP_15]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:         memref.store %[[TMP_c1]], %[[TMP_15]][%[[TMP_c1]]] : memref<2xindex>

 // CHECK-DAG:     %[[TMP_cst:.*]] = arith.constant 0.000000e+00 : f64
 // CHECK-DAG:     %[[TMP_c4_i32:.*]] = arith.constant 4 : i32
 // CHECK-DAG:     %[[TMP_c1_i32:.*]] = arith.constant 1 : i32
 // CHECK-DAG:     %[[TMP_c0_i32:.*]] = arith.constant 0 : i32
 // CHECK-DAG:     %[[TMP_c1:.*]] = arith.constant 1 : index
 // CHECK-DAG:     %[[TMP_c0:.*]] = arith.constant 0 : index
 // CHECK-DAG:     %[[TMP_c4:.*]] = arith.constant 4 : index
 // CHECK-DAG:     %[[TMP_c5:.*]] = arith.constant 5 : index
-// CHECK-DAG:     %[[TMP_c1_i8:.*]] = arith.constant 1 : i8
+// CHECK-DAG:     %[[TMP_c8_i8:.*]] = arith.constant 8 : i8
 // CHECK:         %[[TMP_0:.*]] = memref.alloca() : memref<2xi8>
 // CHECK:         %[[TMP_1:.*]] = memref.cast %[[TMP_0]] : memref<2xi8> to memref<?xi8>
-// CHECK:         memref.store %[[TMP_c1_i8]], %[[TMP_0]][%[[TMP_c0]]] : memref<2xi8>
-// CHECK:         memref.store %[[TMP_c1_i8]], %[[TMP_0]][%[[TMP_c1]]] : memref<2xi8>
+// CHECK:         memref.store %[[TMP_c8_i8]], %[[TMP_0]][%[[TMP_c0]]] : memref<2xi8>
+// CHECK:         memref.store %[[TMP_c8_i8]], %[[TMP_0]][%[[TMP_c1]]] : memref<2xi8>
 // CHECK:         %[[TMP_2:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:         %[[TMP_3:.*]] = memref.cast %[[TMP_2]] : memref<2xindex> to memref<?xindex>
 // CHECK:         memref.store %[[TMP_c4]], %[[TMP_2]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:         memref.store %[[TMP_c5]], %[[TMP_2]][%[[TMP_c1]]] : memref<2xindex>
 // CHECK:         %[[TMP_4:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:         %[[TMP_5:.*]] = memref.cast %[[TMP_4]] : memref<2xindex> to memref<?xindex>
 // CHECK:         memref.store %[[TMP_c1]], %[[TMP_4]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:         memref.store %[[TMP_c0]], %[[TMP_4]][%[[TMP_c1]]] : memref<2xindex>

 // CHECK:             scf.if %[[TMP_23]] {
 // CHECK:               memref.store %[[TMP_22]], %[[TMP_8]][] : memref<f64>
 // CHECK:               %[[TMP_24:.*]] = func.call @addEltF64(%[[TMP_7]], %[[TMP_8]], %[[TMP_10]], %[[TMP_5]]) : (!llvm.ptr<i8>, memref<f64>, memref<?xindex>, memref<?xindex>) -> !llvm.ptr<i8>
 // CHECK:             }
 // CHECK:           }
 // CHECK:         }
 // CHECK:         %[[TMP_11:.*]] = memref.alloca() : memref<2xi8>
 // CHECK:         %[[TMP_12:.*]] = memref.cast %[[TMP_11]] : memref<2xi8> to memref<?xi8>
-// CHECK:         memref.store %[[TMP_c1_i8]], %[[TMP_11]][%[[TMP_c0]]] : memref<2xi8>
-// CHECK:         memref.store %[[TMP_c1_i8]], %[[TMP_11]][%[[TMP_c1]]] : memref<2xi8>
+// CHECK:         memref.store %[[TMP_c8_i8]], %[[TMP_11]][%[[TMP_c0]]] : memref<2xi8>
+// CHECK:         memref.store %[[TMP_c8_i8]], %[[TMP_11]][%[[TMP_c1]]] : memref<2xi8>
 // CHECK:         %[[TMP_13:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:         %[[TMP_14:.*]] = memref.cast %[[TMP_13]] : memref<2xindex> to memref<?xindex>
 // CHECK:         memref.store %[[TMP_c4]], %[[TMP_13]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:         memref.store %[[TMP_c3]], %[[TMP_13]][%[[TMP_c1]]] : memref<2xindex>
 // CHECK:         %[[TMP_15:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:         %[[TMP_16:.*]] = memref.cast %[[TMP_15]] : memref<2xindex> to memref<?xindex>
 // CHECK:         memref.store %[[TMP_c0]], %[[TMP_15]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:         memref.store %[[TMP_c1]], %[[TMP_15]][%[[TMP_c1]]] : memref<2xindex>

 
 // CHECK-LABEL: func.func @concat_mix_dense_perm_dim1(
 // CHECK-SAME:     %[[TMP_arg0:.*]]: tensor<4x2xf64>,
 // CHECK-SAME:     %[[TMP_arg1:.*]]: !llvm.ptr<i8>)
 // CHECK-DAG:         %[[TMP_c2:.*]] = arith.constant 2 : index
 // CHECK-DAG:         %[[TMP_c6_i32:.*]] = arith.constant 6 : i32
 // CHECK-DAG:         %[[TMP_c1_i32:.*]] = arith.constant 1 : i32
 // CHECK-DAG:         %[[TMP_c0_i32:.*]] = arith.constant 0 : i32
-// CHECK-DAG:         %[[TMP_c1_i8:.*]] = arith.constant 1 : i8
+// CHECK-DAG:         %[[TMP_c8_i8:.*]] = arith.constant 8 : i8
 // CHECK-DAG:         %[[TMP_c3:.*]] = arith.constant 3 : index
 // CHECK-DAG:         %[[TMP_c1:.*]] = arith.constant 1 : index
 // CHECK-DAG:         %[[TMP_cst:.*]] = arith.constant 0.000000e+00 : f64
 // CHECK-DAG:         %[[TMP_c0:.*]] = arith.constant 0 : index
 // CHECK-DAG:         %[[TMP_c4:.*]] = arith.constant 4 : index
 // CHECK:         %[[TMP_0:.*]] = memref.alloc() : memref<4x5xf64>
 // CHECK:         linalg.fill ins(%[[TMP_cst]] : f64) outs(%[[TMP_0]] : memref<4x5xf64>)
 // CHECK:         scf.for %[[TMP_arg2:.*]] = %[[TMP_c0]] to %[[TMP_c4]] step %[[TMP_c1]] {
 // CHECK:           scf.for %[[TMP_arg3:.*]] = %[[TMP_c0]] to %[[TMP_c2]] step %[[TMP_c1]] {
 // CHECK:             %[[TMP_12:.*]] = tensor.extract %[[TMP_arg0]][%[[TMP_arg2]], %[[TMP_arg3]]] : tensor<4x2xf64>
 // CHECK:             %[[TMP_13:.*]] = arith.cmpf une, %[[TMP_12]], %[[TMP_cst]] : f64
 // CHECK:             scf.if %[[TMP_13]] {
 // CHECK:               memref.store %[[TMP_12]], %[[TMP_0]][%[[TMP_arg2]], %[[TMP_arg3]]] : memref<4x5xf64>
 // CHECK:             }
 // CHECK:           }
 // CHECK:         }
 // CHECK:         %[[TMP_1:.*]] = memref.alloca() : memref<2xi8>
 // CHECK:         %[[TMP_2:.*]] = memref.cast %[[TMP_1]] : memref<2xi8> to memref<?xi8>
-// CHECK:         memref.store %[[TMP_c1_i8]], %[[TMP_1]][%[[TMP_c0]]] : memref<2xi8>
-// CHECK:         memref.store %[[TMP_c1_i8]], %[[TMP_1]][%[[TMP_c1]]] : memref<2xi8>
+// CHECK:         memref.store %[[TMP_c8_i8]], %[[TMP_1]][%[[TMP_c0]]] : memref<2xi8>
+// CHECK:         memref.store %[[TMP_c8_i8]], %[[TMP_1]][%[[TMP_c1]]] : memref<2xi8>
 // CHECK:         %[[TMP_3:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:         %[[TMP_4:.*]] = memref.cast %[[TMP_3]] : memref<2xindex> to memref<?xindex>
 // CHECK:         memref.store %[[TMP_c4]], %[[TMP_3]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:         memref.store %[[TMP_c3]], %[[TMP_3]][%[[TMP_c1]]] : memref<2xindex>
 // CHECK:         %[[TMP_5:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:         %[[TMP_6:.*]] = memref.cast %[[TMP_5]] : memref<2xindex> to memref<?xindex>
 // CHECK:         memref.store %[[TMP_c0]], %[[TMP_5]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:         memref.store %[[TMP_c1]], %[[TMP_5]][%[[TMP_c1]]] : memref<2xindex>

 
 // CHECK-LABEL: func.func @concat_mix_dense_perm_dim1_dyn(
 // CHECK-SAME:      %[[TMP_arg0:.*]]: tensor<3x2xf64>,
 // CHECK-SAME:      %[[TMP_arg1:.*]]: !llvm.ptr<i8>) 
 // CHECK-DAG:       %[[TMP_c2:.*]] = arith.constant 2 : index
 // CHECK-DAG:       %[[TMP_c6_i32:.*]] = arith.constant 6 : i32
 // CHECK-DAG:       %[[TMP_c1_i32:.*]] = arith.constant 1 : i32
 // CHECK-DAG:       %[[TMP_c0_i32:.*]] = arith.constant 0 : i32
-// CHECK-DAG:       %[[TMP_c1_i8:.*]] = arith.constant 1 : i8
+// CHECK-DAG:       %[[TMP_c8_i8:.*]] = arith.constant 8 : i8
 // CHECK-DAG:       %[[TMP_cst:.*]] = arith.constant 0.000000e+00 : f64
 // CHECK-DAG:       %[[TMP_c0:.*]] = arith.constant 0 : index
 // CHECK-DAG:       %[[TMP_c3:.*]] = arith.constant 3 : index
 // CHECK-DAG:       %[[TMP_c1:.*]] = arith.constant 1 : index
 // CHECK:           %[[TMP_0:.*]] = memref.alloc() : memref<3x5xf64>
 // CHECK:           %[[TMP_1:.*]] = memref.cast %[[TMP_0]] : memref<3x5xf64> to memref<?x?xf64>
 // CHECK:           linalg.fill ins(%[[TMP_cst]] : f64) outs(%[[TMP_0]] : memref<3x5xf64>)
 // CHECK:           scf.for %[[TMP_arg2:.*]] = %[[TMP_c0]] to %[[TMP_c3]] step %[[TMP_c1]] {
 // CHECK:             scf.for %[[TMP_arg3:.*]] = %[[TMP_c0]] to %[[TMP_c2]] step %[[TMP_c1]] {
 // CHECK:               %[[TMP_13:.*]] = tensor.extract %[[TMP_arg0]][%[[TMP_arg2]], %[[TMP_arg3]]] : tensor<3x2xf64>
 // CHECK:               %[[TMP_14:.*]] = arith.cmpf une, %[[TMP_13]], %[[TMP_cst]] : f64
 // CHECK:               scf.if %[[TMP_14]] {
 // CHECK:                 memref.store %[[TMP_13]], %[[TMP_0]][%[[TMP_arg2]], %[[TMP_arg3]]] : memref<3x5xf64>
 // CHECK:               }
 // CHECK:             }
 // CHECK:           }
 // CHECK:           %[[TMP_2:.*]] = memref.alloca() : memref<2xi8>
 // CHECK:           %[[TMP_3:.*]] = memref.cast %[[TMP_2]] : memref<2xi8> to memref<?xi8>
-// CHECK:           memref.store %[[TMP_c1_i8]], %[[TMP_2]][%[[TMP_c0]]] : memref<2xi8>
-// CHECK:           memref.store %[[TMP_c1_i8]], %[[TMP_2]][%[[TMP_c1]]] : memref<2xi8>
+// CHECK:           memref.store %[[TMP_c8_i8]], %[[TMP_2]][%[[TMP_c0]]] : memref<2xi8>
+// CHECK:           memref.store %[[TMP_c8_i8]], %[[TMP_2]][%[[TMP_c1]]] : memref<2xi8>
 // CHECK:           %[[TMP_4:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:           %[[TMP_5:.*]] = memref.cast %[[TMP_4]] : memref<2xindex> to memref<?xindex>
 // CHECK:           memref.store %[[TMP_c3]], %[[TMP_4]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:           memref.store %[[TMP_c3]], %[[TMP_4]][%[[TMP_c1]]] : memref<2xindex>
 // CHECK:           %[[TMP_6:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:           %[[TMP_7:.*]] = memref.cast %[[TMP_6]] : memref<2xindex> to memref<?xindex>
 // CHECK:           memref.store %[[TMP_c0]], %[[TMP_6]][%[[TMP_c0]]] : memref<2xindex>
 // CHECK:           memref.store %[[TMP_c1]], %[[TMP_6]][%[[TMP_c1]]] : memref<2xindex>

mlir/test/Dialect/SparseTensor/sparse_fill_zero.mlir

 // RUN: mlir-opt %s --linalg-generalize-named-ops --sparsification --sparse-tensor-conversion --canonicalize --cse | FileCheck %s
 
 #DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>
 
 // CHECK-LABEL:   func.func @fill_zero_after_alloc(
 // CHECK-SAME:      %[[VAL_0:.*]]: !llvm.ptr<i8>,
 // CHECK-SAME:      %[[VAL_1:.*]]: !llvm.ptr<i8>) -> !llvm.ptr<i8> {
 // CHECK-DAG:       %[[VAL_2:.*]] = arith.constant 0.000000e+00 : f64
 // CHECK-DAG:       %[[VAL_3:.*]] = arith.constant 1 : i32
 // CHECK-DAG:       %[[VAL_4:.*]] = arith.constant 0 : i32
 // CHECK-DAG:       %[[VAL_5:.*]] = arith.constant 0 : index
 // CHECK-DAG:       %[[VAL_6:.*]] = arith.constant 1 : index
 // CHECK-DAG:       %[[VAL_7:.*]] = arith.constant false
 // CHECK-DAG:       %[[VAL_8:.*]] = arith.constant true
 // CHECK-DAG:       %[[VAL_9:.*]] = arith.constant 100 : index
 // CHECK-DAG:       %[[VAL_10:.*]] = arith.constant 300 : index
-// CHECK-DAG:       %[[VAL_11:.*]] = arith.constant 1 : i8
+// CHECK-DAG:       %[[VAL_11:.*]] = arith.constant 8 : i8
 // CHECK:           %[[VAL_12:.*]] = memref.alloca() : memref<2xi8>
 // CHECK:           %[[VAL_13:.*]] = memref.cast %[[VAL_12]] : memref<2xi8> to memref<?xi8>
 // CHECK:           memref.store %[[VAL_11]], %[[VAL_12]]{{\[}}%[[VAL_5]]] : memref<2xi8>
 // CHECK:           memref.store %[[VAL_11]], %[[VAL_12]]{{\[}}%[[VAL_6]]] : memref<2xi8>
 // CHECK:           %[[VAL_14:.*]] = memref.alloca() : memref<2xindex>
 // CHECK:           %[[VAL_15:.*]] = memref.cast %[[VAL_14]] : memref<2xindex> to memref<?xindex>
 // CHECK:           memref.store %[[VAL_9]], %[[VAL_14]]{{\[}}%[[VAL_5]]] : memref<2xindex>
 // CHECK:           memref.store %[[VAL_10]], %[[VAL_14]]{{\[}}%[[VAL_6]]] : memref<2xindex>