This is an archive of the discontinued LLVM Phabricator instance.

Differential D129985

[mlir][bufferization][NFC] Move sparse_tensor.release to bufferization dialect
ClosedPublic

Authored by springerm on Jul 18 2022, 12:42 AM.

Details

Reviewers
aartbik
Commits
rG27a431f5e981: [mlir][bufferization][NFC] Move sparse_tensor.release to bufferization dialect
Summary

This op used to belong to the sparse dialect, but there are use cases for dense bufferization as well. (E.g., when a tensor alloc is returned from a function and should be deallocated at the call site.) This change moves the op to the bufferization dialect, which now has an alloc_tensor and a dealloc_tensor op.

Diff Detail

Event Timeline

springerm created this revision.Jul 18 2022, 12:42 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 18 2022, 12:42 AM
Herald added subscribers: anlunx, bzcheeseman, sdasgup3 and 20 others. · View Herald Transcript
springerm requested review of this revision.Jul 18 2022, 12:42 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 18 2022, 12:42 AM
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
springerm updated this revision to Diff 445408.Jul 18 2022, 12:51 AM

update

Harbormaster completed remote builds in B175965: Diff 445408.Jul 18 2022, 1:28 AM
springerm added a child revision: D130023: [mlir][sparse][NFC] Update remaining test cases.Jul 18 2022, 9:02 AM
aartbik accepted this revision.Jul 18 2022, 10:32 AM
aartbik added inline comments.
mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorPasses.cpp
142

just curious, we add the full dialect but also some individual ops; does that work as expected?

142

He, did we have this twice defined? Good catch.

This revision is now accepted and ready to land.Jul 18 2022, 10:32 AM
springerm marked 2 inline comments as done.Jul 19 2022, 12:13 AM
springerm added inline comments.
mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorPasses.cpp
142

I think all ops of the bufferization dialect are legal. Except for the ones for which we have special rules (AllocTensorOp, DeallocTensorOp), those have another chance to become illegal.

Closed by commit rG27a431f5e981: [mlir][bufferization][NFC] Move sparse_tensor.release to bufferization dialect (authored by springerm). · Explain WhyJul 19 2022, 12:19 AM
This revision was automatically updated to reflect the committed changes.
springerm marked an inline comment as done.
springerm added a commit: rG27a431f5e981: [mlir][bufferization][NFC] Move sparse_tensor.release to bufferization dialect.

Revision Contents

PathSize
mlir/
include/
mlir/
Dialect/
Bufferization/
IR/
58 lines
SparseTensor/
IR/
25 lines
lib/
Dialect/
Bufferization/
IR/
15 lines
SparseTensor/
Transforms/
20 lines
12 lines
9 lines
2 lines
test/
Dialect/
Bufferization/
7 lines
SparseTensor/
2 lines
8 lines
8 lines
2 lines
Integration/
Dialect/
SparseTensor/
CPU/
4 lines
6 lines
6 lines
34 lines
8 lines
8 lines
8 lines
18 lines
2 lines
18 lines
12 lines
12 lines
36 lines
14 lines
4 lines
2 lines
2 lines
28 lines
8 lines
28 lines
12 lines
2 lines
2 lines
6 lines
6 lines
2 lines
2 lines
6 lines
8 lines
12 lines
2 lines
6 lines
2 lines
4 lines
2 lines
14 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
4 lines
8 lines
14 lines
14 lines
python/
3 lines

Diff 445709

mlir/include/mlir/Dialect/Bufferization/IR/BufferizationOps.td

Show First 20 Lines • Show All 180 Lines • ▼ Show 20 Lines let extraClassDeclaration = [{
Value getTarget() { return getOutput(); } Value getTarget() { return getOutput(); }
}]; }];
let assemblyFormat = "$input attr-dict `:` type($input) `to` type($output)"; let assemblyFormat = "$input attr-dict `:` type($input) `to` type($output)";
let hasFolder = 1; let hasFolder = 1;
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
} }
//===----------------------------------------------------------------------===//
// DeallocTensorOp
//===----------------------------------------------------------------------===//
def Bufferization_DeallocTensorOp : Bufferization_Op<"dealloc_tensor",
[BufferizableOpInterface]> {
string summary = "Releases underlying sparse storage format of given tensor";
string description = [{
`bufferization.dealloc_tensor` is a buffer deallocation in tensor land. This
op can be used for manual buffer deallocation. Some bufferizations (such as
One-Shot Bufferize) take care of buffer deallocation, in which case this op
is usually not needed. Details can be found in the documentation of the
respective bufferization passes.
In case of a dense tensor, this op lowers to a `memref.dealloc` op during
bufferization.
In case of a sparse tensor, this op releases the underlying sparse storage
format for a tensor that materialized earlier through a `new` operation, a
`convert` operation with annotated destination tensor type (unless the
convert is folded away), or a `bufferization.alloc_tensor` operation. The
release operation should only be called once for any materialized tensor.
After this operation, any subsequent `memref` querying operation on the
tensor returns undefined results.
Example:
```mlir
bufferization.dealloc_tensor %tensor : tensor<1024x1024xf64, #CSR>
```
}];
let arguments = (ins AnyTensor:$tensor);
let results = (outs);
let assemblyFormat = "$tensor attr-dict `:` type($tensor)";
let extraClassDeclaration = [{
bool bufferizesToMemoryRead(OpOperand &opOperand,
const AnalysisState &state) const {
return false;
}
bool bufferizesToMemoryWrite(OpOperand &opOperand,
const AnalysisState &state) const {
return false;
}
SmallVector<OpResult> getAliasingOpResult(
OpOperand &opOperand, const AnalysisState &state) const {
return {};
}
LogicalResult bufferize(RewriterBase &rewriter,
const BufferizationOptions &options);
}];
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ToTensorOp // ToTensorOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def Bufferization_ToTensorOp : Bufferization_Op<"to_tensor", [ def Bufferization_ToTensorOp : Bufferization_Op<"to_tensor", [
BufferizableOpInterface, BufferizableOpInterface,
SameOperandsAndResultShape, SameOperandsAndResultShape,
SameOperandsAndResultElementType, SameOperandsAndResultElementType,
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 300 Lines • ▼ Show 20 Lines let description = [{
```mlir ```mlir
%1 = sparse_tensor.load %0 : tensor<8xf64, #SV> %1 = sparse_tensor.load %0 : tensor<8xf64, #SV>
``` ```
}]; }];
let assemblyFormat = "$tensor (`hasInserts` $hasInserts^)? attr-dict `:` type($tensor)"; let assemblyFormat = "$tensor (`hasInserts` $hasInserts^)? attr-dict `:` type($tensor)";
} }
def SparseTensor_ReleaseOp : SparseTensor_Op<"release", []>,
Arguments<(ins AnySparseTensor:$tensor)> {
string summary = "Releases underlying sparse storage format of given tensor";
string description = [{
Releases the underlying sparse storage format for a tensor that
materialized earlier through a `new` operation, a `convert` operation
with annotated destination tensor type (unless the convert is folded
away), or a `bufferization.alloc_tensor` operation. The release operation
should only be called once for any materialized tensor. After this
operation, any subsequent `memref` querying operation on the tensor
returns undefined results.
Note that this operation is "impure" in the sense that its behavior
is solely defined by side-effects and not SSA values. The semantics
may be refined over time as our sparse abstractions evolve.
Example:
```mlir
sparse_tensor.release %tensor : tensor<1024x1024xf64, #CSR>
```
}];
let assemblyFormat = "$tensor attr-dict `:` type($tensor)";
}
def SparseTensor_OutOp : SparseTensor_Op<"out", []>, def SparseTensor_OutOp : SparseTensor_Op<"out", []>,
Arguments<(ins AnySparseTensor:$tensor, AnyType:$dest)> { Arguments<(ins AnySparseTensor:$tensor, AnyType:$dest)> {
string summary = "Outputs a sparse tensor to the given destination"; string summary = "Outputs a sparse tensor to the given destination";
string description = [{ string description = [{
Outputs the contents of a sparse tensor to the destination defined by an Outputs the contents of a sparse tensor to the destination defined by an
opaque pointer provided by `dest`. For targets that have access to a file opaque pointer provided by `dest`. For targets that have access to a file
system, for example, this pointer may specify a filename (or file) for output. system, for example, this pointer may specify a filename (or file) for output.
The form of the operation is kept deliberately very general to allow for The form of the operation is kept deliberately very general to allow for
▲ Show 20 Lines • Show All 280 Lines • Show Last 20 Lines

mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp

Show First 20 Lines • Show All 519 Lines • ▼ Show 20 Lines
} // namespace } // namespace
void CloneOp::getCanonicalizationPatterns(RewritePatternSet &results, void CloneOp::getCanonicalizationPatterns(RewritePatternSet &results,
MLIRContext *context) { MLIRContext *context) {
results.add<SimplifyClones>(context); results.add<SimplifyClones>(context);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// DeallocTensorOp
//===----------------------------------------------------------------------===//
LogicalResult DeallocTensorOp::bufferize(RewriterBase &rewriter,
const BufferizationOptions &options) {
FailureOr<Value> buffer = getBuffer(rewriter, getTensor(), options);
if (failed(buffer))
return failure();
if (failed(options.createDealloc(rewriter, getLoc(), *buffer)))
return failure();
rewriter.eraseOp(getOperation());
return success();
}
//===----------------------------------------------------------------------===//
// ToTensorOp // ToTensorOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
OpFoldResult ToTensorOp::fold(ArrayRef<Attribute>) { OpFoldResult ToTensorOp::fold(ArrayRef<Attribute>) {
if (auto toMemref = getMemref().getDefiningOp<ToMemrefOp>()) if (auto toMemref = getMemref().getDefiningOp<ToMemrefOp>())
// Approximate alias analysis by conservatively folding only when no there // Approximate alias analysis by conservatively folding only when no there
// is no interleaved operation. // is no interleaved operation.
if (toMemref->getBlock() == this->getOperation()->getBlock() && if (toMemref->getBlock() == this->getOperation()->getBlock() &&
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines bool isMemoryWrite(Operation *op, OpResult opResult,
return false; return false;
} }
bool bufferizesToAllocation(Operation *op, OpResult opResult) const { bool bufferizesToAllocation(Operation *op, OpResult opResult) const {
return true; return true;
} }
}; };
struct ReleaseOpInterface
: public BufferizableOpInterface::ExternalModel<ReleaseOpInterface,
sparse_tensor::ReleaseOp> {
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
const AnalysisState &state) const {
return false;
}
bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
const AnalysisState &state) const {
return false;
}
SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
const AnalysisState &state) const {
return {};
}
};
} // namespace } // namespace
} // namespace sparse_tensor } // namespace sparse_tensor
} // namespace mlir } // namespace mlir
void mlir::sparse_tensor::registerBufferizableOpInterfaceExternalModels( void mlir::sparse_tensor::registerBufferizableOpInterfaceExternalModels(
DialectRegistry &registry) { DialectRegistry &registry) {
registry.addExtension( registry.addExtension(
+[](MLIRContext *ctx, sparse_tensor::SparseTensorDialect *dialect) { +[](MLIRContext *ctx, sparse_tensor::SparseTensorDialect *dialect) {
sparse_tensor::ConvertOp::attachInterface<ConvertOpInterface>(*ctx); sparse_tensor::ConvertOp::attachInterface<ConvertOpInterface>(*ctx);
sparse_tensor::LoadOp::attachInterface<LoadOpInterface>(*ctx); sparse_tensor::LoadOp::attachInterface<LoadOpInterface>(*ctx);
sparse_tensor::NewOp::attachInterface<NewOpInterface>(*ctx); sparse_tensor::NewOp::attachInterface<NewOpInterface>(*ctx);
sparse_tensor::ReleaseOp::attachInterface<ReleaseOpInterface>(*ctx);
}); });
} }

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

Show First 20 Lines • Show All 862 Lines • ▼ Show 20 Lines matchAndRewrite(ConvertOp op, OpAdaptor adaptor,
return success(); return success();
} }
private: private:
/// Options to control sparse code generation. /// Options to control sparse code generation.
SparseTensorConversionOptions options; SparseTensorConversionOptions options;
}; };
/// Sparse conversion rule for the release operator. /// Sparse conversion rule for the dealloc operator.
class SparseTensorReleaseConverter : public OpConversionPattern<ReleaseOp> { class SparseTensorDeallocConverter
: public OpConversionPattern<bufferization::DeallocTensorOp> {
public: public:
using OpConversionPattern::OpConversionPattern; using OpConversionPattern::OpConversionPattern;
LogicalResult LogicalResult
matchAndRewrite(ReleaseOp op, OpAdaptor adaptor, matchAndRewrite(bufferization::DeallocTensorOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override { ConversionPatternRewriter &rewriter) const override {
auto enc = getSparseTensorEncoding(op.getTensor().getType());
if (!enc)
return failure();
StringRef name = "delSparseTensor"; StringRef name = "delSparseTensor";
TypeRange noTp; TypeRange noTp;
createFuncCall(rewriter, op, name, noTp, adaptor.getOperands(), createFuncCall(rewriter, op, name, noTp, adaptor.getOperands(),
EmitCInterface::Off); EmitCInterface::Off);
rewriter.eraseOp(op); rewriter.eraseOp(op);
return success(); return success();
} }
}; };
▲ Show 20 Lines • Show All 209 Lines • ▼ Show 20 Lines
/// the sparsification of linear algebra operations. /// the sparsification of linear algebra operations.
void mlir::populateSparseTensorConversionPatterns( void mlir::populateSparseTensorConversionPatterns(
TypeConverter &typeConverter, RewritePatternSet &patterns, TypeConverter &typeConverter, RewritePatternSet &patterns,
const SparseTensorConversionOptions &options) { const SparseTensorConversionOptions &options) {
patterns.add<SparseReturnConverter, SparseTensorToDimSizeConverter, patterns.add<SparseReturnConverter, SparseTensorToDimSizeConverter,
SparseCastConverter, SparseTensorNewConverter, SparseCastConverter, SparseTensorNewConverter,
SparseReshapeConverter<tensor::ExpandShapeOp>, SparseReshapeConverter<tensor::ExpandShapeOp>,
SparseReshapeConverter<tensor::CollapseShapeOp>, SparseReshapeConverter<tensor::CollapseShapeOp>,
SparseTensorAllocConverter, SparseTensorReleaseConverter, SparseTensorAllocConverter, SparseTensorDeallocConverter,
SparseTensorToPointersConverter, SparseTensorToIndicesConverter, SparseTensorToPointersConverter, SparseTensorToIndicesConverter,
SparseTensorToValuesConverter, SparseTensorLoadConverter, SparseTensorToValuesConverter, SparseTensorLoadConverter,
SparseTensorLexInsertConverter, SparseTensorExpandConverter, SparseTensorLexInsertConverter, SparseTensorExpandConverter,
SparseTensorCompressConverter, SparseTensorOutConverter>( SparseTensorCompressConverter, SparseTensorOutConverter>(
typeConverter, patterns.getContext()); typeConverter, patterns.getContext());
patterns.add<SparseTensorConvertConverter>(typeConverter, patterns.add<SparseTensorConvertConverter>(typeConverter,
patterns.getContext(), options); patterns.getContext(), options);
} }

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

Show First 20 Lines • Show All 123 Lines • ▼ Show 20 Lines target.addDynamicallyLegalOp<tensor::CollapseShapeOp>(
[&](tensor::CollapseShapeOp op) { [&](tensor::CollapseShapeOp op) {
return converter.isLegal(op.getSrc().getType()) && return converter.isLegal(op.getSrc().getType()) &&
converter.isLegal(op.getResult().getType()); converter.isLegal(op.getResult().getType());
}); });
target.addDynamicallyLegalOp<bufferization::AllocTensorOp>( target.addDynamicallyLegalOp<bufferization::AllocTensorOp>(
[&](bufferization::AllocTensorOp op) { [&](bufferization::AllocTensorOp op) {
return converter.isLegal(op.getType()); return converter.isLegal(op.getType());
}); });
target.addDynamicallyLegalOp<bufferization::DeallocTensorOp>(
[&](bufferization::DeallocTensorOp op) {
return converter.isLegal(op.getTensor().getType());
});
// The following operations and dialects may be introduced by the // The following operations and dialects may be introduced by the
// rewriting rules, and are therefore marked as legal. // rewriting rules, and are therefore marked as legal.
target.addLegalOp<bufferization::ToMemrefOp, bufferization::ToTensorOp, target.addLegalOp<bufferization::ToMemrefOp, bufferization::ToTensorOp,
complex::ConstantOp, complex::NotEqualOp, linalg::FillOp, complex::ConstantOp, complex::NotEqualOp, linalg::FillOp,
linalg::YieldOp, tensor::ExtractOp>(); linalg::YieldOp, tensor::ExtractOp>();
target.addLegalDialect< target.addLegalDialect<
arith::ArithmeticDialect, bufferization::BufferizationDialect, arith::ArithmeticDialect, bufferization::BufferizationDialect,
aartbikUnsubmitted
Done
ReplyInline Actions

just curious, we add the full dialect but also some individual ops; does that work as expected?

aartbik: just curious, we add the full dialect but also some individual ops; does that work as expected?
springermAuthorUnsubmitted
Done
ReplyInline Actions

I think all ops of the bufferization dialect are legal. Except for the ones for which we have special rules (AllocTensorOp, DeallocTensorOp), those have another chance to become illegal.

springerm: I think all ops of the bufferization dialect are legal. Except for the ones for which we have…
LLVM::LLVMDialect, memref::MemRefDialect, scf::SCFDialect>(); LLVM::LLVMDialect, memref::MemRefDialect, scf::SCFDialect>();
target.addDynamicallyLegalOp<bufferization::AllocTensorOp>(
[&](bufferization::AllocTensorOp op) {
// Dense tensors are legal, sparse tensors are not.
aartbikUnsubmitted
Done
ReplyInline Actions

He, did we have this twice defined? Good catch.

aartbik: He, did we have this twice defined? Good catch.
return !static_cast<bool>(op.getType().getEncoding());
});
// Translate strategy flags to strategy options. // Translate strategy flags to strategy options.
SparseTensorConversionOptions options( SparseTensorConversionOptions options(
sparseToSparseConversionStrategy(sparseToSparse)); sparseToSparseConversionStrategy(sparseToSparse));
// Populate with rules and apply rewriting rules. // Populate with rules and apply rewriting rules.
populateFunctionOpInterfaceTypeConversionPattern<func::FuncOp>(patterns, populateFunctionOpInterfaceTypeConversionPattern<func::FuncOp>(patterns,
converter); converter);
populateCallOpTypeConversionPattern(patterns, converter); populateCallOpTypeConversionPattern(patterns, converter);
populateSparseTensorConversionPatterns(converter, patterns, options); populateSparseTensorConversionPatterns(converter, patterns, options);
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,784 Lines • ▼ Show 20 Lines for (OpOperand *t : op.getInputOperands()) {
op->getContext(), srcEnc.getDimLevelType(), op->getContext(), srcEnc.getDimLevelType(),
permute(getContext(), op.getTiedIndexingMap(t), topSort), // new order permute(getContext(), op.getTiedIndexingMap(t), topSort), // new order
srcEnc.getPointerBitWidth(), srcEnc.getIndexBitWidth()); srcEnc.getPointerBitWidth(), srcEnc.getIndexBitWidth());
auto dstTp = RankedTensorType::get(srcTp.getShape(), auto dstTp = RankedTensorType::get(srcTp.getShape(),
srcTp.getElementType(), dstEnc); srcTp.getElementType(), dstEnc);
auto convert = rewriter.create<ConvertOp>(tval.getLoc(), dstTp, tval); auto convert = rewriter.create<ConvertOp>(tval.getLoc(), dstTp, tval);
op->setOperand(tensor, convert); op->setOperand(tensor, convert);
rewriter.setInsertionPointAfter(op); rewriter.setInsertionPointAfter(op);
rewriter.create<ReleaseOp>(tval.getLoc(), convert); rewriter.create<bufferization::DeallocTensorOp>(tval.getLoc(), convert);
return success(); return success();
} }
// Cannot be resolved with a single conversion. // Cannot be resolved with a single conversion.
// TODO: convert more than one? // TODO: convert more than one?
return failure(); return failure();
} }
/// Options to control sparse code generation. /// Options to control sparse code generation.
Show All 11 Lines

mlir/test/Dialect/Bufferization/ops.mlir

Show All 35 Linesfunc.func @test_alloc_tensor_op(%t: tensor<?x5xf32>, %sz: index)
// CHECK: bufferization.alloc_tensor(%{{.*}}, %{{.*}}) : tensor<?x?xf32> // CHECK: bufferization.alloc_tensor(%{{.*}}, %{{.*}}) : tensor<?x?xf32>
%3 = bufferization.alloc_tensor(%sz, %sz) : tensor<?x?xf32> %3 = bufferization.alloc_tensor(%sz, %sz) : tensor<?x?xf32>
// CHECK: bufferization.alloc_tensor() copy(%{{.*}}) {escape = true} : tensor<?x5xf32> // CHECK: bufferization.alloc_tensor() copy(%{{.*}}) {escape = true} : tensor<?x5xf32>
%4 = bufferization.alloc_tensor() copy(%t) {escape = true} : tensor<?x5xf32> %4 = bufferization.alloc_tensor() copy(%t) {escape = true} : tensor<?x5xf32>
// CHECK: bufferization.alloc_tensor() copy(%{{.*}}) {escape = false} : tensor<?x5xf32> // CHECK: bufferization.alloc_tensor() copy(%{{.*}}) {escape = false} : tensor<?x5xf32>
%5 = bufferization.alloc_tensor() copy(%t) {escape = false} : tensor<?x5xf32> %5 = bufferization.alloc_tensor() copy(%t) {escape = false} : tensor<?x5xf32>
return %1 : tensor<?x5xf32> return %1 : tensor<?x5xf32>
} }
// CHECK-LABEL: func @test_dealloc_tensor_op
func.func @test_dealloc_tensor_op(%arg0: tensor<4xi32>) {
// CHECK: bufferization.dealloc_tensor {{.*}} : tensor<4xi32>
bufferization.dealloc_tensor %arg0 : tensor<4xi32>
return
}

mlir/test/Dialect/SparseTensor/conversion.mlir

Show First 20 Lines • Show All 139 Lines • ▼ Show 20 Linesfunc.func @sparse_init(%arg0: index, %arg1: index) -> tensor<?x?xf64, #SparseMatrix> {
return %1 : tensor<?x?xf64, #SparseMatrix> return %1 : tensor<?x?xf64, #SparseMatrix>
} }
// CHECK-LABEL: func @sparse_release( // CHECK-LABEL: func @sparse_release(
// CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) // CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>)
// CHECK: call @delSparseTensor(%[[A]]) : (!llvm.ptr<i8>) -> () // CHECK: call @delSparseTensor(%[[A]]) : (!llvm.ptr<i8>) -> ()
// CHECK: return // CHECK: return
func.func @sparse_release(%arg0: tensor<128xf64, #SparseVector>) { func.func @sparse_release(%arg0: tensor<128xf64, #SparseVector>) {
sparse_tensor.release %arg0 : tensor<128xf64, #SparseVector> bufferization.dealloc_tensor %arg0 : tensor<128xf64, #SparseVector>
return return
} }
// CHECK-LABEL: func @sparse_nop_convert( // CHECK-LABEL: func @sparse_nop_convert(
// CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) -> !llvm.ptr<i8> // CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) -> !llvm.ptr<i8>
// CHECK: return %[[A]] : !llvm.ptr<i8> // CHECK: return %[[A]] : !llvm.ptr<i8>
func.func @sparse_nop_convert(%arg0: tensor<64xf32, #SparseVector>) -> tensor<64xf32, #SparseVector> { func.func @sparse_nop_convert(%arg0: tensor<64xf32, #SparseVector>) -> tensor<64xf32, #SparseVector> {
%0 = sparse_tensor.convert %arg0 : tensor<64xf32, #SparseVector> to tensor<64xf32, #SparseVector> %0 = sparse_tensor.convert %arg0 : tensor<64xf32, #SparseVector> to tensor<64xf32, #SparseVector>
▲ Show 20 Lines • Show All 431 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/invalid.mlir

// RUN: mlir-opt %s -split-input-file -verify-diagnostics // RUN: mlir-opt %s -split-input-file -verify-diagnostics
func.func @invalid_new_dense(%arg0: !llvm.ptr<i8>) -> tensor<32xf32> { func.func @invalid_new_dense(%arg0: !llvm.ptr<i8>) -> tensor<32xf32> {
// expected-error@+1 {{'sparse_tensor.new' op result #0 must be sparse tensor of any type values, but got 'tensor<32xf32>'}} // expected-error@+1 {{'sparse_tensor.new' op result #0 must be sparse tensor of any type values, but got 'tensor<32xf32>'}}
%0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<32xf32> %0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// ----- // -----
func.func @invalid_release_dense(%arg0: tensor<4xi32>) {
// expected-error@+1 {{'sparse_tensor.release' op operand #0 must be sparse tensor of any type values, but got 'tensor<4xi32>'}}
sparse_tensor.release %arg0 : tensor<4xi32>
return
}
// -----
func.func @invalid_pointers_dense(%arg0: tensor<128xf64>) -> memref<?xindex> { func.func @invalid_pointers_dense(%arg0: tensor<128xf64>) -> memref<?xindex> {
%c = arith.constant 0 : index %c = arith.constant 0 : index
// expected-error@+1 {{'sparse_tensor.pointers' op operand #0 must be sparse tensor of any type values, but got 'tensor<128xf64>'}} // expected-error@+1 {{'sparse_tensor.pointers' op operand #0 must be sparse tensor of any type values, but got 'tensor<128xf64>'}}
%0 = sparse_tensor.pointers %arg0, %c : tensor<128xf64> to memref<?xindex> %0 = sparse_tensor.pointers %arg0, %c : tensor<128xf64> to memref<?xindex>
return %0 : memref<?xindex> return %0 : memref<?xindex>
} }
// ----- // -----
▲ Show 20 Lines • Show All 344 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/roundtrip.mlir

Show All 9 Linesfunc.func @sparse_new(%arg0: !llvm.ptr<i8>) -> tensor<128xf64, #SparseVector> {
%0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<128xf64, #SparseVector> %0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<128xf64, #SparseVector>
return %0 : tensor<128xf64, #SparseVector> return %0 : tensor<128xf64, #SparseVector>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}>
// CHECK-LABEL: func @sparse_release( // CHECK-LABEL: func @sparse_dealloc(
// CHECK-SAME: %[[A:.*]]: tensor<128xf64, #{{.*}}> // CHECK-SAME: %[[A:.*]]: tensor<128xf64, #{{.*}}>
// CHECK: sparse_tensor.release %[[A]] : tensor<128xf64, #{{.*}}> // CHECK: bufferization.dealloc_tensor %[[A]] : tensor<128xf64, #{{.*}}>
// CHECK: return // CHECK: return
func.func @sparse_release(%arg0: tensor<128xf64, #SparseVector>) { func.func @sparse_dealloc(%arg0: tensor<128xf64, #SparseVector>) {
sparse_tensor.release %arg0 : tensor<128xf64, #SparseVector> bufferization.dealloc_tensor %arg0 : tensor<128xf64, #SparseVector>
return return
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}>
// CHECK-LABEL: func @sparse_convert_1d_to_sparse( // CHECK-LABEL: func @sparse_convert_1d_to_sparse(
▲ Show 20 Lines • Show All 253 Lines • ▼ Show 20 Lines
func.func @sparse_reduce_2d_to_1d(%arg0: f64, %arg1: f64) -> f64 { func.func @sparse_reduce_2d_to_1d(%arg0: f64, %arg1: f64) -> f64 {
%cf0 = arith.constant 0.0 : f64 %cf0 = arith.constant 0.0 : f64
%r = sparse_tensor.reduce %arg0, %arg1, %cf0 : f64 { %r = sparse_tensor.reduce %arg0, %arg1, %cf0 : f64 {
^bb0(%x: f64, %y: f64): ^bb0(%x: f64, %y: f64):
sparse_tensor.yield %x : f64 sparse_tensor.yield %x : f64
} }
return %r : f64 return %r : f64
} }
No newline at end of file No newline at end of file

mlir/test/Dialect/SparseTensor/sparse_transpose.mlir

Show All 40 Lines
// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_20]]] : memref<?xindex> // CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_20]]] : memref<?xindex>
// CHECK: memref.store %[[VAL_21]], %[[VAL_11]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK: memref.store %[[VAL_21]], %[[VAL_11]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_20]]] : memref<?xf64> // CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_20]]] : memref<?xf64>
// CHECK: memref.store %[[VAL_22]], %[[VAL_12]][] : memref<f64> // CHECK: memref.store %[[VAL_22]], %[[VAL_12]][] : memref<f64>
// CHECK: sparse_tensor.lex_insert %[[VAL_4]], %[[VAL_11]], %[[VAL_12]] : tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, memref<?xindex>, memref<f64> // CHECK: sparse_tensor.lex_insert %[[VAL_4]], %[[VAL_11]], %[[VAL_12]] : tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, memref<?xindex>, memref<f64>
// CHECK: } // CHECK: }
// CHECK: } // CHECK: }
// CHECK: %[[VAL_23:.*]] = sparse_tensor.load %[[VAL_4]] hasInserts : tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> // CHECK: %[[VAL_23:.*]] = sparse_tensor.load %[[VAL_4]] hasInserts : tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>
// CHECK: sparse_tensor.release %[[VAL_5]] : tensor<3x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)>, pointerBitWidth = 0, indexBitWidth = 0 }>> // CHECK: bufferization.dealloc_tensor %[[VAL_5]] : tensor<3x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)>, pointerBitWidth = 0, indexBitWidth = 0 }>>
// CHECK: return %[[VAL_23]] : tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> // CHECK: return %[[VAL_23]] : tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>
// CHECK: } // CHECK: }
func.func @sparse_transpose_auto(%arga: tensor<3x4xf64, #DCSR>) func.func @sparse_transpose_auto(%arga: tensor<3x4xf64, #DCSR>)
-> tensor<4x3xf64, #DCSR> { -> tensor<4x3xf64, #DCSR> {
%i = bufferization.alloc_tensor() : tensor<4x3xf64, #DCSR> %i = bufferization.alloc_tensor() : tensor<4x3xf64, #DCSR>
%0 = linalg.generic #transpose_trait %0 = linalg.generic #transpose_trait
ins(%arga: tensor<3x4xf64, #DCSR>) ins(%arga: tensor<3x4xf64, #DCSR>)
outs(%i: tensor<4x3xf64, #DCSR>) { outs(%i: tensor<4x3xf64, #DCSR>) {
^bb(%a: f64, %x: f64): ^bb(%a: f64, %x: f64):
linalg.yield %a : f64 linalg.yield %a : f64
} -> tensor<4x3xf64, #DCSR> } -> tensor<4x3xf64, #DCSR>
return %0 : tensor<4x3xf64, #DCSR> return %0 : tensor<4x3xf64, #DCSR>
} }

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

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines func.func @entry() {
// CHECK: ( 2, 0, 0, 2.8, 0, 0, 4, 0, 0, 5, 0, 0, 6, 0, 0, 8.2, 0, 0, 8, 0, 0, 10.4, 0, 0, 10 ) // CHECK: ( 2, 0, 0, 2.8, 0, 0, 4, 0, 0, 5, 0, 0, 6, 0, 0, 8.2, 0, 0, 8, 0, 0, 10.4, 0, 0, 10 )
// //
%m = sparse_tensor.values %0 %m = sparse_tensor.values %0
: tensor<?x?xf64, #DenseMatrix> to memref<?xf64> : tensor<?x?xf64, #DenseMatrix> to memref<?xf64>
%v = vector.load %m[%c0] : memref<?xf64>, vector<25xf64> %v = vector.load %m[%c0] : memref<?xf64>, vector<25xf64>
vector.print %v : vector<25xf64> vector.print %v : vector<25xf64>
// Release the resources. // Release the resources.
sparse_tensor.release %a : tensor<?x?xf64, #SparseMatrix> bufferization.dealloc_tensor %a : tensor<?x?xf64, #SparseMatrix>
sparse_tensor.release %0 : tensor<?x?xf64, #DenseMatrix> bufferization.dealloc_tensor %0 : tensor<?x?xf64, #DenseMatrix>
return return
} }
} }

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

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines func.func @entry() {
// //
// Verify the result. // Verify the result.
// //
// CHECK: ( 1, 11, 0, 2, 13, 0, 0, 0, 0, 0, 14, 3, 0, 0, 0, 0, 15, 4, 16, 0, 5, 6, 0, 0, 0, 0, 0, 0, 7, 8, 0, 9 ) // CHECK: ( 1, 11, 0, 2, 13, 0, 0, 0, 0, 0, 14, 3, 0, 0, 0, 0, 15, 4, 16, 0, 5, 6, 0, 0, 0, 0, 0, 0, 7, 8, 0, 9 )
call @dump_vec(%0) : (tensor<?xbf16, #DenseVector>) -> () call @dump_vec(%0) : (tensor<?xbf16, #DenseVector>) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %sv1 : tensor<?xbf16, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xbf16, #SparseVector>
sparse_tensor.release %sv2 : tensor<?xbf16, #SparseVector> bufferization.dealloc_tensor %sv2 : tensor<?xbf16, #SparseVector>
sparse_tensor.release %0 : tensor<?xbf16, #DenseVector> bufferization.dealloc_tensor %0 : tensor<?xbf16, #DenseVector>
return return
} }
} }

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

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines func.func @entry() {
// //
// Verify the result. // Verify the result.
// //
// CHECK: ( 1, 11, 0, 2, 13, 0, 0, 0, 0, 0, 14, 3, 0, 0, 0, 0, 15, 4, 16, 0, 5, 6, 0, 0, 0, 0, 0, 0, 7, 8, 0, 9 ) // CHECK: ( 1, 11, 0, 2, 13, 0, 0, 0, 0, 0, 14, 3, 0, 0, 0, 0, 15, 4, 16, 0, 5, 6, 0, 0, 0, 0, 0, 0, 7, 8, 0, 9 )
call @dump_vec(%0) : (tensor<?xf16, #DenseVector>) -> () call @dump_vec(%0) : (tensor<?xf16, #DenseVector>) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %sv1 : tensor<?xf16, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xf16, #SparseVector>
sparse_tensor.release %sv2 : tensor<?xf16, #SparseVector> bufferization.dealloc_tensor %sv2 : tensor<?xf16, #SparseVector>
sparse_tensor.release %0 : tensor<?xf16, #DenseVector> bufferization.dealloc_tensor %0 : tensor<?xf16, #DenseVector>
return return
} }
} }

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

Show First 20 Lines • Show All 525 Lines • ▼ Show 20 Lines func.func @entry() {
call @dump_mat_4x4(%6) : (tensor<4x4xf64, #DCSR>) -> () call @dump_mat_4x4(%6) : (tensor<4x4xf64, #DCSR>) -> ()
call @dump_mat_4x4(%7) : (tensor<4x4xf64, #DCSR>) -> () call @dump_mat_4x4(%7) : (tensor<4x4xf64, #DCSR>) -> ()
call @dump_mat_4x4(%8) : (tensor<4x4xf64, #DCSR>) -> () call @dump_mat_4x4(%8) : (tensor<4x4xf64, #DCSR>) -> ()
call @dump_mat_4x4(%9) : (tensor<4x4xf64, #DCSR>) -> () call @dump_mat_4x4(%9) : (tensor<4x4xf64, #DCSR>) -> ()
call @dump_mat_4x4_i8(%10) : (tensor<4x4xi8, #DCSR>) -> () call @dump_mat_4x4_i8(%10) : (tensor<4x4xi8, #DCSR>) -> ()
call @dump_mat_4x4(%11) : (tensor<4x4xf64, #DCSR>) -> () call @dump_mat_4x4(%11) : (tensor<4x4xf64, #DCSR>) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %sv1 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xf64, #SparseVector>
sparse_tensor.release %sv2 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %sv2 : tensor<?xf64, #SparseVector>
sparse_tensor.release %sm1 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %sm1 : tensor<?x?xf64, #DCSR>
sparse_tensor.release %sm2 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %sm2 : tensor<?x?xf64, #DCSR>
sparse_tensor.release %sm3 : tensor<4x4xf64, #DCSR> bufferization.dealloc_tensor %sm3 : tensor<4x4xf64, #DCSR>
sparse_tensor.release %sm4 : tensor<4x4xf64, #DCSR> bufferization.dealloc_tensor %sm4 : tensor<4x4xf64, #DCSR>
sparse_tensor.release %0 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %0 : tensor<?xf64, #SparseVector>
sparse_tensor.release %1 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %1 : tensor<?xf64, #SparseVector>
sparse_tensor.release %2 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %2 : tensor<?xf64, #SparseVector>
sparse_tensor.release %3 : tensor<?xi32, #SparseVector> bufferization.dealloc_tensor %3 : tensor<?xi32, #SparseVector>
sparse_tensor.release %5 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %5 : tensor<?x?xf64, #DCSR>
sparse_tensor.release %6 : tensor<4x4xf64, #DCSR> bufferization.dealloc_tensor %6 : tensor<4x4xf64, #DCSR>
sparse_tensor.release %7 : tensor<4x4xf64, #DCSR> bufferization.dealloc_tensor %7 : tensor<4x4xf64, #DCSR>
sparse_tensor.release %8 : tensor<4x4xf64, #DCSR> bufferization.dealloc_tensor %8 : tensor<4x4xf64, #DCSR>
sparse_tensor.release %9 : tensor<4x4xf64, #DCSR> bufferization.dealloc_tensor %9 : tensor<4x4xf64, #DCSR>
sparse_tensor.release %10 : tensor<4x4xi8, #DCSR> bufferization.dealloc_tensor %10 : tensor<4x4xi8, #DCSR>
sparse_tensor.release %11 : tensor<4x4xf64, #DCSR> bufferization.dealloc_tensor %11 : tensor<4x4xf64, #DCSR>
return return
} }
} }

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

Show First 20 Lines • Show All 251 Lines • ▼ Show 20 Lines func.func @entry() {
// //
// CHECK: ( -1064514355, -1068289229, -1072902963, -1081291571, 0, 1066192077, 1074580685, 1079194419, 1082969293, 1134084096 ) // CHECK: ( -1064514355, -1068289229, -1072902963, -1081291571, 0, 1066192077, 1074580685, 1079194419, 1082969293, 1134084096 )
// //
%c9 = call @sparse_cast_f32_as_s32(%3, %zero_i) : (tensor<10xf32, #SV>, tensor<10xi32>) -> tensor<10xi32> %c9 = call @sparse_cast_f32_as_s32(%3, %zero_i) : (tensor<10xf32, #SV>, tensor<10xi32>) -> tensor<10xi32>
%v9 = vector.transfer_read %c9[%z], %i: tensor<10xi32>, vector<10xi32> %v9 = vector.transfer_read %c9[%z], %i: tensor<10xi32>, vector<10xi32>
vector.print %v9 : vector<10xi32> vector.print %v9 : vector<10xi32>
// Release the resources. // Release the resources.
sparse_tensor.release %1 : tensor<10xi32, #SV> bufferization.dealloc_tensor %1 : tensor<10xi32, #SV>
sparse_tensor.release %3 : tensor<10xf32, #SV> bufferization.dealloc_tensor %3 : tensor<10xf32, #SV>
sparse_tensor.release %5 : tensor<10xf64, #SV> bufferization.dealloc_tensor %5 : tensor<10xf64, #SV>
sparse_tensor.release %7 : tensor<10xf64, #SV> bufferization.dealloc_tensor %7 : tensor<10xf64, #SV>
return return
} }
} }

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

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines func.func @entry() {
// CHECK-NEXT: 18 // CHECK-NEXT: 18
// //
%d1 = arith.constant 4 : index %d1 = arith.constant 4 : index
%d2 = arith.constant 2 : index %d2 = arith.constant 2 : index
call @dump(%0, %d1) : (tensor<?xcomplex<f32>, #SparseVector>, index) -> () call @dump(%0, %d1) : (tensor<?xcomplex<f32>, #SparseVector>, index) -> ()
call @dump(%1, %d2) : (tensor<?xcomplex<f32>, #SparseVector>, index) -> () call @dump(%1, %d2) : (tensor<?xcomplex<f32>, #SparseVector>, index) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %sv1 : tensor<?xcomplex<f32>, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xcomplex<f32>, #SparseVector>
sparse_tensor.release %sv2 : tensor<?xcomplex<f32>, #SparseVector> bufferization.dealloc_tensor %sv2 : tensor<?xcomplex<f32>, #SparseVector>
sparse_tensor.release %0 : tensor<?xcomplex<f32>, #SparseVector> bufferization.dealloc_tensor %0 : tensor<?xcomplex<f32>, #SparseVector>
sparse_tensor.release %1 : tensor<?xcomplex<f32>, #SparseVector> bufferization.dealloc_tensor %1 : tensor<?xcomplex<f32>, #SparseVector>
return return
} }
} }

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

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines func.func @entry() {
// CHECK-NEXT: 18 // CHECK-NEXT: 18
// //
%d1 = arith.constant 4 : index %d1 = arith.constant 4 : index
%d2 = arith.constant 2 : index %d2 = arith.constant 2 : index
call @dump(%0, %d1) : (tensor<?xcomplex<f64>, #SparseVector>, index) -> () call @dump(%0, %d1) : (tensor<?xcomplex<f64>, #SparseVector>, index) -> ()
call @dump(%1, %d2) : (tensor<?xcomplex<f64>, #SparseVector>, index) -> () call @dump(%1, %d2) : (tensor<?xcomplex<f64>, #SparseVector>, index) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %sv1 : tensor<?xcomplex<f64>, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xcomplex<f64>, #SparseVector>
sparse_tensor.release %sv2 : tensor<?xcomplex<f64>, #SparseVector> bufferization.dealloc_tensor %sv2 : tensor<?xcomplex<f64>, #SparseVector>
sparse_tensor.release %0 : tensor<?xcomplex<f64>, #SparseVector> bufferization.dealloc_tensor %0 : tensor<?xcomplex<f64>, #SparseVector>
sparse_tensor.release %1 : tensor<?xcomplex<f64>, #SparseVector> bufferization.dealloc_tensor %1 : tensor<?xcomplex<f64>, #SparseVector>
return return
} }
} }

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

Show First 20 Lines • Show All 235 Lines • ▼ Show 20 Lines func.func @entry() {
// CHECK-NEXT: 2 // CHECK-NEXT: 2
// CHECK-NEXT: 2.5 // CHECK-NEXT: 2.5
// CHECK-NEXT: 3 // CHECK-NEXT: 3
call @dumpc(%5, %d3) : (tensor<?xcomplex<f64>, #SparseVector>, index) -> () call @dumpc(%5, %d3) : (tensor<?xcomplex<f64>, #SparseVector>, index) -> ()
// CHECK-NEXT: ( 5.50608, 5, 7.81025 ) // CHECK-NEXT: ( 5.50608, 5, 7.81025 )
call @dumpf(%6) : (tensor<?xf64, #SparseVector>) -> () call @dumpf(%6) : (tensor<?xf64, #SparseVector>) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %sv1 : tensor<?xcomplex<f64>, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xcomplex<f64>, #SparseVector>
sparse_tensor.release %sv2 : tensor<?xcomplex<f64>, #SparseVector> bufferization.dealloc_tensor %sv2 : tensor<?xcomplex<f64>, #SparseVector>
sparse_tensor.release %0 : tensor<?xcomplex<f64>, #SparseVector> bufferization.dealloc_tensor %0 : tensor<?xcomplex<f64>, #SparseVector>
sparse_tensor.release %1 : tensor<?xcomplex<f64>, #SparseVector> bufferization.dealloc_tensor %1 : tensor<?xcomplex<f64>, #SparseVector>
sparse_tensor.release %2 : tensor<?xcomplex<f64>, #SparseVector> bufferization.dealloc_tensor %2 : tensor<?xcomplex<f64>, #SparseVector>
sparse_tensor.release %3 : tensor<?xcomplex<f64>, #SparseVector> bufferization.dealloc_tensor %3 : tensor<?xcomplex<f64>, #SparseVector>
sparse_tensor.release %4 : tensor<?xcomplex<f64>, #SparseVector> bufferization.dealloc_tensor %4 : tensor<?xcomplex<f64>, #SparseVector>
sparse_tensor.release %5 : tensor<?xcomplex<f64>, #SparseVector> bufferization.dealloc_tensor %5 : tensor<?xcomplex<f64>, #SparseVector>
sparse_tensor.release %6 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %6 : tensor<?xf64, #SparseVector>
return return
} }
} }

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

Show All 35 Lines func.func @entry() {
vector.print %i1r : vector<8xindex> vector.print %i1r : vector<8xindex>
// CHECK: ( 1, 2, 3, 4, 5, 6, 7, 8 ) // CHECK: ( 1, 2, 3, 4, 5, 6, 7, 8 )
%v = sparse_tensor.values %ts : tensor<10x8xf64, #Tensor1> to memref<?xf64> %v = sparse_tensor.values %ts : tensor<10x8xf64, #Tensor1> to memref<?xf64>
%vr = vector.transfer_read %v[%c0], %d0: memref<?xf64>, vector<8xf64> %vr = vector.transfer_read %v[%c0], %d0: memref<?xf64>, vector<8xf64>
vector.print %vr : vector<8xf64> vector.print %vr : vector<8xf64>
// Release the resources. // Release the resources.
sparse_tensor.release %ts : tensor<10x8xf64, #Tensor1> bufferization.dealloc_tensor %ts : tensor<10x8xf64, #Tensor1>
return return
} }
} }

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

Show First 20 Lines • Show All 243 Lines • ▼ Show 20 Lines func.func @entry() {
call @dumpidx(%h30) : (memref<?xindex>) -> () call @dumpidx(%h30) : (memref<?xindex>) -> ()
call @dumpidx(%h31) : (memref<?xindex>) -> () call @dumpidx(%h31) : (memref<?xindex>) -> ()
call @dumpidx(%h32) : (memref<?xindex>) -> () call @dumpidx(%h32) : (memref<?xindex>) -> ()
call @dumpidx(%i30) : (memref<?xindex>) -> () call @dumpidx(%i30) : (memref<?xindex>) -> ()
call @dumpidx(%i31) : (memref<?xindex>) -> () call @dumpidx(%i31) : (memref<?xindex>) -> ()
call @dumpidx(%i32) : (memref<?xindex>) -> () call @dumpidx(%i32) : (memref<?xindex>) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %1 : tensor<2x3x4xf64, #Tensor1> bufferization.dealloc_tensor %1 : tensor<2x3x4xf64, #Tensor1>
sparse_tensor.release %2 : tensor<2x3x4xf64, #Tensor2> bufferization.dealloc_tensor %2 : tensor<2x3x4xf64, #Tensor2>
sparse_tensor.release %3 : tensor<2x3x4xf64, #Tensor3> bufferization.dealloc_tensor %3 : tensor<2x3x4xf64, #Tensor3>
sparse_tensor.release %b : tensor<2x3x4xf64, #Tensor1> bufferization.dealloc_tensor %b : tensor<2x3x4xf64, #Tensor1>
sparse_tensor.release %c : tensor<2x3x4xf64, #Tensor1> bufferization.dealloc_tensor %c : tensor<2x3x4xf64, #Tensor1>
sparse_tensor.release %d : tensor<2x3x4xf64, #Tensor2> bufferization.dealloc_tensor %d : tensor<2x3x4xf64, #Tensor2>
sparse_tensor.release %f : tensor<2x3x4xf64, #Tensor2> bufferization.dealloc_tensor %f : tensor<2x3x4xf64, #Tensor2>
sparse_tensor.release %g : tensor<2x3x4xf64, #Tensor3> bufferization.dealloc_tensor %g : tensor<2x3x4xf64, #Tensor3>
sparse_tensor.release %h : tensor<2x3x4xf64, #Tensor3> bufferization.dealloc_tensor %h : tensor<2x3x4xf64, #Tensor3>
return return
} }
} }

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

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines func.func @entry() {
call @dump(%m1) : (memref<?xf64>) -> () call @dump(%m1) : (memref<?xf64>) -> ()
call @dump(%m2) : (memref<?xf64>) -> () call @dump(%m2) : (memref<?xf64>) -> ()
call @dump(%m3) : (memref<?xf64>) -> () call @dump(%m3) : (memref<?xf64>) -> ()
call @dump(%m4) : (memref<?xf64>) -> () call @dump(%m4) : (memref<?xf64>) -> ()
call @dump(%m5) : (memref<?xf64>) -> () call @dump(%m5) : (memref<?xf64>) -> ()
call @dump(%m6) : (memref<?xf64>) -> () call @dump(%m6) : (memref<?xf64>) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %1 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %1 : tensor<?x?xf64, #DCSR>
sparse_tensor.release %2 : tensor<?x?xf64, #DCSC> bufferization.dealloc_tensor %2 : tensor<?x?xf64, #DCSC>
sparse_tensor.release %3 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %3 : tensor<?x?xf64, #DCSR>
sparse_tensor.release %4 : tensor<?x?xf64, #DCSC> bufferization.dealloc_tensor %4 : tensor<?x?xf64, #DCSC>
sparse_tensor.release %5 : tensor<?x?xf64, #DCSC> bufferization.dealloc_tensor %5 : tensor<?x?xf64, #DCSC>
sparse_tensor.release %6 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %6 : tensor<?x?xf64, #DCSR>
return return
} }
} }

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

Show First 20 Lines • Show All 122 Lines • ▼ Show 20 Lines func.func @entry() {
call @dumpi08(%i1) : (memref<?xi8>) -> () call @dumpi08(%i1) : (memref<?xi8>) -> ()
call @dumpi64(%i2) : (memref<?xi64>) -> () call @dumpi64(%i2) : (memref<?xi64>) -> ()
call @dumpi32(%i3) : (memref<?xi32>) -> () call @dumpi32(%i3) : (memref<?xi32>) -> ()
call @dumpi64(%i4) : (memref<?xi64>) -> () call @dumpi64(%i4) : (memref<?xi64>) -> ()
call @dumpi08(%i5) : (memref<?xi08>) -> () call @dumpi08(%i5) : (memref<?xi08>) -> ()
call @dumpi08(%i6) : (memref<?xi08>) -> () call @dumpi08(%i6) : (memref<?xi08>) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %1 : tensor<32x64xf64, #DCSR> bufferization.dealloc_tensor %1 : tensor<32x64xf64, #DCSR>
sparse_tensor.release %2 : tensor<32x64xf64, #DCSC> bufferization.dealloc_tensor %2 : tensor<32x64xf64, #DCSC>
sparse_tensor.release %3 : tensor<32x64xf64, #CSC> bufferization.dealloc_tensor %3 : tensor<32x64xf64, #CSC>
sparse_tensor.release %4 : tensor<32x64xf64, #DCSC> bufferization.dealloc_tensor %4 : tensor<32x64xf64, #DCSC>
sparse_tensor.release %5 : tensor<32x64xf64, #DCSR> bufferization.dealloc_tensor %5 : tensor<32x64xf64, #DCSR>
sparse_tensor.release %6 : tensor<32x64xf64, #DCSR> bufferization.dealloc_tensor %6 : tensor<32x64xf64, #DCSR>
return return
} }
} }

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

Show First 20 Lines • Show All 191 Lines • ▼ Show 20 Lines func.func @entry() {
call @dumpAndRelease_pp4(%dpp46) : (tensor<?x?x4xf64>) -> () call @dumpAndRelease_pp4(%dpp46) : (tensor<?x?x4xf64>) -> ()
call @dumpAndRelease_ppp(%dppp4) : (tensor<?x?x?xf64>) -> () call @dumpAndRelease_ppp(%dppp4) : (tensor<?x?x?xf64>) -> ()
call @dumpAndRelease_ppp(%dppp5) : (tensor<?x?x?xf64>) -> () call @dumpAndRelease_ppp(%dppp5) : (tensor<?x?x?xf64>) -> ()
call @dumpAndRelease_ppp(%dppp6) : (tensor<?x?x?xf64>) -> () call @dumpAndRelease_ppp(%dppp6) : (tensor<?x?x?xf64>) -> ()
// //
// Release sparse tensors. // Release sparse tensors.
// //
sparse_tensor.release %s2341 : tensor<2x3x4xf64, #Tensor1> bufferization.dealloc_tensor %s2341 : tensor<2x3x4xf64, #Tensor1>
sparse_tensor.release %s2342 : tensor<2x3x4xf64, #Tensor2> bufferization.dealloc_tensor %s2342 : tensor<2x3x4xf64, #Tensor2>
sparse_tensor.release %s2343 : tensor<2x3x4xf64, #Tensor3> bufferization.dealloc_tensor %s2343 : tensor<2x3x4xf64, #Tensor3>
sparse_tensor.release %s2344 : tensor<2x3x4xf64, #Tensor4> bufferization.dealloc_tensor %s2344 : tensor<2x3x4xf64, #Tensor4>
sparse_tensor.release %s2345 : tensor<2x3x4xf64, #Tensor5> bufferization.dealloc_tensor %s2345 : tensor<2x3x4xf64, #Tensor5>
sparse_tensor.release %s2346 : tensor<2x3x4xf64, #Tensor6> bufferization.dealloc_tensor %s2346 : tensor<2x3x4xf64, #Tensor6>
sparse_tensor.release %sp344 : tensor<?x3x4xf64, #Tensor4> bufferization.dealloc_tensor %sp344 : tensor<?x3x4xf64, #Tensor4>
sparse_tensor.release %sp345 : tensor<?x3x4xf64, #Tensor5> bufferization.dealloc_tensor %sp345 : tensor<?x3x4xf64, #Tensor5>
sparse_tensor.release %sp346 : tensor<?x3x4xf64, #Tensor6> bufferization.dealloc_tensor %sp346 : tensor<?x3x4xf64, #Tensor6>
sparse_tensor.release %s2p44 : tensor<2x?x4xf64, #Tensor4> bufferization.dealloc_tensor %s2p44 : tensor<2x?x4xf64, #Tensor4>
sparse_tensor.release %s2p45 : tensor<2x?x4xf64, #Tensor5> bufferization.dealloc_tensor %s2p45 : tensor<2x?x4xf64, #Tensor5>
sparse_tensor.release %s2p46 : tensor<2x?x4xf64, #Tensor6> bufferization.dealloc_tensor %s2p46 : tensor<2x?x4xf64, #Tensor6>
sparse_tensor.release %s23p4 : tensor<2x3x?xf64, #Tensor4> bufferization.dealloc_tensor %s23p4 : tensor<2x3x?xf64, #Tensor4>
sparse_tensor.release %s23p5 : tensor<2x3x?xf64, #Tensor5> bufferization.dealloc_tensor %s23p5 : tensor<2x3x?xf64, #Tensor5>
sparse_tensor.release %s23p6 : tensor<2x3x?xf64, #Tensor6> bufferization.dealloc_tensor %s23p6 : tensor<2x3x?xf64, #Tensor6>
sparse_tensor.release %s2pp4 : tensor<2x?x?xf64, #Tensor4> bufferization.dealloc_tensor %s2pp4 : tensor<2x?x?xf64, #Tensor4>
sparse_tensor.release %s2pp5 : tensor<2x?x?xf64, #Tensor5> bufferization.dealloc_tensor %s2pp5 : tensor<2x?x?xf64, #Tensor5>
sparse_tensor.release %s2pp6 : tensor<2x?x?xf64, #Tensor6> bufferization.dealloc_tensor %s2pp6 : tensor<2x?x?xf64, #Tensor6>
return return
} }
} }

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

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines func.func @entry() {
call @dumpAndRelease_234(%d13) : (tensor<2x3x4xf64>) -> () call @dumpAndRelease_234(%d13) : (tensor<2x3x4xf64>) -> ()
call @dumpAndRelease_234(%d21) : (tensor<2x3x4xf64>) -> () call @dumpAndRelease_234(%d21) : (tensor<2x3x4xf64>) -> ()
call @dumpAndRelease_234(%d23) : (tensor<2x3x4xf64>) -> () call @dumpAndRelease_234(%d23) : (tensor<2x3x4xf64>) -> ()
call @dumpAndRelease_234(%d31) : (tensor<2x3x4xf64>) -> () call @dumpAndRelease_234(%d31) : (tensor<2x3x4xf64>) -> ()
// //
// Release sparse tensors. // Release sparse tensors.
// //
sparse_tensor.release %t13 : tensor<2x3x4xf64, #Tensor3> bufferization.dealloc_tensor %t13 : tensor<2x3x4xf64, #Tensor3>
sparse_tensor.release %t21 : tensor<2x3x4xf64, #Tensor1> bufferization.dealloc_tensor %t21 : tensor<2x3x4xf64, #Tensor1>
sparse_tensor.release %t23 : tensor<2x3x4xf64, #Tensor3> bufferization.dealloc_tensor %t23 : tensor<2x3x4xf64, #Tensor3>
sparse_tensor.release %t31 : tensor<2x3x4xf64, #Tensor1> bufferization.dealloc_tensor %t31 : tensor<2x3x4xf64, #Tensor1>
sparse_tensor.release %s1 : tensor<2x3x4xf64, #Tensor1> bufferization.dealloc_tensor %s1 : tensor<2x3x4xf64, #Tensor1>
sparse_tensor.release %s2 : tensor<2x3x4xf64, #Tensor2> bufferization.dealloc_tensor %s2 : tensor<2x3x4xf64, #Tensor2>
sparse_tensor.release %s3 : tensor<2x3x4xf64, #Tensor3> bufferization.dealloc_tensor %s3 : tensor<2x3x4xf64, #Tensor3>
return return
} }
} }

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

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines func.func @entry() {
%x = tensor.insert %z into %t[] : tensor<f32> %x = tensor.insert %z into %t[] : tensor<f32>
%0 = call @sparse_dot(%s1, %s2, %x) : (tensor<1024xf32, #SparseVector>, %0 = call @sparse_dot(%s1, %s2, %x) : (tensor<1024xf32, #SparseVector>,
tensor<1024xf32, #SparseVector>, tensor<1024xf32, #SparseVector>,
tensor<f32>) -> tensor<f32> tensor<f32>) -> tensor<f32>
%1 = tensor.extract %0[] : tensor<f32> %1 = tensor.extract %0[] : tensor<f32>
vector.print %1 : f32 vector.print %1 : f32
// Release the resources. // Release the resources.
sparse_tensor.release %s1 : tensor<1024xf32, #SparseVector> bufferization.dealloc_tensor %s1 : tensor<1024xf32, #SparseVector>
sparse_tensor.release %s2 : tensor<1024xf32, #SparseVector> bufferization.dealloc_tensor %s2 : tensor<1024xf32, #SparseVector>
return return
} }
} }

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

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines func.func @entry() {
// CHECK-SAME: ( 0, 0, 3, 6, -3, -6 ), // CHECK-SAME: ( 0, 0, 3, 6, -3, -6 ),
// CHECK-SAME: ( 2, -1, 3, 0, -3, 0 ) ) // CHECK-SAME: ( 2, -1, 3, 0, -3, 0 ) )
// //
%v = vector.transfer_read %0[%c0, %c0], %i0 %v = vector.transfer_read %0[%c0, %c0], %i0
: tensor<6x6xi32>, vector<6x6xi32> : tensor<6x6xi32>, vector<6x6xi32>
vector.print %v : vector<6x6xi32> vector.print %v : vector<6x6xi32>
// Release the resources. // Release the resources.
sparse_tensor.release %sparse_filter : tensor<3x3xi32, #DCSR> bufferization.dealloc_tensor %sparse_filter : tensor<3x3xi32, #DCSR>
return return
} }
} }

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

Show First 20 Lines • Show All 98 Lines • ▼ Show 20 Lines func.func @entry() {
%r = bufferization.to_memref %0 : memref<7x3xf64> %r = bufferization.to_memref %0 : memref<7x3xf64>
scf.for %i = %c0 to %c7 step %c1 { scf.for %i = %c0 to %c7 step %c1 {
%v = vector.transfer_read %r[%i, %c0], %d0: memref<7x3xf64>, vector<3xf64> %v = vector.transfer_read %r[%i, %c0], %d0: memref<7x3xf64>, vector<3xf64>
vector.print %v : vector<3xf64> vector.print %v : vector<3xf64>
} }
// Release the resources. // Release the resources.
memref.dealloc %xdata : memref<7x3xf64> memref.dealloc %xdata : memref<7x3xf64>
sparse_tensor.release %a : tensor<7x3x3x3x3x3x5x3xf64, #SparseTensor> bufferization.dealloc_tensor %a : tensor<7x3x3x3x3x3x5x3xf64, #SparseTensor>
return return
} }
} }

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

Show First 20 Lines • Show All 209 Lines • ▼ Show 20 Lines func.func @entry() {
vector.print %18 : vector<8xi64> vector.print %18 : vector<8xi64>
vector.print %19 : vector<8xi64> vector.print %19 : vector<8xi64>
vector.print %20 : vector<12xi64> vector.print %20 : vector<12xi64>
vector.print %21 : vector<12xi64> vector.print %21 : vector<12xi64>
vector.print %22 : vector<12xi64> vector.print %22 : vector<12xi64>
vector.print %23 : vector<12xi64> vector.print %23 : vector<12xi64>
// Release resources. // Release resources.
sparse_tensor.release %sv : tensor<8xi64, #SparseVector> bufferization.dealloc_tensor %sv : tensor<8xi64, #SparseVector>
sparse_tensor.release %dv : tensor<8xi64, #SparseVector> bufferization.dealloc_tensor %dv : tensor<8xi64, #SparseVector>
sparse_tensor.release %0 : tensor<8xi64, #SparseVector> bufferization.dealloc_tensor %0 : tensor<8xi64, #SparseVector>
sparse_tensor.release %1 : tensor<8xi64, #SparseVector> bufferization.dealloc_tensor %1 : tensor<8xi64, #SparseVector>
sparse_tensor.release %2 : tensor<8xi64, #SparseVector> bufferization.dealloc_tensor %2 : tensor<8xi64, #SparseVector>
sparse_tensor.release %3 : tensor<8xi64, #SparseVector> bufferization.dealloc_tensor %3 : tensor<8xi64, #SparseVector>
sparse_tensor.release %sm : tensor<3x4xi64, #SparseMatrix> bufferization.dealloc_tensor %sm : tensor<3x4xi64, #SparseMatrix>
sparse_tensor.release %dm : tensor<3x4xi64, #SparseMatrix> bufferization.dealloc_tensor %dm : tensor<3x4xi64, #SparseMatrix>
sparse_tensor.release %4 : tensor<3x4xi64, #SparseMatrix> bufferization.dealloc_tensor %4 : tensor<3x4xi64, #SparseMatrix>
sparse_tensor.release %5 : tensor<3x4xi64, #SparseMatrix> bufferization.dealloc_tensor %5 : tensor<3x4xi64, #SparseMatrix>
sparse_tensor.release %6 : tensor<3x4xi64, #SparseMatrix> bufferization.dealloc_tensor %6 : tensor<3x4xi64, #SparseMatrix>
sparse_tensor.release %7 : tensor<3x4xi64, #SparseMatrix> bufferization.dealloc_tensor %7 : tensor<3x4xi64, #SparseMatrix>
// //
// Call the f32 kernel, verify the result, release the resources. // Call the f32 kernel, verify the result, release the resources.
// //
// CHECK-NEXT: ( 0, 10, 0, 1, 1, 42 ) // CHECK-NEXT: ( 0, 10, 0, 1, 1, 42 )
// //
%100 = call @add_outer_2d(%sf32) : (tensor<2x3xf32, #SparseMatrix>) %100 = call @add_outer_2d(%sf32) : (tensor<2x3xf32, #SparseMatrix>)
-> tensor<2x3xf32, #SparseMatrix> -> tensor<2x3xf32, #SparseMatrix>
%101 = sparse_tensor.values %100 : tensor<2x3xf32, #SparseMatrix> to memref<?xf32> %101 = sparse_tensor.values %100 : tensor<2x3xf32, #SparseMatrix> to memref<?xf32>
%102 = vector.transfer_read %101[%c0], %df: memref<?xf32>, vector<6xf32> %102 = vector.transfer_read %101[%c0], %df: memref<?xf32>, vector<6xf32>
vector.print %102 : vector<6xf32> vector.print %102 : vector<6xf32>
sparse_tensor.release %sf32 : tensor<2x3xf32, #SparseMatrix> bufferization.dealloc_tensor %sf32 : tensor<2x3xf32, #SparseMatrix>
sparse_tensor.release %100 : tensor<2x3xf32, #SparseMatrix> bufferization.dealloc_tensor %100 : tensor<2x3xf32, #SparseMatrix>
return return
} }
} }

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

Show First 20 Lines • Show All 184 Lines • ▼ Show 20 Lines func.func @entry() {
vector.print %vv2 : vector<8xi64> vector.print %vv2 : vector<8xi64>
vector.print %vv3 : vector<8xi64> vector.print %vv3 : vector<8xi64>
vector.print %vv4 : vector<3x4xi64> vector.print %vv4 : vector<3x4xi64>
vector.print %vv5 : vector<3x4xi64> vector.print %vv5 : vector<3x4xi64>
vector.print %vv6 : vector<3x4xi64> vector.print %vv6 : vector<3x4xi64>
vector.print %vv7 : vector<3x4xi64> vector.print %vv7 : vector<3x4xi64>
// Release resources. // Release resources.
sparse_tensor.release %sv : tensor<8xi64, #SparseVector> bufferization.dealloc_tensor %sv : tensor<8xi64, #SparseVector>
sparse_tensor.release %dv : tensor<8xi64, #SparseVector> bufferization.dealloc_tensor %dv : tensor<8xi64, #SparseVector>
sparse_tensor.release %sm : tensor<3x4xi64, #SparseMatrix> bufferization.dealloc_tensor %sm : tensor<3x4xi64, #SparseMatrix>
sparse_tensor.release %dm : tensor<3x4xi64, #SparseMatrix> bufferization.dealloc_tensor %dm : tensor<3x4xi64, #SparseMatrix>
memref.dealloc %mem0 : memref<8xi64> memref.dealloc %mem0 : memref<8xi64>
memref.dealloc %mem1 : memref<8xi64> memref.dealloc %mem1 : memref<8xi64>
memref.dealloc %mem2 : memref<8xi64> memref.dealloc %mem2 : memref<8xi64>
memref.dealloc %mem3 : memref<8xi64> memref.dealloc %mem3 : memref<8xi64>
memref.dealloc %mem4 : memref<3x4xi64> memref.dealloc %mem4 : memref<3x4xi64>
memref.dealloc %mem5 : memref<3x4xi64> memref.dealloc %mem5 : memref<3x4xi64>
memref.dealloc %mem6 : memref<3x4xi64> memref.dealloc %mem6 : memref<3x4xi64>
memref.dealloc %mem7 : memref<3x4xi64> memref.dealloc %mem7 : memref<3x4xi64>
return return
} }
} }

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

Show First 20 Lines • Show All 218 Lines • ▼ Show 20 Lines func.func @entry() {
%val7 = sparse_tensor.values %7 : tensor<4x4xf64, #CSR> to memref<?xf64> %val7 = sparse_tensor.values %7 : tensor<4x4xf64, #CSR> to memref<?xf64>
%val8 = sparse_tensor.values %8 : tensor<4x4xf64, #DCSR> to memref<?xf64> %val8 = sparse_tensor.values %8 : tensor<4x4xf64, #DCSR> to memref<?xf64>
%nz7 = vector.transfer_read %val7[%c0], %d1 : memref<?xf64>, vector<8xf64> %nz7 = vector.transfer_read %val7[%c0], %d1 : memref<?xf64>, vector<8xf64>
%nz8 = vector.transfer_read %val8[%c0], %d1 : memref<?xf64>, vector<8xf64> %nz8 = vector.transfer_read %val8[%c0], %d1 : memref<?xf64>, vector<8xf64>
vector.print %nz7 : vector<8xf64> vector.print %nz7 : vector<8xf64>
vector.print %nz8 : vector<8xf64> vector.print %nz8 : vector<8xf64>
// Release the resources. // Release the resources.
sparse_tensor.release %a1 : tensor<4x8xf64, #CSR> bufferization.dealloc_tensor %a1 : tensor<4x8xf64, #CSR>
sparse_tensor.release %a2 : tensor<4x8xf64, #DCSR> bufferization.dealloc_tensor %a2 : tensor<4x8xf64, #DCSR>
sparse_tensor.release %a3 : tensor<4x8xf64, #CSR> bufferization.dealloc_tensor %a3 : tensor<4x8xf64, #CSR>
sparse_tensor.release %a4 : tensor<4x8xf64, #DCSR> bufferization.dealloc_tensor %a4 : tensor<4x8xf64, #DCSR>
sparse_tensor.release %b1 : tensor<8x4xf64, #CSR> bufferization.dealloc_tensor %b1 : tensor<8x4xf64, #CSR>
sparse_tensor.release %b2 : tensor<8x4xf64, #DCSR> bufferization.dealloc_tensor %b2 : tensor<8x4xf64, #DCSR>
sparse_tensor.release %b3 : tensor<8x4xf64, #CSR> bufferization.dealloc_tensor %b3 : tensor<8x4xf64, #CSR>
sparse_tensor.release %b4 : tensor<8x4xf64, #DCSR> bufferization.dealloc_tensor %b4 : tensor<8x4xf64, #DCSR>
sparse_tensor.release %1 : tensor<4x4xf64, #CSR> bufferization.dealloc_tensor %1 : tensor<4x4xf64, #CSR>
sparse_tensor.release %2 : tensor<4x4xf64, #DCSR> bufferization.dealloc_tensor %2 : tensor<4x4xf64, #DCSR>
sparse_tensor.release %4 : tensor<4x4xf64, #CSR> bufferization.dealloc_tensor %4 : tensor<4x4xf64, #CSR>
sparse_tensor.release %5 : tensor<4x4xf64, #DCSR> bufferization.dealloc_tensor %5 : tensor<4x4xf64, #DCSR>
sparse_tensor.release %7 : tensor<4x4xf64, #CSR> bufferization.dealloc_tensor %7 : tensor<4x4xf64, #CSR>
sparse_tensor.release %8 : tensor<4x4xf64, #DCSR> bufferization.dealloc_tensor %8 : tensor<4x4xf64, #DCSR>
return return
} }
} }

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

Show First 20 Lines • Show All 152 Lines • ▼ Show 20 Lines func.func @entry() {
call @dump(%sm1) : (tensor<?x?xf64, #DCSR>) -> () call @dump(%sm1) : (tensor<?x?xf64, #DCSR>) -> ()
call @dump(%sm2) : (tensor<?x?xf64, #DCSR>) -> () call @dump(%sm2) : (tensor<?x?xf64, #DCSR>) -> ()
call @dump(%0) : (tensor<?x?xf64, #DCSR>) -> () call @dump(%0) : (tensor<?x?xf64, #DCSR>) -> ()
call @dump(%1) : (tensor<?x?xf64, #DCSR>) -> () call @dump(%1) : (tensor<?x?xf64, #DCSR>) -> ()
call @dump(%2) : (tensor<?x?xf64, #DCSR>) -> () call @dump(%2) : (tensor<?x?xf64, #DCSR>) -> ()
call @dump(%3) : (tensor<?x?xf64, #DCSR>) -> () call @dump(%3) : (tensor<?x?xf64, #DCSR>) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %sm1 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %sm1 : tensor<?x?xf64, #DCSR>
sparse_tensor.release %sm1_dup : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %sm1_dup : tensor<?x?xf64, #DCSR>
sparse_tensor.release %sm2 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %sm2 : tensor<?x?xf64, #DCSR>
sparse_tensor.release %0 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %0 : tensor<?x?xf64, #DCSR>
sparse_tensor.release %2 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %2 : tensor<?x?xf64, #DCSR>
sparse_tensor.release %3 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %3 : tensor<?x?xf64, #DCSR>
return return
} }
} }

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

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines func.func @entry() {
// //
%m = bufferization.to_memref %0 : memref<?xi32> %m = bufferization.to_memref %0 : memref<?xi32>
%v = vector.transfer_read %m[%c0], %i0: memref<?xi32>, vector<4xi32> %v = vector.transfer_read %m[%c0], %i0: memref<?xi32>, vector<4xi32>
vector.print %v : vector<4xi32> vector.print %v : vector<4xi32>
// Release the resources. // Release the resources.
memref.dealloc %bdata : memref<?xi32> memref.dealloc %bdata : memref<?xi32>
memref.dealloc %xdata : memref<?xi32> memref.dealloc %xdata : memref<?xi32>
sparse_tensor.release %a : tensor<?x?xi32, #SparseMatrix> bufferization.dealloc_tensor %a : tensor<?x?xi32, #SparseMatrix>
return return
} }
} }

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

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Lines func.func @entry() {
%v = vector.transfer_read %m[%c0, %c0], %f0 %v = vector.transfer_read %m[%c0, %c0], %f0
: memref<?x?xf64>, vector<2x5xf64> : memref<?x?xf64>, vector<2x5xf64>
vector.print %v : vector<2x5xf64> vector.print %v : vector<2x5xf64>
// Release the resources. // Release the resources.
memref.dealloc %adata : memref<?x?xf64> memref.dealloc %adata : memref<?x?xf64>
memref.dealloc %cdata : memref<?x?xf64> memref.dealloc %cdata : memref<?x?xf64>
memref.dealloc %ddata : memref<?x?xf64> memref.dealloc %ddata : memref<?x?xf64>
sparse_tensor.release %b : tensor<?x?x?xf64, #SparseTensor> bufferization.dealloc_tensor %b : tensor<?x?x?xf64, #SparseTensor>
return return
} }
} }

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

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines func.func @entry() {
// //
// CHECK: ( 14, 20, -1, -1 ) // CHECK: ( 14, 20, -1, -1 )
// //
%val = sparse_tensor.values %0 : tensor<32x16xf32, #DCSR> to memref<?xf32> %val = sparse_tensor.values %0 : tensor<32x16xf32, #DCSR> to memref<?xf32>
%vv = vector.transfer_read %val[%c0], %f1: memref<?xf32>, vector<4xf32> %vv = vector.transfer_read %val[%c0], %f1: memref<?xf32>, vector<4xf32>
vector.print %vv : vector<4xf32> vector.print %vv : vector<4xf32>
// Release the resources. // Release the resources.
sparse_tensor.release %sta : tensor<32x16xf32, #DCSR> bufferization.dealloc_tensor %sta : tensor<32x16xf32, #DCSR>
sparse_tensor.release %stb : tensor<32x16xf32, #DCSR> bufferization.dealloc_tensor %stb : tensor<32x16xf32, #DCSR>
sparse_tensor.release %0 : tensor<32x16xf32, #DCSR> bufferization.dealloc_tensor %0 : tensor<32x16xf32, #DCSR>
return return
} }
} }

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

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines func.func @entry() {
%vv = vector.transfer_read %val[%c0], %i0: memref<?xi32>, vector<4xi32> %vv = vector.transfer_read %val[%c0], %i0: memref<?xi32>, vector<4xi32>
vector.print %vv : vector<4xi32> vector.print %vv : vector<4xi32>
%dm = sparse_tensor.convert %0 %dm = sparse_tensor.convert %0
: tensor<?x?xi32, #SparseMatrix> to tensor<?x?xi32> : tensor<?x?xi32, #SparseMatrix> to tensor<?x?xi32>
%vm = vector.transfer_read %dm[%c0, %c0], %i0: tensor<?x?xi32>, vector<3x3xi32> %vm = vector.transfer_read %dm[%c0, %c0], %i0: tensor<?x?xi32>, vector<3x3xi32>
vector.print %vm : vector<3x3xi32> vector.print %vm : vector<3x3xi32>
// Release the resources. // Release the resources.
sparse_tensor.release %st1 : tensor<?x?x?xi32, #SparseTensor> bufferization.dealloc_tensor %st1 : tensor<?x?x?xi32, #SparseTensor>
sparse_tensor.release %st2 : tensor<?x?x?xi32, #SparseTensor> bufferization.dealloc_tensor %st2 : tensor<?x?x?xi32, #SparseTensor>
sparse_tensor.release %0 : tensor<?x?xi32, #SparseMatrix> bufferization.dealloc_tensor %0 : tensor<?x?xi32, #SparseMatrix>
return return
} }
} }

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

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines func.func @entry() {
// //
// CHECK: ( 1, 1.96, 4, 6.25, 9, 16.81, 16, 27.04, 25 ) // CHECK: ( 1, 1.96, 4, 6.25, 9, 16.81, 16, 27.04, 25 )
// //
%m = sparse_tensor.values %0 : tensor<?x?xf64, #DCSR> to memref<?xf64> %m = sparse_tensor.values %0 : tensor<?x?xf64, #DCSR> to memref<?xf64>
%v = vector.transfer_read %m[%c0], %d0: memref<?xf64>, vector<9xf64> %v = vector.transfer_read %m[%c0], %d0: memref<?xf64>, vector<9xf64>
vector.print %v : vector<9xf64> vector.print %v : vector<9xf64>
// Release the resources. // Release the resources.
sparse_tensor.release %x : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %x : tensor<?x?xf64, #DCSR>
return return
} }
} }

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

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines func.func @entry() {
// CHECK-SAME: ( -254, 0, 256, -300, -30, -6 ), // CHECK-SAME: ( -254, 0, 256, -300, -30, -6 ),
// CHECK-SAME: ( 1397, 0, -1408, 100, 10, 33 ) ) // CHECK-SAME: ( 1397, 0, -1408, 100, 10, 33 ) )
// //
%v = vector.transfer_read %0[%c0, %c0], %i0 %v = vector.transfer_read %0[%c0, %c0], %i0
: tensor<5x6xi32>, vector<5x6xi32> : tensor<5x6xi32>, vector<5x6xi32>
vector.print %v : vector<5x6xi32> vector.print %v : vector<5x6xi32>
// Release the resources. // Release the resources.
sparse_tensor.release %sparse_input2 : tensor<3x6xi8, #DCSR> bufferization.dealloc_tensor %sparse_input2 : tensor<3x6xi8, #DCSR>
return return
} }
} }

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

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines func.func @entry() {
// CHECK-NEXT: ( 0, 20, 31, 0 ) // CHECK-NEXT: ( 0, 20, 31, 0 )
// CHECK-NEXT: ( 2, 4, 6, -1 ) // CHECK-NEXT: ( 2, 4, 6, -1 )
// CHECK-NEXT: ( 0, 20, 31, 0 ) // CHECK-NEXT: ( 0, 20, 31, 0 )
// //
call @dump(%0) : (tensor<?xf32, #SparseVector>) -> () call @dump(%0) : (tensor<?xf32, #SparseVector>) -> ()
call @dump(%1) : (tensor<?xf32, #SparseVector>) -> () call @dump(%1) : (tensor<?xf32, #SparseVector>) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %sv1 : tensor<?xcomplex<f32>, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xcomplex<f32>, #SparseVector>
sparse_tensor.release %0 : tensor<?xf32, #SparseVector> bufferization.dealloc_tensor %0 : tensor<?xf32, #SparseVector>
sparse_tensor.release %1 : tensor<?xf32, #SparseVector> bufferization.dealloc_tensor %1 : tensor<?xf32, #SparseVector>
return return
} }
} }

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

Show First 20 Lines • Show All 188 Lines • ▼ Show 20 Lines func.func @entry() {
call @dump_f32(%1) : (tensor<f32>) -> () call @dump_f32(%1) : (tensor<f32>) -> ()
call @dump_i32(%2) : (tensor<i32>) -> () call @dump_i32(%2) : (tensor<i32>) -> ()
call @dump_f32(%3) : (tensor<f32>) -> () call @dump_f32(%3) : (tensor<f32>) -> ()
call @dump_i32(%4) : (tensor<i32>) -> () call @dump_i32(%4) : (tensor<i32>) -> ()
call @dump_i32(%5) : (tensor<i32>) -> () call @dump_i32(%5) : (tensor<i32>) -> ()
call @dump_i32(%6) : (tensor<i32>) -> () call @dump_i32(%6) : (tensor<i32>) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %sparse_input_i32 : tensor<32xi32, #SV> bufferization.dealloc_tensor %sparse_input_i32 : tensor<32xi32, #SV>
sparse_tensor.release %sparse_input_f32 : tensor<32xf32, #SV> bufferization.dealloc_tensor %sparse_input_f32 : tensor<32xf32, #SV>
sparse_tensor.release %dense_input_i32 : tensor<32xi32, #DV> bufferization.dealloc_tensor %dense_input_i32 : tensor<32xi32, #DV>
sparse_tensor.release %dense_input_f32 : tensor<32xf32, #DV> bufferization.dealloc_tensor %dense_input_f32 : tensor<32xf32, #DV>
return return
} }
} }

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

Show First 20 Lines • Show All 115 Lines • ▼ Show 20 Lines func.func @entry() {
%b2 = sparse_tensor.values %collapse2 : tensor<12xf64, #SparseVector> to memref<?xf64> %b2 = sparse_tensor.values %collapse2 : tensor<12xf64, #SparseVector> to memref<?xf64>
%v2 = vector.transfer_read %b2[%c0], %df: memref<?xf64>, vector<16xf64> %v2 = vector.transfer_read %b2[%c0], %df: memref<?xf64>, vector<16xf64>
vector.print %v2 : vector<16xf64> vector.print %v2 : vector<16xf64>
%b3 = sparse_tensor.values %collapse3 : tensor<12xf64, #SparseVector> to memref<?xf64> %b3 = sparse_tensor.values %collapse3 : tensor<12xf64, #SparseVector> to memref<?xf64>
%v3 = vector.transfer_read %b3[%c0], %df: memref<?xf64>, vector<16xf64> %v3 = vector.transfer_read %b3[%c0], %df: memref<?xf64>, vector<16xf64>
vector.print %v3 : vector<16xf64> vector.print %v3 : vector<16xf64>
// Release sparse resources. // Release sparse resources.
sparse_tensor.release %sv : tensor<12xf64, #SparseVector> bufferization.dealloc_tensor %sv : tensor<12xf64, #SparseVector>
sparse_tensor.release %sm : tensor<3x4xf64, #SparseMatrix> bufferization.dealloc_tensor %sm : tensor<3x4xf64, #SparseMatrix>
sparse_tensor.release %expand2 : tensor<3x4xf64, #SparseMatrix> bufferization.dealloc_tensor %expand2 : tensor<3x4xf64, #SparseMatrix>
sparse_tensor.release %expand3 : tensor<3x4xf64, #SparseMatrix> bufferization.dealloc_tensor %expand3 : tensor<3x4xf64, #SparseMatrix>
sparse_tensor.release %collapse2 : tensor<12xf64, #SparseVector> bufferization.dealloc_tensor %collapse2 : tensor<12xf64, #SparseVector>
sparse_tensor.release %collapse3 : tensor<12xf64, #SparseVector> bufferization.dealloc_tensor %collapse3 : tensor<12xf64, #SparseVector>
// Release dense resources. // Release dense resources.
// TODO(springerm): Replace these with a bufferization.release op (operating // TODO(springerm): Replace these with a bufferization.release op (operating
// on tensors). // on tensors).
%meme1 = bufferization.to_memref %expand1 : memref<3x4xf64> %meme1 = bufferization.to_memref %expand1 : memref<3x4xf64>
memref.dealloc %meme1 : memref<3x4xf64> memref.dealloc %meme1 : memref<3x4xf64>
%memc1 = bufferization.to_memref %collapse1 : memref<12xf64> %memc1 = bufferization.to_memref %collapse1 : memref<12xf64>
memref.dealloc %memc1 : memref<12xf64> memref.dealloc %memc1 : memref<12xf64>
return return
} }
} }

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

Show First 20 Lines • Show All 113 Lines • ▼ Show 20 Lines scf.for %i = %c0 to %c5 step %c1 {
%v = vector.transfer_read %r[%i, %c0], %d0: memref<?x?xf32>, vector<5xf32> %v = vector.transfer_read %r[%i, %c0], %d0: memref<?x?xf32>, vector<5xf32>
vector.print %v : vector<5xf32> vector.print %v : vector<5xf32>
} }
// Release the resources. // Release the resources.
memref.dealloc %adata : memref<?x?xf32> memref.dealloc %adata : memref<?x?xf32>
memref.dealloc %bdata : memref<?x?xf32> memref.dealloc %bdata : memref<?x?xf32>
memref.dealloc %xdata : memref<?x?xf32> memref.dealloc %xdata : memref<?x?xf32>
sparse_tensor.release %s : tensor<?x?xf32, #SparseMatrix> bufferization.dealloc_tensor %s : tensor<?x?xf32, #SparseMatrix>
return return
} }
} }

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

Show First 20 Lines • Show All 200 Lines • ▼ Show 20 Lines func.func @entry() {
%v2 = vector.transfer_read %m2[%c0], %d0 : memref<?xf64>, vector<4xf64> %v2 = vector.transfer_read %m2[%c0], %d0 : memref<?xf64>, vector<4xf64>
%v3 = vector.transfer_read %m3[%c0], %d0 : memref<?xf64>, vector<4xf64> %v3 = vector.transfer_read %m3[%c0], %d0 : memref<?xf64>, vector<4xf64>
vector.print %v0 : vector<8x8xf64> vector.print %v0 : vector<8x8xf64>
vector.print %v1 : vector<8x8xf64> vector.print %v1 : vector<8x8xf64>
vector.print %v2 : vector<4xf64> vector.print %v2 : vector<4xf64>
vector.print %v3 : vector<4xf64> vector.print %v3 : vector<4xf64>
// Release the resources. // Release the resources.
sparse_tensor.release %s : tensor<8x8xf64, #SM> bufferization.dealloc_tensor %s : tensor<8x8xf64, #SM>
memref.dealloc %m0 : memref<8x8xf64> memref.dealloc %m0 : memref<8x8xf64>
memref.dealloc %m1 : memref<8x8xf64> memref.dealloc %m1 : memref<8x8xf64>
sparse_tensor.release %2 : tensor<8x8xf64, #SM> bufferization.dealloc_tensor %2 : tensor<8x8xf64, #SM>
sparse_tensor.release %3 : tensor<8x8xf64, #SM> bufferization.dealloc_tensor %3 : tensor<8x8xf64, #SM>
return return
} }
} }

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

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines func.func @entry() {
// //
// CHECK: ( 2, 2, 2, 4, 6, 8, 2, 10, 2, 2, 12, 2, 14, 2, 2, 16 ) // CHECK: ( 2, 2, 2, 4, 6, 8, 2, 10, 2, 2, 12, 2, 14, 2, 2, 16 )
// //
%m = sparse_tensor.values %2 : tensor<8x8xf32, #CSR> to memref<?xf32> %m = sparse_tensor.values %2 : tensor<8x8xf32, #CSR> to memref<?xf32>
%v = vector.transfer_read %m[%c0], %f0: memref<?xf32>, vector<16xf32> %v = vector.transfer_read %m[%c0], %f0: memref<?xf32>, vector<16xf32>
vector.print %v : vector<16xf32> vector.print %v : vector<16xf32>
// Release the resources. // Release the resources.
sparse_tensor.release %1 : tensor<8x8xf32, #CSR> bufferization.dealloc_tensor %1 : tensor<8x8xf32, #CSR>
return return
} }
} }

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

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines func.func @entry() {
// //
// CHECK: ( -1, 1, -1, 1, 1, -1, nan, -nan, 1, -1, -0, 0, 99.99 ) // CHECK: ( -1, 1, -1, 1, 1, -1, nan, -nan, 1, -1, -0, 0, 99.99 )
// //
%1 = sparse_tensor.values %0 : tensor<?xf64, #SparseVector> to memref<?xf64> %1 = sparse_tensor.values %0 : tensor<?xf64, #SparseVector> to memref<?xf64>
%2 = vector.transfer_read %1[%c0], %du: memref<?xf64>, vector<13xf64> %2 = vector.transfer_read %1[%c0], %du: memref<?xf64>, vector<13xf64>
vector.print %2 : vector<13xf64> vector.print %2 : vector<13xf64>
// Release the resources. // Release the resources.
sparse_tensor.release %sv1 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xf64, #SparseVector>
sparse_tensor.release %0 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %0 : tensor<?xf64, #SparseVector>
return return
} }
} }

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

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Lines func.func @entry() {
// //
%m = bufferization.to_memref %0 : memref<?x?xf64> %m = bufferization.to_memref %0 : memref<?x?xf64>
%v = vector.transfer_read %m[%c0, %c0], %i0: memref<?x?xf64>, vector<4x4xf64> %v = vector.transfer_read %m[%c0, %c0], %i0: memref<?x?xf64>, vector<4x4xf64>
vector.print %v : vector<4x4xf64> vector.print %v : vector<4x4xf64>
// Release the resources. // Release the resources.
memref.dealloc %bdata : memref<?x?xf64> memref.dealloc %bdata : memref<?x?xf64>
memref.dealloc %xdata : memref<?x?xf64> memref.dealloc %xdata : memref<?x?xf64>
sparse_tensor.release %a : tensor<?x?xf64, #SparseMatrix> bufferization.dealloc_tensor %a : tensor<?x?xf64, #SparseMatrix>
return return
} }
} }

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

Show First 20 Lines • Show All 240 Lines • ▼ Show 20 Lines func.func @entry() {
%47 = sparse_tensor.indices %y, %c0 : tensor<10x8xf64, #BlockCol> to memref<?xindex> %47 = sparse_tensor.indices %y, %c0 : tensor<10x8xf64, #BlockCol> to memref<?xindex>
%48 = vector.transfer_read %47[%c0], %c0: memref<?xindex>, vector<7xindex> %48 = vector.transfer_read %47[%c0], %c0: memref<?xindex>, vector<7xindex>
vector.print %48 : vector<7xindex> vector.print %48 : vector<7xindex>
%49 = sparse_tensor.values %y : tensor<10x8xf64, #BlockCol> to memref<?xf64> %49 = sparse_tensor.values %y : tensor<10x8xf64, #BlockCol> to memref<?xf64>
%50 = vector.transfer_read %49[%c0], %d0: memref<?xf64>, vector<70xf64> %50 = vector.transfer_read %49[%c0], %d0: memref<?xf64>, vector<70xf64>
vector.print %50 : vector<70xf64> vector.print %50 : vector<70xf64>
// Release the resources. // Release the resources.
sparse_tensor.release %0 : tensor<10x8xf64, #Dense> bufferization.dealloc_tensor %0 : tensor<10x8xf64, #Dense>
sparse_tensor.release %1 : tensor<10x8xf64, #CSR> bufferization.dealloc_tensor %1 : tensor<10x8xf64, #CSR>
sparse_tensor.release %2 : tensor<10x8xf64, #DCSR> bufferization.dealloc_tensor %2 : tensor<10x8xf64, #DCSR>
sparse_tensor.release %3 : tensor<10x8xf64, #CSC> bufferization.dealloc_tensor %3 : tensor<10x8xf64, #CSC>
sparse_tensor.release %4 : tensor<10x8xf64, #DCSC> bufferization.dealloc_tensor %4 : tensor<10x8xf64, #DCSC>
sparse_tensor.release %x : tensor<10x8xf64, #BlockRow> bufferization.dealloc_tensor %x : tensor<10x8xf64, #BlockRow>
sparse_tensor.release %y : tensor<10x8xf64, #BlockCol> bufferization.dealloc_tensor %y : tensor<10x8xf64, #BlockCol>
return return
} }
} }

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

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines func.func @entry() {
// Print the result for verification. // Print the result for verification.
// //
// CHECK: 30.2 // CHECK: 30.2
// //
%v = tensor.extract %0[] : tensor<f64> %v = tensor.extract %0[] : tensor<f64>
vector.print %v : f64 vector.print %v : f64
// Release the resources. // Release the resources.
sparse_tensor.release %a : tensor<?x?xf64, #SparseMatrix> bufferization.dealloc_tensor %a : tensor<?x?xf64, #SparseMatrix>
return return
} }
} }

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

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines func.func @entry() {
// //
%m = bufferization.to_memref %0 : memref<bf16> %m = bufferization.to_memref %0 : memref<bf16>
%v = memref.load %m[] : memref<bf16> %v = memref.load %m[] : memref<bf16>
%vf = arith.extf %v: bf16 to f32 %vf = arith.extf %v: bf16 to f32
vector.print %vf : f32 vector.print %vf : f32
// Release the resources. // Release the resources.
memref.dealloc %xdata : memref<bf16> memref.dealloc %xdata : memref<bf16>
sparse_tensor.release %a : tensor<?x?xbf16, #SparseMatrix> bufferization.dealloc_tensor %a : tensor<?x?xbf16, #SparseMatrix>
return return
} }
} }

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

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines func.func @entry() {
// //
%v = tensor.extract %0[] : tensor<complex<f64>> %v = tensor.extract %0[] : tensor<complex<f64>>
%real = complex.re %v : complex<f64> %real = complex.re %v : complex<f64>
%imag = complex.im %v : complex<f64> %imag = complex.im %v : complex<f64>
vector.print %real : f64 vector.print %real : f64
vector.print %imag : f64 vector.print %imag : f64
// Release the resources. // Release the resources.
sparse_tensor.release %a : tensor<?x?xcomplex<f64>, #SparseMatrix> bufferization.dealloc_tensor %a : tensor<?x?xcomplex<f64>, #SparseMatrix>
return return
} }
} }

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

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines func.func @entry() {
// //
%m = bufferization.to_memref %0 : memref<f16> %m = bufferization.to_memref %0 : memref<f16>
%v = memref.load %m[] : memref<f16> %v = memref.load %m[] : memref<f16>
%vf = arith.extf %v: f16 to f32 %vf = arith.extf %v: f16 to f32
vector.print %vf : f32 vector.print %vf : f32
// Release the resources. // Release the resources.
memref.dealloc %xdata : memref<f16> memref.dealloc %xdata : memref<f16>
sparse_tensor.release %a : tensor<?x?xf16, #SparseMatrix> bufferization.dealloc_tensor %a : tensor<?x?xf16, #SparseMatrix>
return return
} }
} }

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

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines func.func @entry() {
// Verify the results (within some precision). // Verify the results (within some precision).
// //
// CHECK: {{( -0.761[0-9]*, 0.761[0-9]*, 0.96[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 )}} // CHECK: {{( -0.761[0-9]*, 0.761[0-9]*, 0.96[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 )}}
// CHECK-NEXT {{( -0.761[0-9]*, 0, 0, 0.761[0-9]*, 0, 0, 0, 0, 0, 0, 0, 0.96[0-9]*, 0, 0, 0, 0, 0, 0.99[0-9]*, 0, 0, 0.99[0-9]*, 0.99[0-9]*, 0, 0, 0, 0, 0, 0, 0.99[0-9]*, 0.99[0-9]*, 0, 1 )}} // CHECK-NEXT {{( -0.761[0-9]*, 0, 0, 0.761[0-9]*, 0, 0, 0, 0, 0, 0, 0, 0.96[0-9]*, 0, 0, 0, 0, 0, 0.99[0-9]*, 0, 0, 0.99[0-9]*, 0.99[0-9]*, 0, 0, 0, 0, 0, 0, 0.99[0-9]*, 0.99[0-9]*, 0, 1 )}}
// //
call @dump_vec_f64(%0) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec_f64(%0) : (tensor<?xf64, #SparseVector>) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %sv1 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xf64, #SparseVector>
return return
} }
} }

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

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines func.func @entry() {
vector.print %v1 : vector<8xf64> vector.print %v1 : vector<8xf64>
// Print %0 in dense form. // Print %0 in dense form.
%dt = sparse_tensor.convert %0 : tensor<?x?x?xf64, #ST> to tensor<?x?x?xf64> %dt = sparse_tensor.convert %0 : tensor<?x?x?xf64, #ST> to tensor<?x?x?xf64>
%v2 = vector.transfer_read %dt[%c0, %c0, %c0], %default_val: tensor<?x?x?xf64>, vector<3x3x5xf64> %v2 = vector.transfer_read %dt[%c0, %c0, %c0], %default_val: tensor<?x?x?xf64>, vector<3x3x5xf64>
vector.print %v2 : vector<3x3x5xf64> vector.print %v2 : vector<3x3x5xf64>
// Release the resources. // Release the resources.
sparse_tensor.release %sta : tensor<?x?x?xf64, #ST> bufferization.dealloc_tensor %sta : tensor<?x?x?xf64, #ST>
sparse_tensor.release %stb : tensor<?x?x?xf64, #ST> bufferization.dealloc_tensor %stb : tensor<?x?x?xf64, #ST>
sparse_tensor.release %0 : tensor<?x?x?xf64, #ST> bufferization.dealloc_tensor %0 : tensor<?x?x?xf64, #ST>
return return
} }
} }

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

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines func.func @entry() {
%m1 = sparse_tensor.values %st : tensor<?x?x?xf64, #ST1> to memref<?xf64> %m1 = sparse_tensor.values %st : tensor<?x?x?xf64, #ST1> to memref<?xf64>
%m2 = sparse_tensor.values %0 : tensor<?x?x?xf64, #ST2> to memref<?xf64> %m2 = sparse_tensor.values %0 : tensor<?x?x?xf64, #ST2> to memref<?xf64>
%v1 = vector.transfer_read %m1[%c0], %d1: memref<?xf64>, vector<8xf64> %v1 = vector.transfer_read %m1[%c0], %d1: memref<?xf64>, vector<8xf64>
%v2 = vector.transfer_read %m2[%c0], %d1: memref<?xf64>, vector<32xf64> %v2 = vector.transfer_read %m2[%c0], %d1: memref<?xf64>, vector<32xf64>
vector.print %v1 : vector<8xf64> vector.print %v1 : vector<8xf64>
vector.print %v2 : vector<32xf64> vector.print %v2 : vector<32xf64>
// Release the resources. // Release the resources.
sparse_tensor.release %st : tensor<?x?x?xf64, #ST1> bufferization.dealloc_tensor %st : tensor<?x?x?xf64, #ST1>
sparse_tensor.release %0 : tensor<?x?x?xf64, #ST2> bufferization.dealloc_tensor %0 : tensor<?x?x?xf64, #ST2>
return return
} }
} }

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

Show All 36 Lines func.func @sparse_transpose(%arga: tensor<3x4xf64, #DCSR>)
%i = bufferization.alloc_tensor() : tensor<4x3xf64, #DCSR> %i = bufferization.alloc_tensor() : tensor<4x3xf64, #DCSR>
%0 = linalg.generic #transpose_trait %0 = linalg.generic #transpose_trait
ins(%t: tensor<3x4xf64, #DCSC>) ins(%t: tensor<3x4xf64, #DCSC>)
outs(%i: tensor<4x3xf64, #DCSR>) { outs(%i: tensor<4x3xf64, #DCSR>) {
^bb(%a: f64, %x: f64): ^bb(%a: f64, %x: f64):
linalg.yield %a : f64 linalg.yield %a : f64
} -> tensor<4x3xf64, #DCSR> } -> tensor<4x3xf64, #DCSR>
sparse_tensor.release %t : tensor<3x4xf64, #DCSC> bufferization.dealloc_tensor %t : tensor<3x4xf64, #DCSC>
return %0 : tensor<4x3xf64, #DCSR> return %0 : tensor<4x3xf64, #DCSR>
} }
// //
// However, even better, the sparse compiler is able to insert such a // However, even better, the sparse compiler is able to insert such a
// conversion automatically to resolve a cycle in the iteration graph! // conversion automatically to resolve a cycle in the iteration graph!
// //
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines func.func @entry() {
} }
%y = sparse_tensor.convert %1 : tensor<4x3xf64, #DCSR> to tensor<4x3xf64> %y = sparse_tensor.convert %1 : tensor<4x3xf64, #DCSR> to tensor<4x3xf64>
scf.for %i = %c0 to %c4 step %c1 { scf.for %i = %c0 to %c4 step %c1 {
%v2 = vector.transfer_read %y[%i, %c0], %du: tensor<4x3xf64>, vector<3xf64> %v2 = vector.transfer_read %y[%i, %c0], %du: tensor<4x3xf64>, vector<3xf64>
vector.print %v2 : vector<3xf64> vector.print %v2 : vector<3xf64>
} }
// Release resources. // Release resources.
sparse_tensor.release %a : tensor<3x4xf64, #DCSR> bufferization.dealloc_tensor %a : tensor<3x4xf64, #DCSR>
sparse_tensor.release %0 : tensor<4x3xf64, #DCSR> bufferization.dealloc_tensor %0 : tensor<4x3xf64, #DCSR>
sparse_tensor.release %1 : tensor<4x3xf64, #DCSR> bufferization.dealloc_tensor %1 : tensor<4x3xf64, #DCSR>
return return
} }
} }

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

Show First 20 Lines • Show All 249 Lines • ▼ Show 20 Lines func.func @entry() {
call @dump_vec_f64(%sv1) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec_f64(%sv1) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_vec_i32(%0) : (tensor<?xi32, #SparseVector>) -> () call @dump_vec_i32(%0) : (tensor<?xi32, #SparseVector>) -> ()
call @dump_vec_f64(%1) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec_f64(%1) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_vec_f64(%2) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec_f64(%2) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_mat(%3) : (tensor<?x?xf64, #DCSR>) -> () call @dump_mat(%3) : (tensor<?x?xf64, #DCSR>) -> ()
call @dump_mat(%4) : (tensor<?x?xf64, #DCSR>) -> () call @dump_mat(%4) : (tensor<?x?xf64, #DCSR>) -> ()
// Release the resources. // Release the resources.
sparse_tensor.release %sv1 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xf64, #SparseVector>
sparse_tensor.release %sm1 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %sm1 : tensor<?x?xf64, #DCSR>
sparse_tensor.release %0 : tensor<?xi32, #SparseVector> bufferization.dealloc_tensor %0 : tensor<?xi32, #SparseVector>
sparse_tensor.release %1 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %1 : tensor<?xf64, #SparseVector>
sparse_tensor.release %2 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %2 : tensor<?xf64, #SparseVector>
sparse_tensor.release %3 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %3 : tensor<?x?xf64, #DCSR>
sparse_tensor.release %4 : tensor<?x?xf64, #DCSR> bufferization.dealloc_tensor %4 : tensor<?x?xf64, #DCSR>
return return
} }
} }

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

Show First 20 Lines • Show All 218 Lines • ▼ Show 20 Lines func.func @entry() {
%m4 = sparse_tensor.values %4 : tensor<?xf64, #DenseVector> to memref<?xf64> %m4 = sparse_tensor.values %4 : tensor<?xf64, #DenseVector> to memref<?xf64>
%v4 = vector.load %m4[%c0]: memref<?xf64>, vector<32xf64> %v4 = vector.load %m4[%c0]: memref<?xf64>, vector<32xf64>
vector.print %v4 : vector<32xf64> vector.print %v4 : vector<32xf64>
%m5 = bufferization.to_memref %5 : memref<f64> %m5 = bufferization.to_memref %5 : memref<f64>
%v5 = memref.load %m5[] : memref<f64> %v5 = memref.load %m5[] : memref<f64>
vector.print %v5 : f64 vector.print %v5 : f64
// Release the resources. // Release the resources.
sparse_tensor.release %sv1 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xf64, #SparseVector>
sparse_tensor.release %sv1_dup : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %sv1_dup : tensor<?xf64, #SparseVector>
sparse_tensor.release %sv2 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %sv2 : tensor<?xf64, #SparseVector>
sparse_tensor.release %0 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %0 : tensor<?xf64, #SparseVector>
sparse_tensor.release %2 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %2 : tensor<?xf64, #SparseVector>
sparse_tensor.release %3 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %3 : tensor<?xf64, #SparseVector>
sparse_tensor.release %4 : tensor<?xf64, #DenseVector> bufferization.dealloc_tensor %4 : tensor<?xf64, #DenseVector>
return return
} }
} }

mlir/test/Integration/Dialect/SparseTensor/python/test_stress.py

# RUN: SUPPORT_LIB=%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \ # RUN: SUPPORT_LIB=%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
# RUN: %PYTHON %s | FileCheck %s # RUN: %PYTHON %s | FileCheck %s
import ctypes import ctypes
import errno import errno
import itertools import itertools
import os import os
import sys import sys
from typing import List, Callable from typing import List, Callable
import numpy as np import numpy as np
from mlir import ir from mlir import ir
from mlir import runtime as rt from mlir import runtime as rt
from mlir.dialects import bufferization
from mlir.dialects import builtin from mlir.dialects import builtin
from mlir.dialects import func from mlir.dialects import func
from mlir.dialects import sparse_tensor as st from mlir.dialects import sparse_tensor as st
_SCRIPT_PATH = os.path.dirname(os.path.abspath(__file__)) _SCRIPT_PATH = os.path.dirname(os.path.abspath(__file__))
sys.path.append(_SCRIPT_PATH) sys.path.append(_SCRIPT_PATH)
from tools import sparse_compiler from tools import sparse_compiler
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Lines with ir.InsertionPoint(self._module.body):
funcOp.attributes['llvm.emit_c_interface'] = ir.UnitAttr.get() funcOp.attributes['llvm.emit_c_interface'] = ir.UnitAttr.get()
with ir.InsertionPoint(funcOp.add_entry_block()): with ir.InsertionPoint(funcOp.add_entry_block()):
arg0 = funcOp.entry_block.arguments[0] arg0 = funcOp.entry_block.arguments[0]
self._assertEqualsRoundtripTp(arg0.type) self._assertEqualsRoundtripTp(arg0.type)
v = st.ConvertOp(types.pop(0), arg0) v = st.ConvertOp(types.pop(0), arg0)
for tp in types: for tp in types:
w = st.ConvertOp(tp, v) w = st.ConvertOp(tp, v)
# Release intermediate tensors before they fall out of scope. # Release intermediate tensors before they fall out of scope.
st.ReleaseOp(v.result) bufferization.DeallocTensorOp(v.result)
v = w v = w
self._assertEqualsRoundtripTp(v.result.type) self._assertEqualsRoundtripTp(v.result.type)
func.ReturnOp(v) func.ReturnOp(v)
return self return self
def writeTo(self, filename): def writeTo(self, filename):
"""Write the ir.Module to the given file. If the file already exists, """Write the ir.Module to the given file. If the file already exists,
then raises an error. If the filename is None, then is a no-op.""" then raises an error. If the filename is None, then is a no-op."""
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines