Commit bd5494d1 authored by Aart Bik's avatar Aart Bik
Browse files

[mlir][sparse] make index type explicit in public API of support library 

The current implementation used explicit index->int64_t casts for some, but
not all instances of passing values of type "index" in and from the sparse
support library. This revision makes the situation more consistent by
using new "index_t" type at all such places  (which allows for less trivial
casting in the generated MLIR code).  Note that the current revision still
assumes that "index" is 64-bit wide. If we want to support targets with
alternative "index" bit widths, we need to build the support library different.
But the current revision is a step forward by making this requirement explicit
and more visible.

Reviewed By: wrengr

Differential Revision: https://reviews.llvm.org/D112122
parent 35037ae1

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp

+14 −22
Original line number Diff line number Diff line
@@ -45,7 +45,7 @@ enum Action : uint32_t { 


/// Returns internal type encoding for primary storage. Keep these

/// values consistent with the sparse runtime support library.

static unsigned getPrimaryTypeEncoding(Type tp) {

static uint32_t getPrimaryTypeEncoding(Type tp) {

  if (tp.isF64())

    return 1;

  if (tp.isF32())
@@ -63,7 +63,7 @@ static unsigned getPrimaryTypeEncoding(Type tp) { 


/// Returns internal type encoding for overhead storage. Keep these

/// values consistent with the sparse runtime support library.

static unsigned getOverheadTypeEncoding(unsigned width) {

static uint32_t getOverheadTypeEncoding(unsigned width) {

  switch (width) {

  default:

    return 1;
@@ -78,7 +78,7 @@ static unsigned getOverheadTypeEncoding(unsigned width) { 


/// Returns internal dimension level type encoding. Keep these

/// values consistent with the sparse runtime support library.

static unsigned

static uint32_t

getDimLevelTypeEncoding(SparseTensorEncodingAttr::DimLevelType dlt) {

  switch (dlt) {

  case SparseTensorEncodingAttr::DimLevelType::Dense:
@@ -103,12 +103,6 @@ inline static Value constantIndex(ConversionPatternRewriter &rewriter, 
  return rewriter.create<arith::ConstantIndexOp>(loc, i);

}



/// Generates a constant of `i64` type.

inline static Value constantI64(ConversionPatternRewriter &rewriter,

                                Location loc, int64_t i) {

  return rewriter.create<arith::ConstantIntOp>(loc, i, 64);

}



/// Generates a constant of `i32` type.

inline static Value constantI32(ConversionPatternRewriter &rewriter,

                                Location loc, int32_t i) {
@@ -246,11 +240,9 @@ static void newParams(ConversionPatternRewriter &rewriter, 
  params.push_back(genBuffer(rewriter, loc, attrs));

  // Dimension sizes array of the enveloping tensor. Useful for either

  // verification of external data, or for construction of internal data.

  // The index type is casted to I64 for API consistency.

  Type iTp = rewriter.getI64Type();

  SmallVector<Value, 4> sizes;

  for (Value s : szs)

    sizes.push_back(rewriter.create<arith::IndexCastOp>(loc, s, iTp));

    sizes.push_back(s);

  params.push_back(genBuffer(rewriter, loc, sizes));

  // Dimension order permutation array. This is the "identity" permutation by

  // default, or otherwise the "reverse" permutation of a given ordering, so
@@ -258,21 +250,21 @@ static void newParams(ConversionPatternRewriter &rewriter, 
  SmallVector<Value, 4> rev(sz);

  if (AffineMap p = enc.getDimOrdering()) {

    for (unsigned i = 0; i < sz; i++)

      rev[p.getDimPosition(i)] = constantI64(rewriter, loc, i);

      rev[p.getDimPosition(i)] = constantIndex(rewriter, loc, i);

  } else {

    for (unsigned i = 0; i < sz; i++)

      rev[i] = constantI64(rewriter, loc, i);

      rev[i] = constantIndex(rewriter, loc, i);

  }

  params.push_back(genBuffer(rewriter, loc, rev));

  // Secondary and primary types encoding.

  ShapedType resType = op->getResult(0).getType().cast<ShapedType>();

  unsigned secPtr = getOverheadTypeEncoding(enc.getPointerBitWidth());

  unsigned secInd = getOverheadTypeEncoding(enc.getIndexBitWidth());

  unsigned primary = getPrimaryTypeEncoding(resType.getElementType());

  uint32_t secPtr = getOverheadTypeEncoding(enc.getPointerBitWidth());

  uint32_t secInd = getOverheadTypeEncoding(enc.getIndexBitWidth());

  uint32_t primary = getPrimaryTypeEncoding(resType.getElementType());

  assert(primary);

  params.push_back(constantI64(rewriter, loc, secPtr));

  params.push_back(constantI64(rewriter, loc, secInd));

  params.push_back(constantI64(rewriter, loc, primary));

  params.push_back(constantI32(rewriter, loc, secPtr));

  params.push_back(constantI32(rewriter, loc, secInd));

  params.push_back(constantI32(rewriter, loc, primary));

  // User action and pointer.

  Type pTp = LLVM::LLVMPointerType::get(rewriter.getI8Type());

  if (!ptr)
@@ -608,7 +600,7 @@ public: 
    Type eltType = resType.cast<ShapedType>().getElementType();

    StringRef name;

    if (eltType.isIndex())

      name = "sparsePointers"; // 64-bit, but its own name for unique signature

      name = "sparsePointers";

    else if (eltType.isInteger(64))

      name = "sparsePointers64";

    else if (eltType.isInteger(32))
@@ -637,7 +629,7 @@ public: 
    Type eltType = resType.cast<ShapedType>().getElementType();

    StringRef name;

    if (eltType.isIndex())

      name = "sparseIndices"; // 64-bit, but its own name for unique signature

      name = "sparseIndices";

    else if (eltType.isInteger(64))

      name = "sparseIndices64";

    else if (eltType.isInteger(32))

mlir/lib/ExecutionEngine/SparseUtils.cpp

+34 −27
Original line number Diff line number Diff line
@@ -273,7 +273,7 @@ public: 
    if (tensor) {

      assert(tensor->getRank() == rank);

      for (uint64_t r = 0; r < rank; r++)

        assert(tensor->getSizes()[perm[r]] == sizes[r] || sizes[r] == 0);

        assert(sizes[r] == 0 || tensor->getSizes()[perm[r]] == sizes[r]);

      tensor->sort(); // sort lexicographically

      n = new SparseTensorStorage<P, I, V>(tensor->getSizes(), perm, sparsity,

                                           tensor);
@@ -306,8 +306,8 @@ private: 
    while (lo < hi) {

      assert(lo < elements.size() && hi <= elements.size());

      // Find segment in interval with same index elements in this dimension.

      unsigned idx = elements[lo].indices[d];

      unsigned seg = lo + 1;

      uint64_t idx = elements[lo].indices[d];

      uint64_t seg = lo + 1;

      while (seg < hi && elements[seg].indices[d] == idx)

        seg++;

      // Handle segment in interval for sparse or dense dimension.
@@ -505,14 +505,12 @@ static SparseTensorCOO<V> *openSparseTensorCOO(char *filename, uint64_t rank, 


extern "C" {



/// Helper method to read a sparse tensor filename from the environment,

/// defined with the naming convention ${TENSOR0}, ${TENSOR1}, etc.

char *getTensorFilename(uint64_t id) {

  char var[80];

  sprintf(var, "TENSOR%" PRIu64, id);

  char *env = getenv(var);

  return env;

}

/// This type is used in the public API at all places where MLIR expects

/// values with the built-in type "index". For now, we simply assume that

/// type is 64-bit, but targets with different "index" bit widths should link

/// with an alternatively built runtime support library.

// TODO: support such targets?

typedef uint64_t index_t;



//===----------------------------------------------------------------------===//

//
@@ -525,9 +523,9 @@ char *getTensorFilename(uint64_t id) { 
//

//===----------------------------------------------------------------------===//



enum OverheadTypeEnum : uint64_t { kU64 = 1, kU32 = 2, kU16 = 3, kU8 = 4 };

enum OverheadTypeEnum : uint32_t { kU64 = 1, kU32 = 2, kU16 = 3, kU8 = 4 };



enum PrimaryTypeEnum : uint64_t {

enum PrimaryTypeEnum : uint32_t {

  kF64 = 1,

  kF32 = 2,

  kI64 = 3,
@@ -576,7 +574,7 @@ enum Action : uint32_t { 


#define IMPL2(NAME, TYPE, LIB)                                                 \

  void _mlir_ciface_##NAME(StridedMemRefType<TYPE, 1> *ref, void *tensor,      \

                           uint64_t d) {                                       \

                           index_t d) {                                        \

    assert(ref);                                                               \

    assert(tensor);                                                            \

    std::vector<TYPE> *v;                                                      \
@@ -589,17 +587,17 @@ enum Action : uint32_t { 


#define IMPL3(NAME, TYPE)                                                      \

  void *_mlir_ciface_##NAME(void *tensor, TYPE value,                          \

                            StridedMemRefType<uint64_t, 1> *iref,              \

                            StridedMemRefType<uint64_t, 1> *pref) {            \

                            StridedMemRefType<index_t, 1> *iref,               \

                            StridedMemRefType<index_t, 1> *pref) {             \

    assert(tensor);                                                            \

    assert(iref);                                                              \

    assert(pref);                                                              \

    assert(iref->strides[0] == 1 && pref->strides[0] == 1);                    \

    assert(iref->sizes[0] == pref->sizes[0]);                                  \

    const uint64_t *indx = iref->data + iref->offset;                          \

    const uint64_t *perm = pref->data + pref->offset;                          \

    const index_t *indx = iref->data + iref->offset;                           \

    const index_t *perm = pref->data + pref->offset;                           \

    uint64_t isize = iref->sizes[0];                                           \

    std::vector<uint64_t> indices(isize);                                      \

    std::vector<index_t> indices(isize);                                       \

    for (uint64_t r = 0; r < isize; r++)                                       \

      indices[perm[r]] = indx[r];                                              \

    static_cast<SparseTensorCOO<TYPE> *>(tensor)->add(indices, value);         \
@@ -617,17 +615,17 @@ enum Action : uint32_t { 
/// kToCOO = returns coordinate scheme from storage in ptr to use with kFromCOO

void *

_mlir_ciface_newSparseTensor(StridedMemRefType<uint8_t, 1> *aref, // NOLINT

                             StridedMemRefType<uint64_t, 1> *sref,

                             StridedMemRefType<uint64_t, 1> *pref,

                             uint64_t ptrTp, uint64_t indTp, uint64_t valTp,

                             StridedMemRefType<index_t, 1> *sref,

                             StridedMemRefType<index_t, 1> *pref,

                             uint32_t ptrTp, uint32_t indTp, uint32_t valTp,

                             uint32_t action, void *ptr) {

  assert(aref && sref && pref);

  assert(aref->strides[0] == 1 && sref->strides[0] == 1 &&

         pref->strides[0] == 1);

  assert(aref->sizes[0] == sref->sizes[0] && sref->sizes[0] == pref->sizes[0]);

  const uint8_t *sparsity = aref->data + aref->offset;

  const uint64_t *sizes = sref->data + sref->offset;

  const uint64_t *perm = pref->data + pref->offset;

  const index_t *sizes = sref->data + sref->offset;

  const index_t *perm = pref->data + pref->offset;

  uint64_t rank = aref->sizes[0];



  // Double matrices with all combinations of overhead storage.
@@ -687,12 +685,12 @@ _mlir_ciface_newSparseTensor(StridedMemRefType<uint8_t, 1> *aref, // NOLINT 
}



/// Methods that provide direct access to pointers, indices, and values.

IMPL2(sparsePointers, uint64_t, getPointers)

IMPL2(sparsePointers, index_t, getPointers)

IMPL2(sparsePointers64, uint64_t, getPointers)

IMPL2(sparsePointers32, uint32_t, getPointers)

IMPL2(sparsePointers16, uint16_t, getPointers)

IMPL2(sparsePointers8, uint8_t, getPointers)

IMPL2(sparseIndices, uint64_t, getIndices)

IMPL2(sparseIndices, index_t, getIndices)

IMPL2(sparseIndices64, uint64_t, getIndices)

IMPL2(sparseIndices32, uint32_t, getIndices)

IMPL2(sparseIndices16, uint16_t, getIndices)
@@ -726,8 +724,17 @@ IMPL3(addEltI8, int8_t) 
//

//===----------------------------------------------------------------------===//



/// Helper method to read a sparse tensor filename from the environment,

/// defined with the naming convention ${TENSOR0}, ${TENSOR1}, etc.

char *getTensorFilename(index_t id) {

  char var[80];

  sprintf(var, "TENSOR%" PRIu64, id);

  char *env = getenv(var);

  return env;

}



/// Returns size of sparse tensor in given dimension.

uint64_t sparseDimSize(void *tensor, uint64_t d) {

index_t sparseDimSize(void *tensor, index_t d) {

  return static_cast<SparseTensorStorageBase *>(tensor)->getDimSize(d);

}

mlir/test/Dialect/SparseTensor/conversion.mlir

+38 −40
Original line number Diff line number Diff line
@@ -70,11 +70,11 @@ func @sparse_dim3d_const(%arg0: tensor<10x20x30xf64, #SparseTensor>) -> index { 
// CHECK-LABEL: func @sparse_new1d(

//  CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) -> !llvm.ptr<i8>

//   CHECK-DAG: %[[P:.*]] = memref.alloca() : memref<1xi8>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<1xi64>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<1xi64>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<1xindex>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<1xindex>

//   CHECK-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<1xi8> to memref<?xi8>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<1xi64> to memref<?xi64>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<1xi64> to memref<?xi64>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<1xindex> to memref<?xindex>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<1xindex> to memref<?xindex>

//       CHECK: %[[T:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[A]])

//       CHECK: return %[[T]] : !llvm.ptr<i8>

func @sparse_new1d(%arg0: !llvm.ptr<i8>) -> tensor<128xf64, #SparseVector> {
@@ -85,11 +85,11 @@ func @sparse_new1d(%arg0: !llvm.ptr<i8>) -> tensor<128xf64, #SparseVector> { 
// CHECK-LABEL: func @sparse_new2d(

//  CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) -> !llvm.ptr<i8>

//   CHECK-DAG: %[[P:.*]] = memref.alloca() : memref<2xi8>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<2xi64>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<2xi64>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<2xindex>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<2xindex>

//   CHECK-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<2xi8> to memref<?xi8>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<2xi64> to memref<?xi64>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<2xi64> to memref<?xi64>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<2xindex> to memref<?xindex>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<2xindex> to memref<?xindex>

//       CHECK: %[[T:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[A]])

//       CHECK: return %[[T]] : !llvm.ptr<i8>

func @sparse_new2d(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf32, #SparseMatrix> {
@@ -100,11 +100,11 @@ func @sparse_new2d(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf32, #SparseMatrix> { 
// CHECK-LABEL: func @sparse_new3d(

//  CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) -> !llvm.ptr<i8>

//   CHECK-DAG: %[[P:.*]] = memref.alloca() : memref<3xi8>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<3xi64>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<3xi64>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<3xindex>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<3xindex>

//   CHECK-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<3xi8> to memref<?xi8>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<3xi64> to memref<?xi64>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<3xi64> to memref<?xi64>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<3xindex> to memref<?xindex>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<3xindex> to memref<?xindex>

//       CHECK: %[[T:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[A]])

//       CHECK: return %[[T]] : !llvm.ptr<i8>

func @sparse_new3d(%arg0: !llvm.ptr<i8>) -> tensor<?x?x?xf32, #SparseTensor> {
@@ -118,15 +118,13 @@ func @sparse_new3d(%arg0: !llvm.ptr<i8>) -> tensor<?x?x?xf32, #SparseTensor> { 
//   CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index

//   CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index

//   CHECK-DAG: %[[P:.*]] = memref.alloca() : memref<2xi8>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<2xi64>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<2xi64>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<2xindex>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<2xindex>

//   CHECK-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<2xi8> to memref<?xi8>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<2xi64> to memref<?xi64>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<2xi64> to memref<?xi64>

//   CHECK-DAG: %[[II:.*]] = arith.index_cast %[[I]] : index to i64

//   CHECK-DAG: %[[JJ:.*]] = arith.index_cast %[[J]] : index to i64

//   CHECK-DAG: memref.store %[[II]], %[[Q]][%[[C0]]] : memref<2xi64>

//   CHECK-DAG: memref.store %[[JJ]], %[[Q]][%[[C1]]] : memref<2xi64>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<2xindex> to memref<?xindex>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<2xindex> to memref<?xindex>

//   CHECK-DAG: memref.store %[[I]], %[[Q]][%[[C0]]] : memref<2xindex>

//   CHECK-DAG: memref.store %[[J]], %[[Q]][%[[C1]]] : memref<2xindex>

//       CHECK: %[[NP:.*]] = llvm.mlir.null : !llvm.ptr<i8>

//       CHECK: %[[T:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[NP]])

//       CHECK: return %[[T]] : !llvm.ptr<i8>
@@ -158,11 +156,11 @@ func @sparse_nop_convert(%arg0: tensor<64xf32, #SparseVector>) -> tensor<64xf32, 
//   CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index

//   CHECK-DAG: %[[U:.*]] = tensor.dim %[[A]], %[[C0]] : tensor<?xi32>

//   CHECK-DAG: %[[P:.*]] = memref.alloca() : memref<1xi8>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<1xi64>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<1xi64>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<1xindex>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<1xindex>

//   CHECK-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<1xi8> to memref<?xi8>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<1xi64> to memref<?xi64>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<1xi64> to memref<?xi64>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<1xindex> to memref<?xindex>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<1xindex> to memref<?xindex>

//       CHECK: %[[NP:.*]] = llvm.mlir.null : !llvm.ptr<i8>

//       CHECK: %[[C:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[NP]])

//       CHECK: %[[M:.*]] = memref.alloca() : memref<1xindex>
@@ -182,11 +180,11 @@ func @sparse_convert_1d(%arg0: tensor<?xi32>) -> tensor<?xi32, #SparseVector> { 
// CHECK-LABEL: func @sparse_convert_1d_ss(

//  CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>)

//   CHECK-DAG: %[[P:.*]] = memref.alloca() : memref<1xi8>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<1xi64>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<1xi64>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<1xindex>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<1xindex>

//   CHECK-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<1xi8> to memref<?xi8>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<1xi64> to memref<?xi64>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<1xi64> to memref<?xi64>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<1xindex> to memref<?xindex>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<1xindex> to memref<?xindex>

//       CHECK: %[[C:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[A]])

//       CHECK: %[[T:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[C]])

//       CHECK: return %[[T]] : !llvm.ptr<i8>
@@ -200,11 +198,11 @@ func @sparse_convert_1d_ss(%arg0: tensor<?xf32, #SparseVector64>) -> tensor<?xf3 
//   CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index

//   CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index

//   CHECK-DAG: %[[P:.*]] = memref.alloca() : memref<2xi8>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<2xi64>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<2xi64>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<2xindex>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<2xindex>

//   CHECK-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<2xi8> to memref<?xi8>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<2xi64> to memref<?xi64>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<2xi64> to memref<?xi64>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<2xindex> to memref<?xindex>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<2xindex> to memref<?xindex>

//       CHECK: %[[NP:.*]] = llvm.mlir.null : !llvm.ptr<i8>

//       CHECK: %[[C:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[NP]])

//       CHECK: %[[M:.*]] = memref.alloca() : memref<2xindex>
@@ -229,11 +227,11 @@ func @sparse_convert_2d(%arg0: tensor<2x4xf64>) -> tensor<2x4xf64, #SparseMatrix 
//   CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index

//   CHECK-DAG: %[[C2:.*]] = arith.constant 2 : index

//   CHECK-DAG: %[[P:.*]] = memref.alloca() : memref<2xi8>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<2xi64>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<2xi64>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<2xindex>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<2xindex>

//   CHECK-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<2xi8> to memref<?xi8>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<2xi64> to memref<?xi64>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<2xi64> to memref<?xi64>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<2xindex> to memref<?xindex>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<2xindex> to memref<?xindex>

//       CHECK: %[[NP:.*]] = llvm.mlir.null : !llvm.ptr<i8>

//       CHECK: %[[C:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[NP]])

//       CHECK: %[[M:.*]] = memref.alloca() : memref<2xindex>
@@ -263,11 +261,11 @@ func @sparse_constant() -> tensor<8x7xf32, #SparseMatrix>{ 
//   CHECK-DAG: %[[U2:.*]] = tensor.dim %[[A]], %[[C1]] : tensor<?x?x?xf64>

//   CHECK-DAG: %[[U3:.*]] = tensor.dim %[[A]], %[[C2]] : tensor<?x?x?xf64>

//   CHECK-DAG: %[[P:.*]] = memref.alloca() : memref<3xi8>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<3xi64>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<3xi64>

//   CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<3xindex>

//   CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<3xindex>

//   CHECK-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<3xi8> to memref<?xi8>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<3xi64> to memref<?xi64>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<3xi64> to memref<?xi64>

//   CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<3xindex> to memref<?xindex>

//   CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<3xindex> to memref<?xindex>

//       CHECK: %[[NP:.*]] = llvm.mlir.null : !llvm.ptr<i8>

//       CHECK: %[[C:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[NP]])

//       CHECK: %[[M:.*]] = memref.alloca() : memref<3xindex>