This is an archive of the discontinued LLVM Phabricator instance.

Differential D112674

[mlir][sparse] Adding dynamic-size support for sparse=>dense conversion
ClosedPublic

Authored by wrengr on Oct 27 2021, 4:08 PM.

Details

Reviewers
aartbik
bixia
penpornk
Commits
rG5389cdc8f67a: [mlir][sparse] Adding dynamic-size support for sparse=>dense conversion
Summary

Depends On D110790

Diff Detail

Event Timeline

wrengr created this revision.Oct 27 2021, 4:08 PM
Herald added subscribers: wenzhicui, Chia-hungDuan, dcaballe and 17 others. · View Herald TranscriptOct 27 2021, 4:08 PM
wrengr requested review of this revision.Oct 27 2021, 4:08 PM
Herald added a project: Restricted Project. · View Herald TranscriptOct 27 2021, 4:08 PM
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
wrengr mentioned this in D110790: [mlir][sparse] Implementing sparse=>dense conversion..Oct 27 2021, 4:09 PM
Harbormaster completed remote builds in B131069: Diff 382838.Oct 27 2021, 4:22 PM
wrengr updated this revision to Diff 383134.Oct 28 2021, 12:55 PM

Rebased onto newest version of D110790

Harbormaster completed remote builds in B131273: Diff 383134.Oct 28 2021, 1:08 PM
wrengr updated this revision to Diff 383172.Oct 28 2021, 2:51 PM

Rebasing to latest version of D110790

Harbormaster completed remote builds in B131303: Diff 383172.Oct 28 2021, 3:13 PM
aartbik accepted this revision.Oct 28 2021, 4:28 PM

I would also add or extend the end-to-end integration test for a case like this, but that can be done in a follow-up revision.

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

you could add an assert here that the constants match, but perhaps that is overkilll

This revision is now accepted and ready to land.Oct 28 2021, 4:28 PM
Closed by commit rG5389cdc8f67a: [mlir][sparse] Adding dynamic-size support for sparse=>dense conversion (authored by wrengr). · Explain WhyOct 28 2021, 4:56 PM
This revision was automatically updated to reflect the committed changes.
wrengr added a commit: rG5389cdc8f67a: [mlir][sparse] Adding dynamic-size support for sparse=>dense conversion.
wrengr added a comment.Oct 29 2021, 4:36 PM
In D112674#3095218, @aartbik wrote:

I would also add or extend the end-to-end integration test for a case like this, but that can be done in a follow-up revision.

New integration tests (and some debugging) is in D112854.

wrengr mentioned this in D112854: [mlir][sparse] Improve handling of dynamic-sizes for sparse=>dense conversion.Oct 29 2021, 5:09 PM

Revision Contents

PathSize
mlir/
lib/
Dialect/
SparseTensor/
Transforms/
72 lines
test/
Dialect/
SparseTensor/
271 lines

Diff 382838

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

Show First 20 Lines • Show All 427 Lines • ▼ Show 20 Lines for (unsigned i = 0; i < rank; i++) {
val = val =
rewriter.create<arith::IndexCastOp>(loc, val, rewriter.getIndexType()); rewriter.create<arith::IndexCastOp>(loc, val, rewriter.getIndexType());
rewriter.create<memref::StoreOp>(loc, val, ind, idx); rewriter.create<memref::StoreOp>(loc, val, ind, idx);
} }
return rewriter.create<tensor::ExtractOp>(loc, values, ivs[0]); return rewriter.create<tensor::ExtractOp>(loc, values, ivs[0]);
} }
/// Generates code to allocate a tensor of the given type, and zero /// Generates code to allocate a tensor of the given type, and zero
/// initialize it. This function assumes the TensorType is fully /// initialize it. If the tensor type has any dynamic sizes, then the
/// specified (i.e., has static rank and sizes). /// `sizes` parameter should be as filled by sizesFromPtr(); that way
// TODO(wrengr): support dynamic sizes. /// we can reuse the genDimSizeCall() results generated by sizesFromPtr().
static Value allocDenseTensor(ConversionPatternRewriter &rewriter, Location loc, static Value allocDenseTensor(ConversionPatternRewriter &rewriter, Location loc,
RankedTensorType tensorTp) { RankedTensorType tensorTp, ValueRange sizes) {
Type elemTp = tensorTp.getElementType(); Type elemTp = tensorTp.getElementType();
auto memTp = MemRefType::get(tensorTp.getShape(), elemTp); auto shape = tensorTp.getShape();
Value mem = rewriter.create<memref::AllocOp>(loc, memTp); auto memTp = MemRefType::get(shape, elemTp);
SmallVector<Value> dynamicSizes;
for (unsigned i = 0, rank = tensorTp.getRank(); i < rank; i++) {
if (shape[i] == ShapedType::kDynamicSize)
dynamicSizes.push_back(sizes[i]);
aartbikUnsubmitted
Not Done
ReplyInline Actions

you could add an assert here that the constants match, but perhaps that is overkilll

aartbik: you could add an assert here that the constants match, but perhaps that is overkilll
}
Value mem = rewriter.create<memref::AllocOp>(loc, memTp, dynamicSizes);
Value zero = constantZero(rewriter, loc, elemTp); Value zero = constantZero(rewriter, loc, elemTp);
rewriter.create<linalg::FillOp>(loc, zero, mem).result(); rewriter.create<linalg::FillOp>(loc, zero, mem).result();
return mem; return mem;
} }
/// Insert the element returned by genGetNextCall() into the tensor /// Insert the element returned by genGetNextCall() into the tensor
/// created by allocDenseTensor(). /// created by allocDenseTensor().
/// ///
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Lines if (!encDst && encSrc) {
// this is good enough for now. // this is good enough for now.
Location loc = op->getLoc(); Location loc = op->getLoc();
RankedTensorType tensorTp = resType.dyn_cast<RankedTensorType>(); RankedTensorType tensorTp = resType.dyn_cast<RankedTensorType>();
if (!tensorTp) { if (!tensorTp) {
op.emitError() << "Result type is not a RankedTensorType"; op.emitError() << "Result type is not a RankedTensorType";
return failure(); return failure();
} }
unsigned rank = tensorTp.getRank(); unsigned rank = tensorTp.getRank();
Type elemTp = tensorTp.getElementType();
Value dst = allocDenseTensor(rewriter, loc, tensorTp);
Value ind = genAlloca(rewriter, loc, rank, rewriter.getIndexType());
Value elemPtr = genAllocaScalar(rewriter, loc, elemTp);
Value iter;
{
// Clone encSrc but removing the dimOrdering. // Clone encSrc but removing the dimOrdering.
// The srcDimOrdering will already be applied during the // The srcDimOrdering will already be applied during the
// conversion from `SparseTensorStorage src` to SparseTensorCOO // conversion from `SparseTensorStorage src` to SparseTensorCOO
// (before that COO is converted to an iterator); so we don't // (before that COO is converted to an iterator); so we don't
// want newParams() to apply it a second time. // want newParams() to apply it a second time.
// //
// The dimLevelType is only actually used by the actions which // The dimLevelType is only actually used by the actions which
// return SparseTensorStorage (namely: kEmpty, kFromFile, and // return SparseTensorStorage (namely: kEmpty, kFromFile, and
// kFromCOO); so since we are using kToIter, the only operational // kFromCOO); so since we are using kToIter, the only operational
// requirement is that it has the right length. Since the dst // requirement is that it has the right length. Since the dst
// is a dense tensor, we choose to set dimLevelType to all-dense // is a dense tensor, we choose to set dimLevelType to all-dense
// for semantic correctness. // for semantic correctness.
encDst = SparseTensorEncodingAttr::get( encDst = SparseTensorEncodingAttr::get(
op->getContext(), op->getContext(),
SmallVector<SparseTensorEncodingAttr::DimLevelType>( SmallVector<SparseTensorEncodingAttr::DimLevelType>(
rank, SparseTensorEncodingAttr::DimLevelType::Dense), rank, SparseTensorEncodingAttr::DimLevelType::Dense),
AffineMap(), encSrc.getPointerBitWidth(), AffineMap(), encSrc.getPointerBitWidth(), encSrc.getIndexBitWidth());
encSrc.getIndexBitWidth());
SmallVector<Value, 4> sizes; SmallVector<Value, 4> sizes;
SmallVector<Value, 8> params; SmallVector<Value, 8> params;
// TODO(wrengr): support dynamic sizes. sizesFromPtr(rewriter, sizes, op, encSrc, tensorTp, src);
sizesFromType(rewriter, sizes, loc, tensorTp);
newParams(rewriter, params, op, encDst, kToIter, sizes, src); newParams(rewriter, params, op, encDst, kToIter, sizes, src);
iter = genNewCall(rewriter, op, params); Value iter = genNewCall(rewriter, op, params);
} Value ind = genAlloca(rewriter, loc, rank, rewriter.getIndexType());
Value elemPtr = genAllocaScalar(rewriter, loc, tensorTp.getElementType());
Value dst = allocDenseTensor(rewriter, loc, tensorTp, sizes);
SmallVector<Value> noArgs; SmallVector<Value> noArgs;
SmallVector<Type> noTypes; SmallVector<Type> noTypes;
auto whileOp = rewriter.create<scf::WhileOp>(loc, noTypes, noArgs); auto whileOp = rewriter.create<scf::WhileOp>(loc, noTypes, noArgs);
{ {
Block *before = rewriter.createBlock(&whileOp.before(), {}, noTypes); Block *before = rewriter.createBlock(&whileOp.before(), {}, noTypes);
rewriter.setInsertionPointToEnd(before); rewriter.setInsertionPointToEnd(before);
Value cond = genGetNextCall(rewriter, op, iter, ind, elemPtr); Value cond = genGetNextCall(rewriter, op, iter, ind, elemPtr);
rewriter.create<scf::ConditionOp>(loc, cond, before->getArguments()); rewriter.create<scf::ConditionOp>(loc, cond, before->getArguments());
▲ Show 20 Lines • Show All 248 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/conversion_sparse2dense.mlir

Show All 11 Lines#SparseTensor = #sparse_tensor.encoding<{
dimLevelType = ["dense", "compressed", "compressed"], dimLevelType = ["dense", "compressed", "compressed"],
dimOrdering = affine_map<(i,j,k) -> (k,i,j)> dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
}> }>
// CHECK-LABEL: func @sparse_convert_1d( // CHECK-LABEL: func @sparse_convert_1d(
// CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<13xi32> // CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<13xi32>
// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index // CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[I13:.*]] = arith.constant 13 : index // CHECK-DAG: %[[I13:.*]] = arith.constant 13 : index
//
// CHECK-DAG: %[[M:.*]] = memref.alloc() : memref<13xi32>
// CHECK-DAG: %[[E0:.*]] = arith.constant 0 : i32
// CHECK-DAG: linalg.fill(%[[E0]], %[[M]]) : i32, memref<13xi32>
// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<1xindex>
// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<1xindex> to memref<?xindex>
// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<i32>
//
// CHECK-DAG: %[[AttrsS:.*]] = memref.alloca() : memref<1xi8> // CHECK-DAG: %[[AttrsS:.*]] = memref.alloca() : memref<1xi8>
// CHECK-DAG: %[[AttrsD:.*]] = memref.cast %[[AttrsS]] : memref<1xi8> to memref<?xi8> // CHECK-DAG: %[[AttrsD:.*]] = memref.cast %[[AttrsS]] : memref<1xi8> to memref<?xi8>
// CHECK-DAG: %[[Attr0:.*]] = arith.constant 0 : i8 // CHECK-DAG: %[[Attr0:.*]] = arith.constant 0 : i8
// CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I0]]] : memref<1xi8> // CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I0]]] : memref<1xi8>
//
// CHECK-DAG: %[[SizesS:.*]] = memref.alloca() : memref<1xindex> // CHECK-DAG: %[[SizesS:.*]] = memref.alloca() : memref<1xindex>
// CHECK-DAG: %[[SizesD:.*]] = memref.cast %[[SizesS]] : memref<1xindex> to memref<?xindex> // CHECK-DAG: %[[SizesD:.*]] = memref.cast %[[SizesS]] : memref<1xindex> to memref<?xindex>
// CHECK-DAG: memref.store %[[I13]], %[[SizesS]][%[[I0]]] : memref<1xindex> // CHECK-DAG: memref.store %[[I13]], %[[SizesS]][%[[I0]]] : memref<1xindex>
//
// CHECK-DAG: %[[PermS:.*]] = memref.alloca() : memref<1xindex> // CHECK-DAG: %[[PermS:.*]] = memref.alloca() : memref<1xindex>
// CHECK-DAG: %[[PermD:.*]] = memref.cast %[[PermS]] : memref<1xindex> to memref<?xindex> // CHECK-DAG: %[[PermD:.*]] = memref.cast %[[PermS]] : memref<1xindex> to memref<?xindex>
// CHECK-DAG: memref.store %[[I0]], %[[PermS]][%[[I0]]] : memref<1xindex> // CHECK-DAG: memref.store %[[I0]], %[[PermS]][%[[I0]]] : memref<1xindex>
//
// CHECK-DAG: %[[SecTp:.*]] = arith.constant 1 : i32 // CHECK-DAG: %[[SecTp:.*]] = arith.constant 1 : i32
// CHECK-DAG: %[[ElemTp:.*]] = arith.constant 4 : i32 // CHECK-DAG: %[[ElemTp:.*]] = arith.constant 4 : i32
// CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 5 : i32 // CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 5 : i32
// CHECK: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %[[SecTp]], %[[SecTp]], %[[ElemTp]], %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8> // CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %[[SecTp]], %[[SecTp]], %[[ElemTp]], %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<1xindex>
// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<1xindex> to memref<?xindex>
// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<i32>
// CHECK-DAG: %[[M:.*]] = memref.alloc() : memref<13xi32>
// CHECK-DAG: %[[E0:.*]] = arith.constant 0 : i32
// CHECK-DAG: linalg.fill(%[[E0]], %[[M]]) : i32, memref<13xi32>
// CHECK: scf.while : () -> () { // CHECK: scf.while : () -> () {
// CHECK: %[[Cond:.*]] = call @getNextI32(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<i32>) -> i1 // CHECK: %[[Cond:.*]] = call @getNextI32(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<i32>) -> i1
// CHECK: scf.condition(%[[Cond]]) // CHECK: scf.condition(%[[Cond]])
// CHECK: } do { // CHECK: } do {
// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<1xindex> // CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<1xindex>
// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<i32> // CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<i32>
// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]]] : memref<13xi32> // CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]]] : memref<13xi32>
// CHECK: scf.yield // CHECK: scf.yield
// CHECK: } // CHECK: }
// CHECK: %[[T:.*]] = memref.tensor_load %[[M]] : memref<13xi32> // CHECK: %[[T:.*]] = memref.tensor_load %[[M]] : memref<13xi32>
// CHECK: return %[[T]] : tensor<13xi32> // CHECK: return %[[T]] : tensor<13xi32>
func @sparse_convert_1d(%arg0: tensor<13xi32, #SparseVector>) -> tensor<13xi32> { func @sparse_convert_1d(%arg0: tensor<13xi32, #SparseVector>) -> tensor<13xi32> {
%0 = sparse_tensor.convert %arg0 : tensor<13xi32, #SparseVector> to tensor<13xi32> %0 = sparse_tensor.convert %arg0 : tensor<13xi32, #SparseVector> to tensor<13xi32>
return %0 : 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: %[[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: %[[SecTp:.*]] = arith.constant 1 : i32
// CHECK-DAG: %[[ElemTp:.*]] = arith.constant 4 : i32
// CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 5 : i32
// CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %[[SecTp]], %[[SecTp]], %[[ElemTp]], %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<1xindex>
// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<1xindex> to memref<?xindex>
// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<i32>
// CHECK-DAG: %[[M:.*]] = memref.alloc(%[[SizeI0]]) : memref<?xi32>
// CHECK-DAG: %[[E0:.*]] = arith.constant 0 : i32
// CHECK-DAG: linalg.fill(%[[E0]], %[[M]]) : i32, memref<?xi32>
// CHECK: scf.while : () -> () {
// CHECK: %[[Cond:.*]] = call @getNextI32(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<i32>) -> i1
// CHECK: scf.condition(%[[Cond]])
// CHECK: } do {
// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<1xindex>
// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<i32>
// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]]] : memref<?xi32>
// CHECK: scf.yield
// CHECK: }
// CHECK: %[[T:.*]] = memref.tensor_load %[[M]] : memref<?xi32>
// CHECK: return %[[T]] : tensor<?xi32>
func @sparse_convert_1d_dyn(%arg0: tensor<?xi32, #SparseVector>) -> tensor<?xi32> {
%0 = sparse_tensor.convert %arg0 : tensor<?xi32, #SparseVector> to tensor<?xi32>
return %0 : tensor<?xi32>
}
// CHECK-LABEL: func @sparse_convert_2d( // CHECK-LABEL: func @sparse_convert_2d(
// CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<2x4xf64> // CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<2x4xf64>
// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index // CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index // CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[I2:.*]] = arith.constant 2 : index // CHECK-DAG: %[[I2:.*]] = arith.constant 2 : index
// CHECK-DAG: %[[I4:.*]] = arith.constant 4 : index // CHECK-DAG: %[[I4:.*]] = arith.constant 4 : index
//
// CHECK-DAG: %[[M:.*]] = memref.alloc() : memref<2x4xf64>
// CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64
// CHECK-DAG: linalg.fill(%[[E0]], %[[M]]) : f64, memref<2x4xf64>
// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<2xindex>
// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<2xindex> to memref<?xindex>
// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<f64>
//
// CHECK-DAG: %[[AttrsS:.*]] = memref.alloca() : memref<2xi8> // CHECK-DAG: %[[AttrsS:.*]] = memref.alloca() : memref<2xi8>
// CHECK-DAG: %[[AttrsD:.*]] = memref.cast %[[AttrsS]] : memref<2xi8> to memref<?xi8> // CHECK-DAG: %[[AttrsD:.*]] = memref.cast %[[AttrsS]] : memref<2xi8> to memref<?xi8>
// CHECK-DAG: %[[Attr0:.*]] = arith.constant 0 : i8 // CHECK-DAG: %[[Attr0:.*]] = arith.constant 0 : i8
// CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I0]]] : memref<2xi8> // CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I0]]] : memref<2xi8>
// CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I1]]] : memref<2xi8> // CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I1]]] : memref<2xi8>
//
// CHECK-DAG: %[[SizesS:.*]] = memref.alloca() : memref<2xindex> // CHECK-DAG: %[[SizesS:.*]] = memref.alloca() : memref<2xindex>
// CHECK-DAG: %[[SizesD:.*]] = memref.cast %[[SizesS]] : memref<2xindex> to memref<?xindex> // CHECK-DAG: %[[SizesD:.*]] = memref.cast %[[SizesS]] : memref<2xindex> to memref<?xindex>
// CHECK-DAG: memref.store %[[I2]], %[[SizesS]][%[[I0]]] : memref<2xindex> // CHECK-DAG: memref.store %[[I2]], %[[SizesS]][%[[I0]]] : memref<2xindex>
// CHECK-DAG: memref.store %[[I4]], %[[SizesS]][%[[I1]]] : memref<2xindex> // CHECK-DAG: memref.store %[[I4]], %[[SizesS]][%[[I1]]] : memref<2xindex>
//
// CHECK-DAG: %[[PermS:.*]] = memref.alloca() : memref<2xindex> // CHECK-DAG: %[[PermS:.*]] = memref.alloca() : memref<2xindex>
// CHECK-DAG: %[[PermD:.*]] = memref.cast %[[PermS]] : memref<2xindex> to memref<?xindex> // CHECK-DAG: %[[PermD:.*]] = memref.cast %[[PermS]] : memref<2xindex> to memref<?xindex>
// CHECK-DAG: memref.store %[[I0]], %[[PermS]][%[[I0]]] : memref<2xindex> // CHECK-DAG: memref.store %[[I0]], %[[PermS]][%[[I0]]] : memref<2xindex>
// CHECK-DAG: memref.store %[[I1]], %[[PermS]][%[[I1]]] : memref<2xindex> // CHECK-DAG: memref.store %[[I1]], %[[PermS]][%[[I1]]] : memref<2xindex>
//
// CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 5 : i32 // CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 5 : i32
// CHECK: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8> // CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<2xindex>
// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<2xindex> to memref<?xindex>
// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<f64>
// CHECK-DAG: %[[M:.*]] = memref.alloc() : memref<2x4xf64>
// CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64
// CHECK-DAG: linalg.fill(%[[E0]], %[[M]]) : f64, memref<2x4xf64>
// CHECK: scf.while : () -> () { // CHECK: scf.while : () -> () {
// CHECK: %[[Cond:.*]] = call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1 // CHECK: %[[Cond:.*]] = call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
// CHECK: scf.condition(%[[Cond]]) // CHECK: scf.condition(%[[Cond]])
// CHECK: } do { // CHECK: } do {
// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<2xindex> // CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<2xindex>
// CHECK: %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<2xindex> // CHECK: %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<2xindex>
// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64> // CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64>
// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<2x4xf64> // CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<2x4xf64>
// CHECK: scf.yield // CHECK: scf.yield
// CHECK: } // CHECK: }
// CHECK: %[[T:.*]] = memref.tensor_load %[[M]] : memref<2x4xf64> // CHECK: %[[T:.*]] = memref.tensor_load %[[M]] : memref<2x4xf64>
// CHECK: return %[[T]] : tensor<2x4xf64> // CHECK: return %[[T]] : tensor<2x4xf64>
func @sparse_convert_2d(%arg0: tensor<2x4xf64, #SparseMatrix>) -> tensor<2x4xf64> { func @sparse_convert_2d(%arg0: tensor<2x4xf64, #SparseMatrix>) -> tensor<2x4xf64> {
%0 = sparse_tensor.convert %arg0 : tensor<2x4xf64, #SparseMatrix> to tensor<2x4xf64> %0 = sparse_tensor.convert %arg0 : tensor<2x4xf64, #SparseMatrix> to tensor<2x4xf64>
return %0 : tensor<2x4xf64> return %0 : tensor<2x4xf64>
} }
// 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: %[[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-DAG: memref.store %[[I1]], %[[PermS]][%[[I1]]] : memref<2xindex>
// CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 5 : i32
// CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<2xindex>
// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<2xindex> to memref<?xindex>
// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<f64>
// CHECK-DAG: %[[M:.*]] = memref.alloc(%[[SizeI0]]) : memref<?x4xf64>
// CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64
// CHECK-DAG: linalg.fill(%[[E0]], %[[M]]) : f64, memref<?x4xf64>
// CHECK: scf.while : () -> () {
// CHECK: %[[Cond:.*]] = call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
// CHECK: scf.condition(%[[Cond]])
// CHECK: } do {
// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<2xindex>
// CHECK: %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<2xindex>
// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64>
// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<?x4xf64>
// CHECK: scf.yield
// CHECK: }
// CHECK: %[[T:.*]] = memref.tensor_load %[[M]] : memref<?x4xf64>
// CHECK: return %[[T]] : tensor<?x4xf64>
func @sparse_convert_2d_dyn0(%arg0: tensor<?x4xf64, #SparseMatrix>) -> tensor<?x4xf64> {
%0 = sparse_tensor.convert %arg0 : tensor<?x4xf64, #SparseMatrix> to tensor<?x4xf64>
return %0 : tensor<?x4xf64>
}
// 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: %[[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-DAG: memref.store %[[I1]], %[[PermS]][%[[I1]]] : memref<2xindex>
// CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 5 : i32
// CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<2xindex>
// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<2xindex> to memref<?xindex>
// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<f64>
// CHECK-DAG: %[[M:.*]] = memref.alloc(%[[SizeI1]]) : memref<2x?xf64>
// CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64
// CHECK-DAG: linalg.fill(%[[E0]], %[[M]]) : f64, memref<2x?xf64>
// CHECK: scf.while : () -> () {
// CHECK: %[[Cond:.*]] = call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
// CHECK: scf.condition(%[[Cond]])
// CHECK: } do {
// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<2xindex>
// CHECK: %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<2xindex>
// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64>
// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<2x?xf64>
// CHECK: scf.yield
// CHECK: }
// CHECK: %[[T:.*]] = memref.tensor_load %[[M]] : memref<2x?xf64>
// CHECK: return %[[T]] : tensor<2x?xf64>
func @sparse_convert_2d_dyn1(%arg0: tensor<2x?xf64, #SparseMatrix>) -> tensor<2x?xf64> {
%0 = sparse_tensor.convert %arg0 : tensor<2x?xf64, #SparseMatrix> to tensor<2x?xf64>
return %0 : tensor<2x?xf64>
}
// 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: %[[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-DAG: memref.store %[[I0]], %[[PermS]][%[[I0]]] : memref<2xindex>
// CHECK-DAG: memref.store %[[I1]], %[[PermS]][%[[I1]]] : memref<2xindex>
// CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 5 : i32
// CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<2xindex>
// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<2xindex> to memref<?xindex>
// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<f64>
// CHECK-DAG: %[[M:.*]] = memref.alloc(%[[SizeI0]], %[[SizeI1]]) : memref<?x?xf64>
// CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64
// CHECK-DAG: linalg.fill(%[[E0]], %[[M]]) : f64, memref<?x?xf64>
// CHECK: scf.while : () -> () {
// CHECK: %[[Cond:.*]] = call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
// CHECK: scf.condition(%[[Cond]])
// CHECK: } do {
// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<2xindex>
// CHECK: %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<2xindex>
// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64>
// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<?x?xf64>
// CHECK: scf.yield
// CHECK: }
// CHECK: %[[T:.*]] = memref.tensor_load %[[M]] : memref<?x?xf64>
// CHECK: return %[[T]] : tensor<?x?xf64>
func @sparse_convert_2d_dyn2(%arg0: tensor<?x?xf64, #SparseMatrix>) -> tensor<?x?xf64> {
%0 = sparse_tensor.convert %arg0 : tensor<?x?xf64, #SparseMatrix> to tensor<?x?xf64>
return %0 : tensor<?x?xf64>
}
// CHECK-LABEL: func @sparse_convert_3d( // CHECK-LABEL: func @sparse_convert_3d(
// CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<2x3x4xf64> // CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<2x3x4xf64>
// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index // CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index // CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[I2:.*]] = arith.constant 2 : index // CHECK-DAG: %[[I2:.*]] = arith.constant 2 : index
// CHECK-DAG: %[[I3:.*]] = arith.constant 3 : index // CHECK-DAG: %[[I3:.*]] = arith.constant 3 : index
// CHECK-DAG: %[[I4:.*]] = arith.constant 4 : index // CHECK-DAG: %[[I4:.*]] = arith.constant 4 : index
//
// CHECK-DAG: %[[M:.*]] = memref.alloc() : memref<2x3x4xf64>
// CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64
// CHECK-DAG: linalg.fill(%[[E0]], %[[M]]) : f64, memref<2x3x4xf64>
// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<3xindex>
// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<3xindex> to memref<?xindex>
// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<f64>
//
// CHECK-DAG: %[[AttrsS:.*]] = memref.alloca() : memref<3xi8> // CHECK-DAG: %[[AttrsS:.*]] = memref.alloca() : memref<3xi8>
// CHECK-DAG: %[[AttrsD:.*]] = memref.cast %[[AttrsS]] : memref<3xi8> to memref<?xi8> // CHECK-DAG: %[[AttrsD:.*]] = memref.cast %[[AttrsS]] : memref<3xi8> to memref<?xi8>
// CHECK-DAG: %[[Attr0:.*]] = arith.constant 0 : i8 // CHECK-DAG: %[[Attr0:.*]] = arith.constant 0 : i8
// CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I0]]] : memref<3xi8> // CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I0]]] : memref<3xi8>
// CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I1]]] : memref<3xi8> // CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I1]]] : memref<3xi8>
// CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I2]]] : memref<3xi8> // CHECK-DAG: memref.store %[[Attr0]], %[[AttrsS]][%[[I2]]] : memref<3xi8>
//
// CHECK-DAG: %[[SizesS:.*]] = memref.alloca() : memref<3xindex> // CHECK-DAG: %[[SizesS:.*]] = memref.alloca() : memref<3xindex>
// CHECK-DAG: %[[SizesD:.*]] = memref.cast %[[SizesS]] : memref<3xindex> to memref<?xindex> // CHECK-DAG: %[[SizesD:.*]] = memref.cast %[[SizesS]] : memref<3xindex> to memref<?xindex>
// CHECK-DAG: memref.store %[[I2]], %[[SizesS]][%[[I0]]] : memref<3xindex> // CHECK-DAG: memref.store %[[I2]], %[[SizesS]][%[[I0]]] : memref<3xindex>
// CHECK-DAG: memref.store %[[I3]], %[[SizesS]][%[[I1]]] : memref<3xindex> // CHECK-DAG: memref.store %[[I3]], %[[SizesS]][%[[I1]]] : memref<3xindex>
// CHECK-DAG: memref.store %[[I4]], %[[SizesS]][%[[I2]]] : memref<3xindex> // CHECK-DAG: memref.store %[[I4]], %[[SizesS]][%[[I2]]] : memref<3xindex>
//
// CHECK-DAG: %[[PermS:.*]] = memref.alloca() : memref<3xindex> // CHECK-DAG: %[[PermS:.*]] = memref.alloca() : memref<3xindex>
// CHECK-DAG: %[[PermD:.*]] = memref.cast %[[PermS]] : memref<3xindex> to memref<?xindex> // CHECK-DAG: %[[PermD:.*]] = memref.cast %[[PermS]] : memref<3xindex> to memref<?xindex>
// CHECK-DAG: memref.store %[[I0]], %[[PermS]][%[[I0]]] : memref<3xindex> // CHECK-DAG: memref.store %[[I0]], %[[PermS]][%[[I0]]] : memref<3xindex>
// CHECK-DAG: memref.store %[[I1]], %[[PermS]][%[[I1]]] : memref<3xindex> // CHECK-DAG: memref.store %[[I1]], %[[PermS]][%[[I1]]] : memref<3xindex>
// CHECK-DAG: memref.store %[[I2]], %[[PermS]][%[[I2]]] : memref<3xindex> // CHECK-DAG: memref.store %[[I2]], %[[PermS]][%[[I2]]] : memref<3xindex>
//
// CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 5 : i32 // CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 5 : i32
// CHECK: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8> // CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<3xindex>
// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<3xindex> to memref<?xindex>
// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<f64>
// CHECK-DAG: %[[M:.*]] = memref.alloc() : memref<2x3x4xf64>
// CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64
// CHECK-DAG: linalg.fill(%[[E0]], %[[M]]) : f64, memref<2x3x4xf64>
// CHECK: scf.while : () -> () { // CHECK: scf.while : () -> () {
// CHECK: %[[Cond:.*]] = call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1 // CHECK: %[[Cond:.*]] = call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
// CHECK: scf.condition(%[[Cond]]) // CHECK: scf.condition(%[[Cond]])
// CHECK: } do { // CHECK: } do {
// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<3xindex> // CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<3xindex>
// CHECK: %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<3xindex> // CHECK: %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<3xindex>
// CHECK: %[[Iv2:.*]] = memref.load %[[IndS]][%[[I2]]] : memref<3xindex> // CHECK: %[[Iv2:.*]] = memref.load %[[IndS]][%[[I2]]] : memref<3xindex>
// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64> // CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64>
Show All 9 Lines