This is an archive of the discontinued LLVM Phabricator instance.

Differential D150330

[mlir][sparse] Renaming the STEA field `dimLevelType` to `lvlTypes`
ClosedPublic

Authored by wrengr on May 10 2023, 4:43 PM.

Details

Reviewers
aartbik
bixia
Peiming
nicolasvasilache
herhut
ftynse
springerm
Commits
rGa0615d020a02: [mlir][sparse] Renaming the STEA field `dimLevelType` to `lvlTypes`
Summary

This commit is part of the migration of towards the new STEA syntax/design. In particular, this commit includes the following changes:

  • Renaming compiler-internal functions/methods:
    • SparseTensorEncodingAttr::{getDimLevelType => getLvlTypes}
    • Merger::{getDimLevelType => getLvlType} (for consistency)
    • sparse_tensor::{getDimLevelType => buildLevelType} (to help reduce confusion vs actual getter methods)
  • Renaming external facets to match:
    • the STEA parser and printer
    • the C and Python bindings
    • PyTACO

However, the actual renaming of the DimLevelType itself (along with all the "dlt" names) will be handled in a separate commit.

Diff Detail

Event Timeline

wrengr created this revision.May 10 2023, 4:43 PM
Herald added a project: Restricted Project. · View Herald TranscriptMay 10 2023, 4:43 PM
Herald added subscribers: bviyer, hanchung, jsetoain and 20 others. · View Herald Transcript
wrengr requested review of this revision.May 10 2023, 4:43 PM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptMay 10 2023, 4:43 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
wrengr updated this revision to Diff 521159.May 10 2023, 4:46 PM

git-clang-format

aartbik accepted this revision.May 10 2023, 4:53 PM
This revision is now accepted and ready to land.May 10 2023, 4:53 PM
Harbormaster completed remote builds in B231219: Diff 521159.May 10 2023, 5:55 PM
wrengr edited the summary of this revision. (Show Details)May 11 2023, 3:48 PM
wrengr updated this revision to Diff 521483.May 11 2023, 3:48 PM
wrengr edited the summary of this revision. (Show Details)

Updating the parser, printer, CAPI, and Python bindings

Herald added a reviewer: herhut. · View Herald TranscriptMay 11 2023, 3:48 PM
Herald added a reviewer: ftynse. · View Herald Transcript
Herald added a reviewer: springerm. · View Herald Transcript
Herald added subscribers: • pcwang-thead, awarzynski, mravishankar and 3 others. · View Herald Transcript
wrengr updated this revision to Diff 521484.May 11 2023, 3:49 PM

git-clang-format

wrengr edited the summary of this revision. (Show Details)May 11 2023, 3:50 PM
Harbormaster completed remote builds in B231471: Diff 521484.May 11 2023, 4:41 PM
wrengr added a child revision: D150409: [mlir][sparse] Adjusting error message wording, to better match new field names.May 11 2023, 5:17 PM
aartbik added a comment.May 12 2023, 12:33 PM

Still LGTM although
(1) please update the summary to reflect the wider scope of this change
(2) I think you need a follow up in e.g. SparseTensorOps.td to update the exampes

wrengr updated this revision to Diff 523146.May 17 2023, 1:11 PM

rebase

Harbormaster completed remote builds in B232679: Diff 523146.May 17 2023, 1:43 PM
This revision was landed with ongoing or failed builds.May 17 2023, 2:24 PM
Closed by commit rGa0615d020a02: [mlir][sparse] Renaming the STEA field `dimLevelType` to `lvlTypes` (authored by wrengr). · Explain Why
This revision was automatically updated to reflect the committed changes.
wrengr added a commit: rGa0615d020a02: [mlir][sparse] Renaming the STEA field `dimLevelType` to `lvlTypes`.
wrengr added a comment.May 17 2023, 2:36 PM

Note: D150409 detected a failure to rename things in "test/Dialect/SparseTensor/GPU/gpu_matvec_lib.mlir" since the rebasing. However, since this differential already landed, I've made the change in D150409

wrengr added a comment.May 17 2023, 2:49 PM

Actually it looks like a bunch of GPU tests weren't caught when rebasing. I'm working on a patch to fix those now.

wrengr mentioned this in D150822: [mlir][sparse] Fixing GPU tests (followup to D150330).May 17 2023, 2:59 PM
wrengr added a comment.May 17 2023, 3:02 PM

D150822 should fix all the failing GPU tests

wrengr mentioned this in rG7f5fb90bbb3f: [mlir][sparse] Fixing GPU tests (followup to D150330).May 17 2023, 3:30 PM
wrengr added a comment.May 17 2023, 4:58 PM

And D150830 should fix what D150822 missed

wrengr mentioned this in D150739: [mlir][sparse] Make sparse_tensor::StorageLayout publicly available..May 17 2023, 6:31 PM
wrengr mentioned this in D150920: [mlir][sparse] Updating STEA documentation examples to use "lvlTypes".May 18 2023, 5:27 PM
wrengr mentioned this in rG81d28921da8e: [mlir][sparse] Updating STEA documentation examples to use "lvlTypes".May 19 2023, 1:01 PM

Revision Contents

PathSize
mlir/
include/
mlir-c/
Dialect/
4 lines
mlir/
Dialect/
SparseTensor/
IR/
28 lines
6 lines
Utils/
8 lines
lib/
Bindings/
Python/
12 lines
CAPI/
Dialect/
17 lines
Dialect/
SparseTensor/
IR/
48 lines
Transforms/
6 lines
2 lines
2 lines
10 lines
3 lines
2 lines
11 lines
Utils/
6 lines
test/
CAPI/
16 lines
Dialect/
Bufferization/
4 lines
2 lines
Linalg/
2 lines
SparseTensor/
GPU/
2 lines
2 lines
2 lines
32 lines
2 lines
4 lines
4 lines
2 lines
2 lines
12 lines
12 lines
10 lines
18 lines
4 lines
2 lines
2 lines
90 lines
16 lines
4 lines
10 lines
4 lines
6 lines
4 lines
20 lines
72 lines
48 lines
2 lines
44 lines
222 lines
216 lines
190 lines
8 lines
4 lines
6 lines
12 lines
2 lines
8 lines
6 lines
2 lines
6 lines
34 lines
4 lines
2 lines
110 lines
2 lines
10 lines
2 lines
2 lines
14 lines
202 lines
2 lines
2 lines
6 lines
4 lines
2 lines
2 lines
12 lines
6 lines
2 lines
32 lines
30 lines
4 lines
34 lines
10 lines
18 lines
6 lines
18 lines
2 lines
2 lines
2 lines
2 lines
162 lines
Integration/
Dialect/
SparseTensor/
CPU/
14 lines
14 lines
14 lines
14 lines
4 lines
4 lines
4 lines
4 lines
2 lines
4 lines
2 lines
2 lines
12 lines
8 lines
2 lines
2 lines
2 lines
2 lines
4 lines
8 lines
4 lines
6 lines
4 lines
6 lines
4 lines
6 lines
6 lines
12 lines
12 lines
6 lines
2 lines
2 lines
8 lines
2 lines
2 lines
12 lines
4 lines
4 lines
2 lines
10 lines
8 lines
4 lines
22 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
6 lines
2 lines
2 lines
6 lines
6 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
8 lines
2 lines
14 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
4 lines
4 lines
GPU/
CUDA/
2 lines
2 lines
python/
2 lines
taco/
tools/
4 lines
python/
dialects/
sparse_tensor/
30 lines

Diff 523174

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

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
/// Checks whether the given attribute is a `sparse_tensor.encoding` attribute. /// Checks whether the given attribute is a `sparse_tensor.encoding` attribute.
MLIR_CAPI_EXPORTED bool MLIR_CAPI_EXPORTED bool
mlirAttributeIsASparseTensorEncodingAttr(MlirAttribute attr); mlirAttributeIsASparseTensorEncodingAttr(MlirAttribute attr);
/// Creates a `sparse_tensor.encoding` attribute with the given parameters. /// Creates a `sparse_tensor.encoding` attribute with the given parameters.
MLIR_CAPI_EXPORTED MlirAttribute mlirSparseTensorEncodingAttrGet( MLIR_CAPI_EXPORTED MlirAttribute mlirSparseTensorEncodingAttrGet(
MlirContext ctx, intptr_t lvlRank, MlirContext ctx, intptr_t lvlRank,
enum MlirSparseTensorDimLevelType const *dimLevelTypes, enum MlirSparseTensorDimLevelType const *lvlTypes,
MlirAffineMap dimOrdering, MlirAffineMap higherOrdering, int posWidth, MlirAffineMap dimOrdering, MlirAffineMap higherOrdering, int posWidth,
int crdWidth); int crdWidth);
/// Returns the level-rank of the `sparse_tensor.encoding` attribute. /// Returns the level-rank of the `sparse_tensor.encoding` attribute.
MLIR_CAPI_EXPORTED intptr_t MLIR_CAPI_EXPORTED intptr_t
mlirSparseTensorEncodingGetLvlRank(MlirAttribute attr); mlirSparseTensorEncodingGetLvlRank(MlirAttribute attr);
/// Returns a specified level-type of the `sparse_tensor.encoding` attribute. /// Returns a specified level-type of the `sparse_tensor.encoding` attribute.
MLIR_CAPI_EXPORTED enum MlirSparseTensorDimLevelType MLIR_CAPI_EXPORTED enum MlirSparseTensorDimLevelType
mlirSparseTensorEncodingAttrGetDimLevelType(MlirAttribute attr, intptr_t lvl); mlirSparseTensorEncodingAttrGetLvlType(MlirAttribute attr, intptr_t lvl);
/// Returns the dimension-ordering of the `sparse_tensor.encoding` attribute. /// Returns the dimension-ordering of the `sparse_tensor.encoding` attribute.
MLIR_CAPI_EXPORTED MlirAffineMap MLIR_CAPI_EXPORTED MlirAffineMap
mlirSparseTensorEncodingAttrGetDimOrdering(MlirAttribute attr); mlirSparseTensorEncodingAttrGetDimOrdering(MlirAttribute attr);
/// Returns the higher-ordering of the `sparse_tensor.encoding` attribute. /// Returns the higher-ordering of the `sparse_tensor.encoding` attribute.
MLIR_CAPI_EXPORTED MlirAffineMap MLIR_CAPI_EXPORTED MlirAffineMap
mlirSparseTensorEncodingAttrGetHigherOrdering(MlirAttribute attr); mlirSparseTensorEncodingAttrGetHigherOrdering(MlirAttribute attr);
Show All 16 Lines

mlir/include/mlir/Dialect/SparseTensor/IR/Enums.h

Show First 20 Lines • Show All 294 Lines • ▼ Show 20 Lines
} }
/// Convert a LevelFormat to its corresponding DimLevelType with the given /// Convert a LevelFormat to its corresponding DimLevelType with the given
/// properties. Returns std::nullopt when the properties are not applicable for /// properties. Returns std::nullopt when the properties are not applicable for
/// the input level format. /// the input level format.
/// TODO: factor out a new LevelProperties type so we can add new properties /// TODO: factor out a new LevelProperties type so we can add new properties
/// without changing this function's signature /// without changing this function's signature
constexpr std::optional<DimLevelType> constexpr std::optional<DimLevelType>
getDimLevelType(LevelFormat lf, bool ordered, bool unique) { buildLevelType(LevelFormat lf, bool ordered, bool unique) {
auto dlt = static_cast<DimLevelType>(static_cast<uint8_t>(lf) | auto dlt = static_cast<DimLevelType>(static_cast<uint8_t>(lf) |
(ordered ? 0 : 2) | (unique ? 0 : 1)); (ordered ? 0 : 2) | (unique ? 0 : 1));
return isValidDLT(dlt) ? std::optional(dlt) : std::nullopt; return isValidDLT(dlt) ? std::optional(dlt) : std::nullopt;
} }
/// Ensure the above conversion works as intended. /// Ensure the above conversion works as intended.
static_assert( static_assert(
(getLevelFormat(DimLevelType::Undef) == std::nullopt && (getLevelFormat(DimLevelType::Undef) == std::nullopt &&
*getLevelFormat(DimLevelType::Dense) == LevelFormat::Dense && *getLevelFormat(DimLevelType::Dense) == LevelFormat::Dense &&
*getLevelFormat(DimLevelType::Compressed) == LevelFormat::Compressed && *getLevelFormat(DimLevelType::Compressed) == LevelFormat::Compressed &&
*getLevelFormat(DimLevelType::CompressedNu) == LevelFormat::Compressed && *getLevelFormat(DimLevelType::CompressedNu) == LevelFormat::Compressed &&
*getLevelFormat(DimLevelType::CompressedNo) == LevelFormat::Compressed && *getLevelFormat(DimLevelType::CompressedNo) == LevelFormat::Compressed &&
*getLevelFormat(DimLevelType::CompressedNuNo) == LevelFormat::Compressed && *getLevelFormat(DimLevelType::CompressedNuNo) == LevelFormat::Compressed &&
*getLevelFormat(DimLevelType::Singleton) == LevelFormat::Singleton && *getLevelFormat(DimLevelType::Singleton) == LevelFormat::Singleton &&
*getLevelFormat(DimLevelType::SingletonNu) == LevelFormat::Singleton && *getLevelFormat(DimLevelType::SingletonNu) == LevelFormat::Singleton &&
*getLevelFormat(DimLevelType::SingletonNo) == LevelFormat::Singleton && *getLevelFormat(DimLevelType::SingletonNo) == LevelFormat::Singleton &&
*getLevelFormat(DimLevelType::SingletonNuNo) == LevelFormat::Singleton), *getLevelFormat(DimLevelType::SingletonNuNo) == LevelFormat::Singleton),
"getLevelFormat conversion is broken"); "getLevelFormat conversion is broken");
static_assert( static_assert(
(getDimLevelType(LevelFormat::Dense, false, true) == std::nullopt && (buildLevelType(LevelFormat::Dense, false, true) == std::nullopt &&
getDimLevelType(LevelFormat::Dense, true, false) == std::nullopt && buildLevelType(LevelFormat::Dense, true, false) == std::nullopt &&
getDimLevelType(LevelFormat::Dense, false, false) == std::nullopt && buildLevelType(LevelFormat::Dense, false, false) == std::nullopt &&
*getDimLevelType(LevelFormat::Dense, true, true) == DimLevelType::Dense && *buildLevelType(LevelFormat::Dense, true, true) == DimLevelType::Dense &&
*getDimLevelType(LevelFormat::Compressed, true, true) == *buildLevelType(LevelFormat::Compressed, true, true) ==
DimLevelType::Compressed && DimLevelType::Compressed &&
*getDimLevelType(LevelFormat::Compressed, true, false) == *buildLevelType(LevelFormat::Compressed, true, false) ==
DimLevelType::CompressedNu && DimLevelType::CompressedNu &&
*getDimLevelType(LevelFormat::Compressed, false, true) == *buildLevelType(LevelFormat::Compressed, false, true) ==
DimLevelType::CompressedNo && DimLevelType::CompressedNo &&
*getDimLevelType(LevelFormat::Compressed, false, false) == *buildLevelType(LevelFormat::Compressed, false, false) ==
DimLevelType::CompressedNuNo && DimLevelType::CompressedNuNo &&
*getDimLevelType(LevelFormat::Singleton, true, true) == *buildLevelType(LevelFormat::Singleton, true, true) ==
DimLevelType::Singleton && DimLevelType::Singleton &&
*getDimLevelType(LevelFormat::Singleton, true, false) == *buildLevelType(LevelFormat::Singleton, true, false) ==
DimLevelType::SingletonNu && DimLevelType::SingletonNu &&
*getDimLevelType(LevelFormat::Singleton, false, true) == *buildLevelType(LevelFormat::Singleton, false, true) ==
DimLevelType::SingletonNo && DimLevelType::SingletonNo &&
*getDimLevelType(LevelFormat::Singleton, false, false) == *buildLevelType(LevelFormat::Singleton, false, false) ==
DimLevelType::SingletonNuNo), DimLevelType::SingletonNuNo),
"getDimLevelType conversion is broken"); "buildLevelType conversion is broken");
// Ensure the above predicates work as intended. // Ensure the above predicates work as intended.
static_assert((isValidDLT(DimLevelType::Undef) && static_assert((isValidDLT(DimLevelType::Undef) &&
isValidDLT(DimLevelType::Dense) && isValidDLT(DimLevelType::Dense) &&
isValidDLT(DimLevelType::Compressed) && isValidDLT(DimLevelType::Compressed) &&
isValidDLT(DimLevelType::CompressedNu) && isValidDLT(DimLevelType::CompressedNu) &&
isValidDLT(DimLevelType::CompressedNo) && isValidDLT(DimLevelType::CompressedNo) &&
isValidDLT(DimLevelType::CompressedNuNo) && isValidDLT(DimLevelType::CompressedNuNo) &&
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 260 Lines • ▼ Show 20 Linesdef SparseTensorEncodingAttr : SparseTensor_Attr<"SparseTensorEncoding",
// Data in sparse tensor encoding. // Data in sparse tensor encoding.
let parameters = ( let parameters = (
ins ins
// A level-type for each level of the sparse storage. // A level-type for each level of the sparse storage.
ArrayRefParameter< ArrayRefParameter<
"::mlir::sparse_tensor::DimLevelType", "::mlir::sparse_tensor::DimLevelType",
"level-types" "level-types"
>: $dimLevelType, >: $lvlTypes,
// A permutation from (higher-ordering)-coordinates to level-coordinates. // A permutation from (higher-ordering)-coordinates to level-coordinates.
"AffineMap":$dimOrdering, "AffineMap":$dimOrdering,
// A mapping from dimension-coordinates to (higher-ordering)-coordinates. // A mapping from dimension-coordinates to (higher-ordering)-coordinates.
"AffineMap":$higherOrdering, "AffineMap":$higherOrdering,
// The required bitwidth for position storage. // The required bitwidth for position storage.
"unsigned":$posWidth, "unsigned":$posWidth,
// The required bitwidth for coordinate storage. // The required bitwidth for coordinate storage.
"unsigned":$crdWidth, "unsigned":$crdWidth,
// A slice attribute for each dimension of the tensor type. // A slice attribute for each dimension of the tensor type.
ArrayRefParameter< ArrayRefParameter<
"::mlir::sparse_tensor::SparseTensorDimSliceAttr", "::mlir::sparse_tensor::SparseTensorDimSliceAttr",
"per dimension slice metadata" "per dimension slice metadata"
>: $dimSlices >: $dimSlices
); );
let builders = [ let builders = [
AttrBuilder<(ins "ArrayRef<::mlir::sparse_tensor::DimLevelType>":$dimLevelType, AttrBuilder<(ins "ArrayRef<::mlir::sparse_tensor::DimLevelType>":$lvlTypes,
"AffineMap":$dimOrdering, "AffineMap":$dimOrdering,
"AffineMap":$higherOrdering, "AffineMap":$higherOrdering,
"unsigned":$posWidth, "unsigned":$posWidth,
"unsigned":$crdWidth), [{ "unsigned":$crdWidth), [{
return $_get($_ctxt, dimLevelType, return $_get($_ctxt, lvlTypes,
dimOrdering, dimOrdering,
higherOrdering, higherOrdering,
posWidth, posWidth,
crdWidth, crdWidth,
ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr>{}); ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr>{});
}]> }]>
]; ];
▲ Show 20 Lines • Show All 150 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/SparseTensor/Utils/Merger.h

Show First 20 Lines • Show All 371 Lines • ▼ Show 20 Linespublic:
/// to sparse level-type. /// to sparse level-type.
bool hasAnySparse(const BitVector &bits) const; bool hasAnySparse(const BitVector &bits) const;
/// Returns true if bits contains a dependent index reduction condition on /// Returns true if bits contains a dependent index reduction condition on
/// sparse levels. /// sparse levels.
bool hasSparseIdxReduction(const BitVector &bits) const; bool hasSparseIdxReduction(const BitVector &bits) const;
/// Gets the level-type of the `t`th tensor on `i`th loop. /// Gets the level-type of the `t`th tensor on `i`th loop.
DimLevelType getDimLevelType(TensorId t, LoopId i) const { DimLevelType getLvlType(TensorId t, LoopId i) const {
assert(isValidTensorId(t) && isValidLoopId(i)); assert(isValidTensorId(t) && isValidLoopId(i));
return lvlTypes[t][i]; return lvlTypes[t][i];
} }
/// Gets the level-type of the TensorLoopId. /// Gets the level-type of the TensorLoopId.
DimLevelType getDimLevelType(TensorLoopId b) const { DimLevelType getLvlType(TensorLoopId b) const {
return getDimLevelType(tensor(b), loop(b)); return getLvlType(tensor(b), loop(b));
} }
/// Gets the loop identifier for the `lvl`th level of the `t`th tensor. /// Gets the loop identifier for the `lvl`th level of the `t`th tensor.
std::optional<LoopId> getLoopId(TensorId t, Level lvl) const { std::optional<LoopId> getLoopId(TensorId t, Level lvl) const {
assert(isValidLevel(t, lvl)); assert(isValidLevel(t, lvl));
return lvlToLoop[t][lvl]; return lvlToLoop[t][lvl];
} }
Show All 33 Linespublic:
} }
void foreachTensorLoopId(LatPointId p, bool simple, void foreachTensorLoopId(LatPointId p, bool simple,
ForeachTensorLoopIdCallback callback) const { ForeachTensorLoopIdCallback callback) const {
const auto &point = lat(p); const auto &point = lat(p);
const auto &bits = simple ? point.simple : point.bits; const auto &bits = simple ? point.simple : point.bits;
for (const TensorLoopId b : bits.set_bits()) { for (const TensorLoopId b : bits.set_bits()) {
const TensorId t = tensor(b); const TensorId t = tensor(b);
const auto optLvl = getLvl(b); const auto optLvl = getLvl(b);
const auto lvlTp = getDimLevelType(b); const auto lvlTp = getLvlType(b);
if (isLvlWithNonTrivialIdxExp(b)) { if (isLvlWithNonTrivialIdxExp(b)) {
// This must be an undefined level. // This must be an undefined level.
assert(!optLvl.has_value()); assert(!optLvl.has_value());
// Slice the tid along the dependent level to iterate current loop. // Slice the tid along the dependent level to iterate current loop.
callback(b, t, getLoopDependentLevel(b), lvlTp, callback(b, t, getLoopDependentLevel(b), lvlTp,
/*isIdxReduc=*/true); /*isIdxReduc=*/true);
} else { } else {
callback(b, t, optLvl, lvlTp, /*isIdxReduc=*/false); callback(b, t, optLvl, lvlTp, /*isIdxReduc=*/false);
▲ Show 20 Lines • Show All 231 Lines • Show Last 20 Lines

mlir/lib/Bindings/Python/DialectSparseTensor.cpp

Show All 33 Lines py::enum_<MlirSparseTensorDimLevelType>(m, "DimLevelType", py::module_local())
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_WITH_HI_NO) MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_WITH_HI_NO)
.value("compressed-hi-nu-no", .value("compressed-hi-nu-no",
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_WITH_HI_NU_NO); MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_WITH_HI_NU_NO);
mlir_attribute_subclass(m, "EncodingAttr", mlir_attribute_subclass(m, "EncodingAttr",
mlirAttributeIsASparseTensorEncodingAttr) mlirAttributeIsASparseTensorEncodingAttr)
.def_classmethod( .def_classmethod(
"get", "get",
[](py::object cls, [](py::object cls, std::vector<MlirSparseTensorDimLevelType> lvlTypes,
std::vector<MlirSparseTensorDimLevelType> dimLevelTypes,
std::optional<MlirAffineMap> dimOrdering, std::optional<MlirAffineMap> dimOrdering,
std::optional<MlirAffineMap> higherOrdering, int posWidth, std::optional<MlirAffineMap> higherOrdering, int posWidth,
int crdWidth, MlirContext context) { int crdWidth, MlirContext context) {
return cls(mlirSparseTensorEncodingAttrGet( return cls(mlirSparseTensorEncodingAttrGet(
context, dimLevelTypes.size(), dimLevelTypes.data(), context, lvlTypes.size(), lvlTypes.data(),
dimOrdering ? *dimOrdering : MlirAffineMap{nullptr}, dimOrdering ? *dimOrdering : MlirAffineMap{nullptr},
higherOrdering ? *higherOrdering : MlirAffineMap{nullptr}, higherOrdering ? *higherOrdering : MlirAffineMap{nullptr},
posWidth, crdWidth)); posWidth, crdWidth));
}, },
py::arg("cls"), py::arg("dim_level_types"), py::arg("dim_ordering"), py::arg("cls"), py::arg("lvl_types"), py::arg("dim_ordering"),
py::arg("higher_ordering"), py::arg("pos_width"), py::arg("higher_ordering"), py::arg("pos_width"),
py::arg("crd_width"), py::arg("context") = py::none(), py::arg("crd_width"), py::arg("context") = py::none(),
"Gets a sparse_tensor.encoding from parameters.") "Gets a sparse_tensor.encoding from parameters.")
.def_property_readonly( .def_property_readonly(
"dim_level_types", "lvl_types",
[](MlirAttribute self) { [](MlirAttribute self) {
const int lvlRank = mlirSparseTensorEncodingGetLvlRank(self); const int lvlRank = mlirSparseTensorEncodingGetLvlRank(self);
std::vector<MlirSparseTensorDimLevelType> ret; std::vector<MlirSparseTensorDimLevelType> ret;
ret.reserve(lvlRank); ret.reserve(lvlRank);
for (int l = 0; l < lvlRank; ++l) for (int l = 0; l < lvlRank; ++l)
ret.push_back( ret.push_back(mlirSparseTensorEncodingAttrGetLvlType(self, l));
mlirSparseTensorEncodingAttrGetDimLevelType(self, l));
return ret; return ret;
}) })
.def_property_readonly( .def_property_readonly(
"dim_ordering", "dim_ordering",
[](MlirAttribute self) -> std::optional<MlirAffineMap> { [](MlirAttribute self) -> std::optional<MlirAffineMap> {
MlirAffineMap ret = MlirAffineMap ret =
mlirSparseTensorEncodingAttrGetDimOrdering(self); mlirSparseTensorEncodingAttrGetDimOrdering(self);
if (mlirAffineMapIsNull(ret)) if (mlirAffineMapIsNull(ret))
Show All 22 Lines

mlir/lib/CAPI/Dialect/SparseTensor.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesstatic_assert(
"MlirSparseTensorDimLevelType (C-API) and DimLevelType (C++) mismatch"); "MlirSparseTensorDimLevelType (C-API) and DimLevelType (C++) mismatch");
bool mlirAttributeIsASparseTensorEncodingAttr(MlirAttribute attr) { bool mlirAttributeIsASparseTensorEncodingAttr(MlirAttribute attr) {
return isa<SparseTensorEncodingAttr>(unwrap(attr)); return isa<SparseTensorEncodingAttr>(unwrap(attr));
} }
MlirAttribute mlirSparseTensorEncodingAttrGet( MlirAttribute mlirSparseTensorEncodingAttrGet(
MlirContext ctx, intptr_t lvlRank, MlirContext ctx, intptr_t lvlRank,
MlirSparseTensorDimLevelType const *dimLevelTypes, MlirSparseTensorDimLevelType const *lvlTypes, MlirAffineMap dimOrdering,
MlirAffineMap dimOrdering, MlirAffineMap higherOrdering, int posWidth, MlirAffineMap higherOrdering, int posWidth, int crdWidth) {
int crdWidth) { SmallVector<DimLevelType> cppLvlTypes;
SmallVector<DimLevelType> cppDimLevelTypes; cppLvlTypes.reserve(lvlRank);
cppDimLevelTypes.reserve(lvlRank);
for (intptr_t l = 0; l < lvlRank; ++l) for (intptr_t l = 0; l < lvlRank; ++l)
cppDimLevelTypes.push_back(static_cast<DimLevelType>(dimLevelTypes[l])); cppLvlTypes.push_back(static_cast<DimLevelType>(lvlTypes[l]));
return wrap(SparseTensorEncodingAttr::get( return wrap(SparseTensorEncodingAttr::get(
unwrap(ctx), cppDimLevelTypes, unwrap(dimOrdering), unwrap(ctx), cppLvlTypes, unwrap(dimOrdering), unwrap(higherOrdering),
unwrap(higherOrdering), posWidth, crdWidth)); posWidth, crdWidth));
} }
MlirAffineMap mlirSparseTensorEncodingAttrGetDimOrdering(MlirAttribute attr) { MlirAffineMap mlirSparseTensorEncodingAttrGetDimOrdering(MlirAttribute attr) {
return wrap(cast<SparseTensorEncodingAttr>(unwrap(attr)).getDimOrdering()); return wrap(cast<SparseTensorEncodingAttr>(unwrap(attr)).getDimOrdering());
} }
MlirAffineMap MlirAffineMap
mlirSparseTensorEncodingAttrGetHigherOrdering(MlirAttribute attr) { mlirSparseTensorEncodingAttrGetHigherOrdering(MlirAttribute attr) {
return wrap(cast<SparseTensorEncodingAttr>(unwrap(attr)).getHigherOrdering()); return wrap(cast<SparseTensorEncodingAttr>(unwrap(attr)).getHigherOrdering());
} }
intptr_t mlirSparseTensorEncodingGetLvlRank(MlirAttribute attr) { intptr_t mlirSparseTensorEncodingGetLvlRank(MlirAttribute attr) {
return cast<SparseTensorEncodingAttr>(unwrap(attr)).getLvlRank(); return cast<SparseTensorEncodingAttr>(unwrap(attr)).getLvlRank();
} }
MlirSparseTensorDimLevelType MlirSparseTensorDimLevelType
mlirSparseTensorEncodingAttrGetDimLevelType(MlirAttribute attr, intptr_t lvl) { mlirSparseTensorEncodingAttrGetLvlType(MlirAttribute attr, intptr_t lvl) {
return static_cast<MlirSparseTensorDimLevelType>( return static_cast<MlirSparseTensorDimLevelType>(
cast<SparseTensorEncodingAttr>(unwrap(attr)).getLvlType(lvl)); cast<SparseTensorEncodingAttr>(unwrap(attr)).getLvlType(lvl));
} }
int mlirSparseTensorEncodingAttrGetPosWidth(MlirAttribute attr) { int mlirSparseTensorEncodingAttrGetPosWidth(MlirAttribute attr) {
return cast<SparseTensorEncodingAttr>(unwrap(attr)).getPosWidth(); return cast<SparseTensorEncodingAttr>(unwrap(attr)).getPosWidth();
} }
int mlirSparseTensorEncodingAttrGetCrdWidth(MlirAttribute attr) { int mlirSparseTensorEncodingAttrGetCrdWidth(MlirAttribute attr) {
return cast<SparseTensorEncodingAttr>(unwrap(attr)).getCrdWidth(); return cast<SparseTensorEncodingAttr>(unwrap(attr)).getCrdWidth();
} }

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

Show First 20 Lines • Show All 124 Lines • ▼ Show 20 LinesType SparseTensorEncodingAttr::getPosType() const {
return detail::getIntegerOrIndexType(getContext(), getPosWidth()); return detail::getIntegerOrIndexType(getContext(), getPosWidth());
} }
Type SparseTensorEncodingAttr::getCrdType() const { Type SparseTensorEncodingAttr::getCrdType() const {
return detail::getIntegerOrIndexType(getContext(), getCrdWidth()); return detail::getIntegerOrIndexType(getContext(), getCrdWidth());
} }
SparseTensorEncodingAttr SparseTensorEncodingAttr::withoutOrdering() const { SparseTensorEncodingAttr SparseTensorEncodingAttr::withoutOrdering() const {
return SparseTensorEncodingAttr::get(getContext(), getDimLevelType(), return SparseTensorEncodingAttr::get(getContext(), getLvlTypes(), AffineMap(),
AffineMap(), AffineMap(), getPosWidth(), AffineMap(), getPosWidth(),
getCrdWidth()); getCrdWidth());
} }
SparseTensorEncodingAttr SparseTensorEncodingAttr::withoutBitWidths() const { SparseTensorEncodingAttr SparseTensorEncodingAttr::withoutBitWidths() const {
return SparseTensorEncodingAttr::get(getContext(), getDimLevelType(), return SparseTensorEncodingAttr::get(
getDimOrdering(), getHigherOrdering(), 0, getContext(), getLvlTypes(), getDimOrdering(), getHigherOrdering(), 0, 0);
0);
} }
bool SparseTensorEncodingAttr::isAllDense() const { bool SparseTensorEncodingAttr::isAllDense() const {
return !getImpl() || llvm::all_of(getDimLevelType(), isDenseDLT); return !getImpl() || llvm::all_of(getLvlTypes(), isDenseDLT);
} }
bool SparseTensorEncodingAttr::isAllOrdered() const { bool SparseTensorEncodingAttr::isAllOrdered() const {
return !getImpl() || llvm::all_of(getDimLevelType(), isOrderedDLT); return !getImpl() || llvm::all_of(getLvlTypes(), isOrderedDLT);
} }
bool SparseTensorEncodingAttr::hasIdDimOrdering() const { bool SparseTensorEncodingAttr::hasIdDimOrdering() const {
return !getImpl() || !getDimOrdering() || getDimOrdering().isIdentity(); return !getImpl() || !getDimOrdering() || getDimOrdering().isIdentity();
} }
Level SparseTensorEncodingAttr::getLvlRank() const { Level SparseTensorEncodingAttr::getLvlRank() const {
assert(getImpl() && "Uninitialized SparseTensorEncodingAttr"); assert(getImpl() && "Uninitialized SparseTensorEncodingAttr");
return getDimLevelType().size(); return getLvlTypes().size();
} }
DimLevelType SparseTensorEncodingAttr::getLvlType(Level l) const { DimLevelType SparseTensorEncodingAttr::getLvlType(Level l) const {
if (!getImpl()) if (!getImpl())
return DimLevelType::Dense; return DimLevelType::Dense;
assert(l < getLvlRank() && "Level is out of bounds"); assert(l < getLvlRank() && "Level is out of bounds");
return getDimLevelType()[l]; return getLvlTypes()[l];
} }
std::optional<uint64_t> std::optional<uint64_t>
SparseTensorEncodingAttr::getStaticDimSliceOffset(Dimension dim) const { SparseTensorEncodingAttr::getStaticDimSliceOffset(Dimension dim) const {
return getDimSlices()[dim].getStaticOffset(); return getDimSlices()[dim].getStaticOffset();
} }
std::optional<uint64_t> std::optional<uint64_t>
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines#define ERROR_IF(COND, MSG) \
SmallVector<SparseTensorDimSliceAttr> slices; SmallVector<SparseTensorDimSliceAttr> slices;
AffineMap dimOrd = {}; AffineMap dimOrd = {};
AffineMap higherOrd = {}; AffineMap higherOrd = {};
unsigned posWidth = 0; unsigned posWidth = 0;
unsigned crdWidth = 0; unsigned crdWidth = 0;
StringRef attrName; StringRef attrName;
// Exactly 6 keys. // Exactly 6 keys.
SmallVector<StringRef, 6> keys = {"dimLevelType", "dimOrdering", SmallVector<StringRef, 6> keys = {"lvlTypes", "dimOrdering", "higherOrdering",
"higherOrdering", "posWidth", "posWidth", "crdWidth", "slice"};
"crdWidth", "slice"};
while (succeeded(parser.parseOptionalKeyword(&attrName))) { while (succeeded(parser.parseOptionalKeyword(&attrName))) {
if (!llvm::is_contained(keys, attrName)) { if (!llvm::is_contained(keys, attrName)) {
parser.emitError(parser.getNameLoc(), "unexpected key: ") << attrName; parser.emitError(parser.getNameLoc(), "unexpected key: ") << attrName;
return {}; return {};
} }
// Consume the `=` after keys // Consume the `=` after keys
RETURN_ON_FAIL(parser.parseEqual()) RETURN_ON_FAIL(parser.parseEqual())
// FIXME: using `operator==` below duplicates the string comparison // FIXME: using `operator==` below duplicates the string comparison
// cost of the `is_contained` check above. Should instead use some // cost of the `is_contained` check above. Should instead use some
// "find" function that returns the index into `keys` so that we can // "find" function that returns the index into `keys` so that we can
// dispatch on that instead. // dispatch on that instead.
if (attrName == "dimLevelType") { if (attrName == "lvlTypes") {
Attribute attr; Attribute attr;
RETURN_ON_FAIL(parser.parseAttribute(attr)); RETURN_ON_FAIL(parser.parseAttribute(attr));
auto arrayAttr = llvm::dyn_cast<ArrayAttr>(attr); auto arrayAttr = llvm::dyn_cast<ArrayAttr>(attr);
ERROR_IF(!arrayAttr, "expected an array for dimension level types") ERROR_IF(!arrayAttr, "expected an array for dimension level types")
for (auto i : arrayAttr) { for (auto i : arrayAttr) {
auto strAttr = llvm::dyn_cast<StringAttr>(i); auto strAttr = llvm::dyn_cast<StringAttr>(i);
ERROR_IF(!strAttr, "expected a string value in dimension level types") ERROR_IF(!strAttr, "expected a string value in dimension level types")
auto strVal = strAttr.getValue(); auto strVal = strAttr.getValue();
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines#undef RETURN_ON_FAIL
// Construct struct-like storage for attribute. // Construct struct-like storage for attribute.
return parser.getChecked<SparseTensorEncodingAttr>( return parser.getChecked<SparseTensorEncodingAttr>(
parser.getContext(), lvlTypes, dimOrd, higherOrd, posWidth, crdWidth, parser.getContext(), lvlTypes, dimOrd, higherOrd, posWidth, crdWidth,
slices); slices);
} }
void SparseTensorEncodingAttr::print(AsmPrinter &printer) const { void SparseTensorEncodingAttr::print(AsmPrinter &printer) const {
// Print the struct-like storage in dictionary fashion. // Print the struct-like storage in dictionary fashion.
printer << "<{ dimLevelType = [ "; printer << "<{ lvlTypes = [ ";
llvm::interleaveComma(getDimLevelType(), printer, [&](DimLevelType dlt) { llvm::interleaveComma(getLvlTypes(), printer, [&](DimLevelType dlt) {
printer << "\"" << toMLIRString(dlt) << "\""; printer << "\"" << toMLIRString(dlt) << "\"";
}); });
printer << " ]"; printer << " ]";
// Print remaining members only for non-default values. // Print remaining members only for non-default values.
if (!hasIdDimOrdering()) if (!hasIdDimOrdering())
printer << ", dimOrdering = affine_map<" << getDimOrdering() << ">"; printer << ", dimOrdering = affine_map<" << getDimOrdering() << ">";
if (getHigherOrdering()) if (getHigherOrdering())
printer << ", higherOrdering = affine_map<" << getHigherOrdering() << ">"; printer << ", higherOrdering = affine_map<" << getHigherOrdering() << ">";
Show All 12 Lines if (!getDimSlices().empty()) {
printer << " ]"; printer << " ]";
} }
printer << " }>"; printer << " }>";
} }
LogicalResult SparseTensorEncodingAttr::verify( LogicalResult SparseTensorEncodingAttr::verify(
function_ref<InFlightDiagnostic()> emitError, function_ref<InFlightDiagnostic()> emitError,
ArrayRef<DimLevelType> dimLevelType, AffineMap dimOrdering, ArrayRef<DimLevelType> lvlTypes, AffineMap dimOrdering,
AffineMap higherOrdering, unsigned posWidth, unsigned crdWidth, AffineMap higherOrdering, unsigned posWidth, unsigned crdWidth,
ArrayRef<SparseTensorDimSliceAttr> dimSlices) { ArrayRef<SparseTensorDimSliceAttr> dimSlices) {
if (!acceptBitWidth(posWidth)) if (!acceptBitWidth(posWidth))
return emitError() << "unexpected position bitwidth: " << posWidth; return emitError() << "unexpected position bitwidth: " << posWidth;
if (!acceptBitWidth(crdWidth)) if (!acceptBitWidth(crdWidth))
return emitError() << "unexpected coordinate bitwidth: " << crdWidth; return emitError() << "unexpected coordinate bitwidth: " << crdWidth;
// Before we can check that the level-rank is consistent/coherent // Before we can check that the level-rank is consistent/coherent
// across all fields, we need to define it. The source-of-truth for // across all fields, we need to define it. The source-of-truth for
// the `getLvlRank` method is the length of the level-types array, // the `getLvlRank` method is the length of the level-types array,
// since it must always be provided and have full rank; therefore we // since it must always be provided and have full rank; therefore we
// use that same source-of-truth here. // use that same source-of-truth here.
const Level lvlRank = dimLevelType.size(); const Level lvlRank = lvlTypes.size();
if (lvlRank == 0) if (lvlRank == 0)
return emitError() << "expected a non-empty array for level types"; return emitError() << "expected a non-empty array for level types";
if (dimOrdering) { if (dimOrdering) {
if (!dimOrdering.isPermutation()) if (!dimOrdering.isPermutation())
return emitError() return emitError()
<< "expected a permutation affine map for dimension ordering"; << "expected a permutation affine map for dimension ordering";
if (dimOrdering.getNumResults() != lvlRank) if (dimOrdering.getNumResults() != lvlRank)
return emitError() << "unexpected mismatch in ordering and dimension " return emitError() << "unexpected mismatch in ordering and dimension "
Show All 20 Lines if (failed(X)) { \
return failure(); \ return failure(); \
} }
LogicalResult SparseTensorEncodingAttr::verifyEncoding( LogicalResult SparseTensorEncodingAttr::verifyEncoding(
ArrayRef<DynSize> dimShape, Type elementType, ArrayRef<DynSize> dimShape, Type elementType,
function_ref<InFlightDiagnostic()> emitError) const { function_ref<InFlightDiagnostic()> emitError) const {
// Check structural integrity. In particular, this ensures that the // Check structural integrity. In particular, this ensures that the
// level-rank is coherent across all the fields. // level-rank is coherent across all the fields.
RETURN_FAILURE_IF_FAILED(verify(emitError, getDimLevelType(), RETURN_FAILURE_IF_FAILED(verify(emitError, getLvlTypes(), getDimOrdering(),
getDimOrdering(), getHigherOrdering(), getHigherOrdering(), getPosWidth(),
getPosWidth(), getCrdWidth(), getDimSlices())) getCrdWidth(), getDimSlices()))
// Check integrity with tensor type specifics. In particular, we // Check integrity with tensor type specifics. In particular, we
// need only check that the dimension-rank of the tensor agrees with // need only check that the dimension-rank of the tensor agrees with
// the dimension-rank of the encoding. // the dimension-rank of the encoding.
const Dimension dimRank = dimShape.size(); const Dimension dimRank = dimShape.size();
if (dimRank == 0) if (dimRank == 0)
return emitError() << "expected non-scalar sparse tensor"; return emitError() << "expected non-scalar sparse tensor";
if (const auto higherOrdering = getHigherOrdering()) { if (const auto higherOrdering = getHigherOrdering()) {
if (higherOrdering.getNumDims() != dimRank) if (higherOrdering.getNumDims() != dimRank)
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 LinesRankedTensorType sparse_tensor::getCOOFromTypeWithOrdering(RankedTensorType rtt,
// agrees with the size of `lvlPerm` because that will be verified by // agrees with the size of `lvlPerm` because that will be verified by
// `STEA::get`. // `STEA::get`.
const Level lvlRank = src.getDimRank(); const Level lvlRank = src.getDimRank();
SmallVector<DimLevelType> lvlTypes; SmallVector<DimLevelType> lvlTypes;
// An unordered and non-unique compressed level at beginning. // An unordered and non-unique compressed level at beginning.
// If this is also the last level, then it is unique. // If this is also the last level, then it is unique.
lvlTypes.push_back( lvlTypes.push_back(
*getDimLevelType(LevelFormat::Compressed, ordered, lvlRank == 1)); *buildLevelType(LevelFormat::Compressed, ordered, lvlRank == 1));
if (lvlRank > 1) { if (lvlRank > 1) {
// TODO: it is actually ordered at the level for ordered input. // TODO: it is actually ordered at the level for ordered input.
// Followed by unordered non-unique n-2 singleton levels. // Followed by unordered non-unique n-2 singleton levels.
std::fill_n(std::back_inserter(lvlTypes), lvlRank - 2, std::fill_n(std::back_inserter(lvlTypes), lvlRank - 2,
*getDimLevelType(LevelFormat::Singleton, ordered, false)); *buildLevelType(LevelFormat::Singleton, ordered, false));
// Ends by a unique singleton level unless the lvlRank is 1. // Ends by a unique singleton level unless the lvlRank is 1.
lvlTypes.push_back(*getDimLevelType(LevelFormat::Singleton, ordered, true)); lvlTypes.push_back(*buildLevelType(LevelFormat::Singleton, ordered, true));
} }
// TODO: Maybe pick the bitwidth based on input/output tensors (probably the // TODO: Maybe pick the bitwidth based on input/output tensors (probably the
// largest one among them) in the original operation instead of using the // largest one among them) in the original operation instead of using the
// default value. // default value.
unsigned posWidth = src.getPosWidth(); unsigned posWidth = src.getPosWidth();
unsigned crdWidth = src.getCrdWidth(); unsigned crdWidth = src.getCrdWidth();
auto enc = SparseTensorEncodingAttr::get(src.getContext(), lvlTypes, lvlPerm, auto enc = SparseTensorEncodingAttr::get(src.getContext(), lvlTypes, lvlPerm,
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
/// We normalized sparse tensor encoding attribute by always using /// We normalized sparse tensor encoding attribute by always using
/// ordered/unique DLT such that "compressed-nu-no" and "compressed-nu" (as well /// ordered/unique DLT such that "compressed-nu-no" and "compressed-nu" (as well
/// as other variants) lead to the same storage specifier type, and stripping /// as other variants) lead to the same storage specifier type, and stripping
/// irrelevant fields that do not alter the sparse tensor memory layout. /// irrelevant fields that do not alter the sparse tensor memory layout.
static SparseTensorEncodingAttr static SparseTensorEncodingAttr
getNormalizedEncodingForSpecifier(SparseTensorEncodingAttr enc) { getNormalizedEncodingForSpecifier(SparseTensorEncodingAttr enc) {
SmallVector<DimLevelType> dlts; SmallVector<DimLevelType> dlts;
for (auto dlt : enc.getDimLevelType()) for (auto dlt : enc.getLvlTypes())
dlts.push_back(*getDimLevelType(*getLevelFormat(dlt), true, true)); dlts.push_back(*buildLevelType(*getLevelFormat(dlt), true, true));
return SparseTensorEncodingAttr::get( return SparseTensorEncodingAttr::get(
enc.getContext(), dlts, enc.getContext(), dlts,
AffineMap(), // dimOrdering (irrelavant to storage speicifer) AffineMap(), // dimOrdering (irrelavant to storage speicifer)
AffineMap(), // highLvlOrdering (irrelavant to storage specifer) AffineMap(), // highLvlOrdering (irrelavant to storage specifer)
// Always use `index` for memSize and lvlSize instead of reusing // Always use `index` for memSize and lvlSize instead of reusing
// `getPosWidth` and `getCrdWidth`. It allows us to reuse the same SSA // `getPosWidth` and `getCrdWidth`. It allows us to reuse the same SSA
// value for different bitwidth, it also avoids casting between index and // value for different bitwidth, it also avoids casting between index and
▲ Show 20 Lines • Show All 604 Lines • Show Last 20 Lines

mlir/lib/Dialect/SparseTensor/Transforms/CodegenEnv.h

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Linespublic:
} }
constexpr TensorLoopId makeTensorLoopId(unsigned t, unsigned i) const { constexpr TensorLoopId makeTensorLoopId(unsigned t, unsigned i) const {
return latticeMerger.makeTensorLoopId(t, i); return latticeMerger.makeTensorLoopId(t, i);
} }
const TensorExp &exp(ExprId e) const { return latticeMerger.exp(e); } const TensorExp &exp(ExprId e) const { return latticeMerger.exp(e); }
const LatPoint &lat(LatPointId l) const { return latticeMerger.lat(l); } const LatPoint &lat(LatPointId l) const { return latticeMerger.lat(l); }
ArrayRef<LatPointId> set(LatSetId s) const { return latticeMerger.set(s); } ArrayRef<LatPointId> set(LatSetId s) const { return latticeMerger.set(s); }
DimLevelType dlt(TensorId t, LoopId i) const { DimLevelType dlt(TensorId t, LoopId i) const {
return latticeMerger.getDimLevelType(t, i); return latticeMerger.getLvlType(t, i);
}
DimLevelType dlt(TensorLoopId b) const {
return latticeMerger.getDimLevelType(b);
} }
DimLevelType dlt(TensorLoopId b) const { return latticeMerger.getLvlType(b); }
// //
// LoopEmitter delegates. // LoopEmitter delegates.
// //
TensorLevel makeTensorLevel(TensorId t, Level l) const { TensorLevel makeTensorLevel(TensorId t, Level l) const {
// Make sure LoopEmitter, GenericOp, and Merger agree on the number of // Make sure LoopEmitter, GenericOp, and Merger agree on the number of
// tensors. Merger has one more synthetic tensor for loop invariants. // tensors. Merger has one more synthetic tensor for loop invariants.
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 282 Lines • ▼ Show 20 Lines for (TensorId tid = 0; tid < numTensors; tid++) {
} }
const SparseTensorType stt(rtp); const SparseTensorType stt(rtp);
const Level lvlRank = stt.getLvlRank(); const Level lvlRank = stt.getLvlRank();
// We always treat sparse output tensor as dense so that we always iterate // We always treat sparse output tensor as dense so that we always iterate
// it based on lvl size. // it based on lvl size.
if (stt.hasEncoding() && !(isOutputTensor(tid) && isSparseOut)) { if (stt.hasEncoding() && !(isOutputTensor(tid) && isSparseOut)) {
const auto enc = stt.getEncoding(); const auto enc = stt.getEncoding();
isSparseSlices[tid] = enc.isSlice(); isSparseSlices[tid] = enc.isSlice();
for (auto lvlTp : enc.getDimLevelType()) for (auto lvlTp : enc.getLvlTypes())
lvlTypes[tid].push_back(lvlTp); lvlTypes[tid].push_back(lvlTp);
} else { } else {
lvlTypes[tid].assign(lvlRank, DimLevelType::Dense); lvlTypes[tid].assign(lvlRank, DimLevelType::Dense);
} }
// Initialize using empty value. // Initialize using empty value.
lvlSizes[tid].assign(lvlRank, Value()); lvlSizes[tid].assign(lvlRank, Value());
highs[tid].assign(lvlRank, Value()); highs[tid].assign(lvlRank, Value());
▲ Show 20 Lines • Show All 1,821 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,153 Lines • ▼ Show 20 Lines matchAndRewrite(tensor::ExtractSliceOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override { ConversionPatternRewriter &rewriter) const override {
Location loc = op.getLoc(); Location loc = op.getLoc();
MLIRContext *ctx = op.getContext(); MLIRContext *ctx = op.getContext();
auto srcEnc = getSparseTensorEncoding(op.getSourceType()); auto srcEnc = getSparseTensorEncoding(op.getSourceType());
auto dstEnc = getSparseTensorEncoding(op.getResult().getType()); auto dstEnc = getSparseTensorEncoding(op.getResult().getType());
// TODO: We should check these in ExtractSliceOp::verify. // TODO: We should check these in ExtractSliceOp::verify.
if (!srcEnc || !dstEnc || !dstEnc.isSlice()) if (!srcEnc || !dstEnc || !dstEnc.isSlice())
return failure(); return failure();
assert(srcEnc.getDimLevelType() == dstEnc.getDimLevelType()); assert(srcEnc.getLvlTypes() == dstEnc.getLvlTypes());
assert(srcEnc.getDimOrdering() == dstEnc.getDimOrdering()); assert(srcEnc.getDimOrdering() == dstEnc.getDimOrdering());
assert(srcEnc.getHigherOrdering() == dstEnc.getHigherOrdering()); assert(srcEnc.getHigherOrdering() == dstEnc.getHigherOrdering());
assert(srcEnc.getPosWidth() == dstEnc.getPosWidth()); assert(srcEnc.getPosWidth() == dstEnc.getPosWidth());
assert(srcEnc.getCrdWidth() == dstEnc.getCrdWidth()); assert(srcEnc.getCrdWidth() == dstEnc.getCrdWidth());
SmallVector<Value> fields; SmallVector<Value> fields;
auto desc = getMutDescriptorFromTensorTuple(adaptor.getSource(), fields); auto desc = getMutDescriptorFromTensorTuple(adaptor.getSource(), fields);
▲ Show 20 Lines • Show All 606 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 199 Lines • ▼ Show 20 Linesstatic Value genAlloc(RewriterBase &rewriter, Location loc, Value sz, Type tp) {
return rewriter.create<memref::AllocOp>(loc, memTp, ValueRange{sz}); return rewriter.create<memref::AllocOp>(loc, memTp, ValueRange{sz});
} }
/// Generates a temporary buffer for the level-types of the given encoding. /// Generates a temporary buffer for the level-types of the given encoding.
static Value genLvlTypesBuffer(OpBuilder &builder, Location loc, static Value genLvlTypesBuffer(OpBuilder &builder, Location loc,
SparseTensorType stt) { SparseTensorType stt) {
SmallVector<Value> lvlTypes; SmallVector<Value> lvlTypes;
lvlTypes.reserve(stt.getLvlRank()); lvlTypes.reserve(stt.getLvlRank());
for (const auto dlt : stt.getEncoding().getDimLevelType()) for (const auto dlt : stt.getEncoding().getLvlTypes())
lvlTypes.push_back(constantDimLevelTypeEncoding(builder, loc, dlt)); lvlTypes.push_back(constantDimLevelTypeEncoding(builder, loc, dlt));
return allocaBuffer(builder, loc, lvlTypes); return allocaBuffer(builder, loc, lvlTypes);
} }
/// This class abstracts over the API of `_mlir_ciface_newSparseTensor`: /// This class abstracts over the API of `_mlir_ciface_newSparseTensor`:
/// the "swiss army knife" method of the sparse runtime support library /// the "swiss army knife" method of the sparse runtime support library
/// for materializing sparse tensors into the computation. This abstraction /// for materializing sparse tensors into the computation. This abstraction
/// reduces the need to make modifications to client code whenever that /// reduces the need to make modifications to client code whenever that
▲ Show 20 Lines • Show All 343 Lines • ▼ Show 20 Linesstatic void genSparseCOOIterationLoop(
Block *before = rewriter.createBlock(&whileOp.getBefore(), {}, noTypes); Block *before = rewriter.createBlock(&whileOp.getBefore(), {}, noTypes);
rewriter.setInsertionPointToEnd(before); rewriter.setInsertionPointToEnd(before);
Value cond = genGetNextCall(rewriter, loc, iter, srcDimCoords, elemPtr); Value cond = genGetNextCall(rewriter, loc, iter, srcDimCoords, elemPtr);
rewriter.create<scf::ConditionOp>(loc, cond, before->getArguments()); rewriter.create<scf::ConditionOp>(loc, cond, before->getArguments());
Block *after = rewriter.createBlock(&whileOp.getAfter(), {}, noTypes); Block *after = rewriter.createBlock(&whileOp.getAfter(), {}, noTypes);
rewriter.setInsertionPointToStart(after); rewriter.setInsertionPointToStart(after);
const bool hasDenseDim = const bool hasDenseDim =
llvm::any_of(stt.getEncoding().getDimLevelType(), isDenseDLT); llvm::any_of(stt.getEncoding().getLvlTypes(), isDenseDLT);
if (hasDenseDim) { if (hasDenseDim) {
Value elemV = rewriter.create<memref::LoadOp>(loc, elemPtr); Value elemV = rewriter.create<memref::LoadOp>(loc, elemPtr);
Value isZero = genIsNonzero(rewriter, loc, elemV); Value isZero = genIsNonzero(rewriter, loc, elemV);
scf::IfOp ifOp = rewriter.create<scf::IfOp>(loc, isZero, /*else*/ false); scf::IfOp ifOp = rewriter.create<scf::IfOp>(loc, isZero, /*else*/ false);
rewriter.setInsertionPointToStart(&ifOp.getThenRegion().front()); rewriter.setInsertionPointToStart(&ifOp.getThenRegion().front());
} }
// Callback here to build loop body. // Callback here to build loop body.
bodyBuilder(rewriter, loc, srcDimCoords, elemPtr); bodyBuilder(rewriter, loc, srcDimCoords, elemPtr);
▲ Show 20 Lines • Show All 298 Lines • ▼ Show 20 Lines if (srcTp.hasEncoding() && dstTp.hasEncoding()) {
SmallVector<Value> dimSizes = getDimSizes(rewriter, loc, srcTp, src); SmallVector<Value> dimSizes = getDimSizes(rewriter, loc, srcTp, src);
bool useDirectConversion; bool useDirectConversion;
switch (options.sparseToSparseStrategy) { switch (options.sparseToSparseStrategy) {
case SparseToSparseConversionStrategy::kViaCOO: case SparseToSparseConversionStrategy::kViaCOO:
useDirectConversion = false; useDirectConversion = false;
break; break;
case SparseToSparseConversionStrategy::kDirect: case SparseToSparseConversionStrategy::kDirect:
useDirectConversion = true; useDirectConversion = true;
assert(canUseDirectConversion(dstEnc.getDimLevelType()) && assert(canUseDirectConversion(dstEnc.getLvlTypes()) &&
"Unsupported target for direct sparse-to-sparse conversion"); "Unsupported target for direct sparse-to-sparse conversion");
break; break;
case SparseToSparseConversionStrategy::kAuto: case SparseToSparseConversionStrategy::kAuto:
useDirectConversion = canUseDirectConversion(dstEnc.getDimLevelType()); useDirectConversion = canUseDirectConversion(dstEnc.getLvlTypes());
break; break;
} }
if (useDirectConversion) { if (useDirectConversion) {
rewriter.replaceOp( rewriter.replaceOp(
op, params.genBuffers(srcTp.withEncoding(dstEnc), dimSizes) op, params.genBuffers(srcTp.withEncoding(dstEnc), dimSizes)
.genNewCall(Action::kSparseToSparse, src)); .genNewCall(Action::kSparseToSparse, src));
} else { // use via-COO conversion. } else { // use via-COO conversion.
// Set up encoding with right mix of src and dst so that the two // Set up encoding with right mix of src and dst so that the two
// method calls can share most parameters, while still providing // method calls can share most parameters, while still providing
// the correct sparsity information to either of them. // the correct sparsity information to either of them.
const auto mixedEnc = SparseTensorEncodingAttr::get( const auto mixedEnc = SparseTensorEncodingAttr::get(
op->getContext(), dstEnc.getDimLevelType(), dstEnc.getDimOrdering(), op->getContext(), dstEnc.getLvlTypes(), dstEnc.getDimOrdering(),
dstEnc.getHigherOrdering(), srcEnc.getPosWidth(), dstEnc.getHigherOrdering(), srcEnc.getPosWidth(),
srcEnc.getCrdWidth()); srcEnc.getCrdWidth());
// TODO: This is the only place where `kToCOO` (or `kToIterator`) // TODO: This is the only place where `kToCOO` (or `kToIterator`)
// is called with a non-identity permutation. Is there any clean // is called with a non-identity permutation. Is there any clean
// way to push the permutation over to the `kFromCOO` side instead? // way to push the permutation over to the `kFromCOO` side instead?
Value coo = params.genBuffers(srcTp.withEncoding(mixedEnc), dimSizes) Value coo = params.genBuffers(srcTp.withEncoding(mixedEnc), dimSizes)
.genNewCall(Action::kToCOO, src); .genNewCall(Action::kToCOO, src);
Value dst = params.setTemplateTypes(srcTp.withEncoding(dstEnc)) Value dst = params.setTemplateTypes(srcTp.withEncoding(dstEnc))
▲ Show 20 Lines • Show All 569 Lines • Show Last 20 Lines

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

Show All 38 Lines
// Helper method to match any typed zero. // Helper method to match any typed zero.
static bool isZeroValue(Value val) { static bool isZeroValue(Value val) {
return matchPattern(val, m_Zero()) || matchPattern(val, m_AnyZeroFloat()); return matchPattern(val, m_Zero()) || matchPattern(val, m_AnyZeroFloat());
} }
// Helper to detect a sparse tensor type operand. // Helper to detect a sparse tensor type operand.
static bool isSparseTensor(OpOperand *op) { static bool isSparseTensor(OpOperand *op) {
auto enc = getSparseTensorEncoding(op->get().getType()); auto enc = getSparseTensorEncoding(op->get().getType());
return enc && return enc && llvm::is_contained(enc.getLvlTypes(), DimLevelType::Compressed);
llvm::is_contained(enc.getDimLevelType(), DimLevelType::Compressed);
} }
// Helper method to find zero/uninitialized allocation. // Helper method to find zero/uninitialized allocation.
static bool isAlloc(OpOperand *op, bool isZero) { static bool isAlloc(OpOperand *op, bool isZero) {
Value val = op->get(); Value val = op->get();
// Check allocation, with zero alloc when required. // Check allocation, with zero alloc when required.
if (auto alloc = val.getDefiningOp<AllocTensorOp>()) { if (auto alloc = val.getDefiningOp<AllocTensorOp>()) {
Value copy = alloc.getCopy(); Value copy = alloc.getCopy();
▲ Show 20 Lines • Show All 1,229 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 Lines llvm::function_ref<bool(FieldIndex, SparseTensorFieldKind, Level,
DimLevelType)> DimLevelType)>
callback) { callback) {
assert(enc); assert(enc);
#define RETURN_ON_FALSE(fidx, kind, dim, dlt) \ #define RETURN_ON_FALSE(fidx, kind, dim, dlt) \
if (!(callback(fidx, kind, dim, dlt))) \ if (!(callback(fidx, kind, dim, dlt))) \
return; return;
const auto lvlTypes = enc.getDimLevelType(); const auto lvlTypes = enc.getLvlTypes();
const Level lvlRank = enc.getLvlRank(); const Level lvlRank = enc.getLvlRank();
const Level cooStart = getCOOStart(enc); const Level cooStart = getCOOStart(enc);
const Level end = cooStart == lvlRank ? cooStart : cooStart + 1; const Level end = cooStart == lvlRank ? cooStart : cooStart + 1;
FieldIndex fieldIdx = kDataFieldStartingIdx; FieldIndex fieldIdx = kDataFieldStartingIdx;
// Per-dimension storage. // Per-dimension storage.
for (Level l = 0; l < end; l++) { for (Level l = 0; l < end; l++) {
// Dimension level types apply in order to the reordered dimension. // Dimension level types apply in order to the reordered dimension.
// As a result, the compound type can be constructed directly in the given // As a result, the compound type can be constructed directly in the given
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 226 Lines • ▼ Show 20 Lines
/// compound affine sparse level, and it will be incremented by one when /// compound affine sparse level, and it will be incremented by one when
/// used. /// used.
static bool findAffine(Merger &merger, TensorId tid, Level lvl, AffineExpr a, static bool findAffine(Merger &merger, TensorId tid, Level lvl, AffineExpr a,
DimLevelType dlt, LoopId &filterLdx, DimLevelType dlt, LoopId &filterLdx,
bool setLvlFormat = true) { bool setLvlFormat = true) {
switch (a.getKind()) { switch (a.getKind()) {
case AffineExprKind::DimId: { case AffineExprKind::DimId: {
const LoopId idx = merger.makeLoopId(a.cast<AffineDimExpr>().getPosition()); const LoopId idx = merger.makeLoopId(a.cast<AffineDimExpr>().getPosition());
if (!isUndefDLT(merger.getDimLevelType(tid, idx))) if (!isUndefDLT(merger.getLvlType(tid, idx)))
return false; // used more than once return false; // used more than once
if (setLvlFormat) if (setLvlFormat)
merger.setLevelAndType(tid, idx, lvl, dlt); merger.setLevelAndType(tid, idx, lvl, dlt);
return true; return true;
} }
case AffineExprKind::Add: case AffineExprKind::Add:
case AffineExprKind::Mul: case AffineExprKind::Mul:
case AffineExprKind::Constant: { case AffineExprKind::Constant: {
if (!isDenseDLT(dlt) && setLvlFormat) { if (!isDenseDLT(dlt) && setLvlFormat) {
assert(isUndefDLT(merger.getDimLevelType(tid, filterLdx))); assert(isUndefDLT(merger.getLvlType(tid, filterLdx)));
// Use a filter loop for sparse affine expression. // Use a filter loop for sparse affine expression.
merger.setLevelAndType(tid, filterLdx, lvl, dlt); merger.setLevelAndType(tid, filterLdx, lvl, dlt);
++filterLdx; ++filterLdx;
} }
if (auto binOp = a.dyn_cast<AffineBinaryOpExpr>()) { if (auto binOp = a.dyn_cast<AffineBinaryOpExpr>()) {
// We do not set dim level format for affine expresssion like d0 + d1 on // We do not set dim level format for affine expresssion like d0 + d1 on
// either loop index at d0 or d1. // either loop index at d0 or d1.
Show All 27 Lines
/// ///
/// TODO: constant should be easy to handle. /// TODO: constant should be easy to handle.
static bool findDepIdxSet(Merger &merger, TensorId tensor, Level lvl, static bool findDepIdxSet(Merger &merger, TensorId tensor, Level lvl,
AffineExpr a, DimLevelType dlt, AffineExpr a, DimLevelType dlt,
bool isSubExp = false) { bool isSubExp = false) {
switch (a.getKind()) { switch (a.getKind()) {
case AffineExprKind::DimId: { case AffineExprKind::DimId: {
const LoopId ldx = merger.makeLoopId(a.cast<AffineDimExpr>().getPosition()); const LoopId ldx = merger.makeLoopId(a.cast<AffineDimExpr>().getPosition());
if (!isUndefDLT(merger.getDimLevelType(tensor, ldx))) if (!isUndefDLT(merger.getLvlType(tensor, ldx)))
return false; // used more than once, e.g., A[i][i] return false; // used more than once, e.g., A[i][i]
// TODO: Generalizes the following two cases. A[i] (with trivial index // TODO: Generalizes the following two cases. A[i] (with trivial index
// expression) can be treated as a special affine index expression. We do // expression) can be treated as a special affine index expression. We do
// not necessarily need to differentiate them. // not necessarily need to differentiate them.
if (!isSubExp) if (!isSubExp)
merger.setLevelAndType(tensor, ldx, lvl, dlt); merger.setLevelAndType(tensor, ldx, lvl, dlt);
▲ Show 20 Lines • Show All 320 Lines • ▼ Show 20 Linesstatic void addFilterLoopBasedConstraints(CodegenEnv &env, OpOperand &t,
assert(!enc || lvlRank == enc.getLvlRank()); assert(!enc || lvlRank == enc.getLvlRank());
for (Level lvl = 0; lvl < lvlRank; lvl++) { for (Level lvl = 0; lvl < lvlRank; lvl++) {
// FIXME: `toOrigDim` is deprecated. // FIXME: `toOrigDim` is deprecated.
AffineExpr ta = map.getResult(toOrigDim(enc, lvl)); AffineExpr ta = map.getResult(toOrigDim(enc, lvl));
std::optional<LoopId> tldx = env.merger().getLoopId(tid, lvl); std::optional<LoopId> tldx = env.merger().getLoopId(tid, lvl);
// Filter loops should be constructed after all the dependent loops, // Filter loops should be constructed after all the dependent loops,
// i.e., d0 + d1 < filter_loop(d0 + d1) // i.e., d0 + d1 < filter_loop(d0 + d1)
if (tldx && env.merger().isFilterLoop(*tldx)) { if (tldx && env.merger().isFilterLoop(*tldx)) {
assert(!ta.isa<AffineDimExpr>() && assert(!ta.isa<AffineDimExpr>() && !isDenseDLT(enc.getLvlTypes()[lvl]));
!isDenseDLT(enc.getDimLevelType()[lvl]));
addAffineOrderings(adjM, inDegree, ta, AffineExpr(), std::nullopt, tldx); addAffineOrderings(adjM, inDegree, ta, AffineExpr(), std::nullopt, tldx);
// Now that the ordering of affine expression is captured by filter // Now that the ordering of affine expression is captured by filter
// loop idx, we only need to ensure the affine ordering against filter // loop idx, we only need to ensure the affine ordering against filter
// loop. Thus, we reset the affine express to nil here to mark it as // loop. Thus, we reset the affine express to nil here to mark it as
// resolved. // resolved.
ta = AffineExpr(); ta = AffineExpr();
} }
▲ Show 20 Lines • Show All 1,280 Lines • ▼ Show 20 Lines for (OpOperand *t : env.op().getDpsInputOperands()) {
// conversion into a sparse tensor that adheres to the iteration // conversion into a sparse tensor that adheres to the iteration
// graph order. Also releases the temporary sparse tensor. // graph order. Also releases the temporary sparse tensor.
// //
// TODO: investigate fusing the conversion with computation, // TODO: investigate fusing the conversion with computation,
// especially if it is a direct yield! // especially if it is a direct yield!
// //
auto srcTp = getRankedTensorType(tval); auto srcTp = getRankedTensorType(tval);
auto dstEnc = SparseTensorEncodingAttr::get( auto dstEnc = SparseTensorEncodingAttr::get(
getContext(), srcEnc.getDimLevelType(), getContext(), srcEnc.getLvlTypes(),
permute(env, env.op().getMatchingIndexingMap(t)), // new order permute(env, env.op().getMatchingIndexingMap(t)), // new order
srcEnc.getHigherOrdering(), srcEnc.getPosWidth(), srcEnc.getHigherOrdering(), srcEnc.getPosWidth(),
srcEnc.getCrdWidth()); srcEnc.getCrdWidth());
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);
rewriter.updateRootInPlace(env.op(), rewriter.updateRootInPlace(env.op(),
[&]() { env.op()->setOperand(tid, convert); }); [&]() { env.op()->setOperand(tid, convert); });
Show All 21 Lines

mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp

Show First 20 Lines • Show All 399 Lines • ▼ Show 20 LinesBitVector Merger::simplifyCond(LatSetId s0, LatPointId p0) {
BitVector simple(latPoints[p0].bits); BitVector simple(latPoints[p0].bits);
bool reset = isSingleton && hasAnySparse(simple); bool reset = isSingleton && hasAnySparse(simple);
const TensorLoopId be = simple.size(); const TensorLoopId be = simple.size();
TensorLoopId offset = 0; // relative to the end TensorLoopId offset = 0; // relative to the end
if (!reset) if (!reset)
// Starts resetting from a dense level, so that the first bit (if kept) // Starts resetting from a dense level, so that the first bit (if kept)
// is not undefined level-type. // is not undefined level-type.
for (unsigned b = 0; b < be; b++) { for (unsigned b = 0; b < be; b++) {
if (simple[b] && isDenseDLT(getDimLevelType(TensorLoopId{b}))) { if (simple[b] && isDenseDLT(getLvlType(TensorLoopId{b}))) {
offset = be - b - 1; // relative to the end offset = be - b - 1; // relative to the end
break; break;
} }
} }
// Now apply the two basic rules. We also iterate the bits reversely to always // Now apply the two basic rules. We also iterate the bits reversely to always
// keep the rightmost bit (which could possibly be a synthetic tensor). // keep the rightmost bit (which could possibly be a synthetic tensor).
for (unsigned b = be - 1 - offset, i = 0; i < be; for (unsigned b = be - 1 - offset, i = 0; i < be;
b = b == 0 ? be - 1 : b - 1, i++) { b = b == 0 ? be - 1 : b - 1, i++) {
// Slice on dense level has `locate` property as well, and can be optimized. // Slice on dense level has `locate` property as well, and can be optimized.
if (simple[b] && !isSparseLvlWithNonTrivialIdxExp(b)) { if (simple[b] && !isSparseLvlWithNonTrivialIdxExp(b)) {
const auto dlt = getDimLevelType(b); const auto dlt = getLvlType(b);
if (!isCompressedDLT(dlt) && !isSingletonDLT(dlt) && !isCompressedWithHiDLT(dlt)) { if (!isCompressedDLT(dlt) && !isSingletonDLT(dlt) && !isCompressedWithHiDLT(dlt)) {
if (reset) if (reset)
simple.reset(b); simple.reset(b);
reset = true; reset = true;
} }
} }
} }
return simple; return simple;
▲ Show 20 Lines • Show All 150 Lines • ▼ Show 20 Linesbool Merger::isSingleCondition(TensorId t, ExprId e) const {
case TensorExp::Kind::kReduce: case TensorExp::Kind::kReduce:
return false; return false;
} }
llvm_unreachable("unexpected kind"); llvm_unreachable("unexpected kind");
} }
bool Merger::hasAnySparse(const BitVector &bits) const { bool Merger::hasAnySparse(const BitVector &bits) const {
for (TensorLoopId b : bits.set_bits()) { for (TensorLoopId b : bits.set_bits()) {
const auto dlt = getDimLevelType(b); const auto dlt = getLvlType(b);
if (isCompressedDLT(dlt) || isSingletonDLT(dlt) || isCompressedWithHiDLT(dlt)) if (isCompressedDLT(dlt) || isSingletonDLT(dlt) || isCompressedWithHiDLT(dlt))
return true; return true;
} }
return hasSparseIdxReduction(bits); return hasSparseIdxReduction(bits);
} }
bool Merger::hasSparseIdxReduction(const BitVector &bits) const { bool Merger::hasSparseIdxReduction(const BitVector &bits) const {
for (TensorLoopId b : bits.set_bits()) for (TensorLoopId b : bits.set_bits())
▲ Show 20 Lines • Show All 884 Lines • Show Last 20 Lines

mlir/test/CAPI/sparse_tensor.c

Show All 19 Lines
#include <string.h> #include <string.h>
// CHECK-LABEL: testRoundtripEncoding() // CHECK-LABEL: testRoundtripEncoding()
static int testRoundtripEncoding(MlirContext ctx) { static int testRoundtripEncoding(MlirContext ctx) {
fprintf(stderr, "testRoundtripEncoding()\n"); fprintf(stderr, "testRoundtripEncoding()\n");
// clang-format off // clang-format off
const char *originalAsm = const char *originalAsm =
"#sparse_tensor.encoding<{ " "#sparse_tensor.encoding<{ "
"dimLevelType = [ \"dense\", \"compressed\", \"compressed\"], " "lvlTypes = [ \"dense\", \"compressed\", \"compressed\"], "
"dimOrdering = affine_map<(d0, d1, d2) -> (d0, d1, d2)>, " "dimOrdering = affine_map<(d0, d1, d2) -> (d0, d1, d2)>, "
"higherOrdering = affine_map<(d0, d1)[s0] -> (s0, d0, d1)>, " "higherOrdering = affine_map<(d0, d1)[s0] -> (s0, d0, d1)>, "
"posWidth = 32, crdWidth = 64 }>"; "posWidth = 32, crdWidth = 64 }>";
// clang-format on // clang-format on
MlirAttribute originalAttr = MlirAttribute originalAttr =
mlirAttributeParseGet(ctx, mlirStringRefCreateFromCString(originalAsm)); mlirAttributeParseGet(ctx, mlirStringRefCreateFromCString(originalAsm));
// CHECK: isa: 1 // CHECK: isa: 1
fprintf(stderr, "isa: %d\n", fprintf(stderr, "isa: %d\n",
mlirAttributeIsASparseTensorEncodingAttr(originalAttr)); mlirAttributeIsASparseTensorEncodingAttr(originalAttr));
MlirAffineMap dimOrdering = MlirAffineMap dimOrdering =
mlirSparseTensorEncodingAttrGetDimOrdering(originalAttr); mlirSparseTensorEncodingAttrGetDimOrdering(originalAttr);
// CHECK: (d0, d1, d2) -> (d0, d1, d2) // CHECK: (d0, d1, d2) -> (d0, d1, d2)
mlirAffineMapDump(dimOrdering); mlirAffineMapDump(dimOrdering);
MlirAffineMap higherOrdering = MlirAffineMap higherOrdering =
mlirSparseTensorEncodingAttrGetHigherOrdering(originalAttr); mlirSparseTensorEncodingAttrGetHigherOrdering(originalAttr);
// CHECK: (d0, d1)[s0] -> (s0, d0, d1) // CHECK: (d0, d1)[s0] -> (s0, d0, d1)
mlirAffineMapDump(higherOrdering); mlirAffineMapDump(higherOrdering);
// CHECK: level_type: 4 // CHECK: level_type: 4
// CHECK: level_type: 8 // CHECK: level_type: 8
// CHECK: level_type: 8 // CHECK: level_type: 8
int lvlRank = mlirSparseTensorEncodingGetLvlRank(originalAttr); int lvlRank = mlirSparseTensorEncodingGetLvlRank(originalAttr);
enum MlirSparseTensorDimLevelType *levelTypes = enum MlirSparseTensorDimLevelType *lvlTypes =
malloc(sizeof(enum MlirSparseTensorDimLevelType) * lvlRank); malloc(sizeof(enum MlirSparseTensorDimLevelType) * lvlRank);
for (int l = 0; l < lvlRank; ++l) { for (int l = 0; l < lvlRank; ++l) {
levelTypes[l] = lvlTypes[l] = mlirSparseTensorEncodingAttrGetLvlType(originalAttr, l);
mlirSparseTensorEncodingAttrGetDimLevelType(originalAttr, l); fprintf(stderr, "level_type: %d\n", lvlTypes[l]);
fprintf(stderr, "level_type: %d\n", levelTypes[l]);
} }
// CHECK: posWidth: 32 // CHECK: posWidth: 32
int posWidth = mlirSparseTensorEncodingAttrGetPosWidth(originalAttr); int posWidth = mlirSparseTensorEncodingAttrGetPosWidth(originalAttr);
fprintf(stderr, "posWidth: %d\n", posWidth); fprintf(stderr, "posWidth: %d\n", posWidth);
// CHECK: crdWidth: 64 // CHECK: crdWidth: 64
int crdWidth = mlirSparseTensorEncodingAttrGetCrdWidth(originalAttr); int crdWidth = mlirSparseTensorEncodingAttrGetCrdWidth(originalAttr);
fprintf(stderr, "crdWidth: %d\n", crdWidth); fprintf(stderr, "crdWidth: %d\n", crdWidth);
MlirAttribute newAttr = MlirAttribute newAttr = mlirSparseTensorEncodingAttrGet(
mlirSparseTensorEncodingAttrGet(ctx, lvlRank, levelTypes, dimOrdering, ctx, lvlRank, lvlTypes, dimOrdering, higherOrdering, posWidth, crdWidth);
higherOrdering, posWidth, crdWidth);
mlirAttributeDump(newAttr); // For debugging filecheck output. mlirAttributeDump(newAttr); // For debugging filecheck output.
// CHECK: equal: 1 // CHECK: equal: 1
fprintf(stderr, "equal: %d\n", mlirAttributeEqual(originalAttr, newAttr)); fprintf(stderr, "equal: %d\n", mlirAttributeEqual(originalAttr, newAttr));
free(levelTypes); free(lvlTypes);
return 0; return 0;
} }
int main(void) { int main(void) {
MlirContext ctx = mlirContextCreate(); MlirContext ctx = mlirContextCreate();
mlirDialectHandleRegisterDialect(mlirGetDialectHandle__sparse_tensor__(), mlirDialectHandleRegisterDialect(mlirGetDialectHandle__sparse_tensor__(),
ctx); ctx);
if (testRoundtripEncoding(ctx)) if (testRoundtripEncoding(ctx))
return 1; return 1;
mlirContextDestroy(ctx); mlirContextDestroy(ctx);
return 0; return 0;
} }

mlir/test/Dialect/Bufferization/invalid.mlir

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
func.func @escape_attr_non_bufferizable(%m0: memref<?xf32>) { func.func @escape_attr_non_bufferizable(%m0: memref<?xf32>) {
// expected-error @+1{{'bufferization.escape' only valid on bufferizable ops}} // expected-error @+1{{'bufferization.escape' only valid on bufferizable ops}}
%0 = memref.cast %m0 {bufferization.escape = [true]} : memref<?xf32> to memref<10xf32> %0 = memref.cast %m0 {bufferization.escape = [true]} : memref<?xf32> to memref<10xf32>
return return
} }
// ----- // -----
#DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
func.func @sparse_alloc_direct_return() -> tensor<20x40xf32, #DCSR> { func.func @sparse_alloc_direct_return() -> tensor<20x40xf32, #DCSR> {
// expected-error @+1{{sparse tensor allocation should not escape function}} // expected-error @+1{{sparse tensor allocation should not escape function}}
%0 = bufferization.alloc_tensor() : tensor<20x40xf32, #DCSR> %0 = bufferization.alloc_tensor() : tensor<20x40xf32, #DCSR>
return %0 : tensor<20x40xf32, #DCSR> return %0 : tensor<20x40xf32, #DCSR>
} }
// ----- // -----
#DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
func.func private @foo(tensor<20x40xf32, #DCSR>) -> () func.func private @foo(tensor<20x40xf32, #DCSR>) -> ()
func.func @sparse_alloc_call() { func.func @sparse_alloc_call() {
// expected-error @+1{{sparse tensor allocation should not escape function}} // expected-error @+1{{sparse tensor allocation should not escape function}}
%0 = bufferization.alloc_tensor() : tensor<20x40xf32, #DCSR> %0 = bufferization.alloc_tensor() : tensor<20x40xf32, #DCSR>
call @foo(%0) : (tensor<20x40xf32, #DCSR>) -> () call @foo(%0) : (tensor<20x40xf32, #DCSR>) -> ()
return return
Show All 18 Lines

mlir/test/Dialect/Bufferization/ops.mlir

// RUN: mlir-opt %s | mlir-opt | FileCheck %s // RUN: mlir-opt %s | mlir-opt | FileCheck %s
// RUN: mlir-opt %s --mlir-print-op-generic | mlir-opt | FileCheck %s // RUN: mlir-opt %s --mlir-print-op-generic | mlir-opt | FileCheck %s
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = ["dense", "compressed"] lvlTypes = ["dense", "compressed"]
}> }>
// CHECK-LABEL: func @test_clone // CHECK-LABEL: func @test_clone
func.func @test_clone(%buf : memref<*xf32>) -> memref<*xf32> { func.func @test_clone(%buf : memref<*xf32>) -> memref<*xf32> {
%clone = bufferization.clone %buf : memref<*xf32> to memref<*xf32> %clone = bufferization.clone %buf : memref<*xf32> to memref<*xf32>
return %clone : memref<*xf32> return %clone : memref<*xf32>
} }
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/drop-unit-extent-dims.mlir

Show First 20 Lines • Show All 848 Lines • ▼ Show 20 Lines#matvec = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (j)>, // b affine_map<(i,j) -> (j)>, // b
affine_map<(i,j) -> (i)> // x (out) affine_map<(i,j) -> (i)> // x (out)
], ],
iterator_types = ["parallel", "reduction"] iterator_types = ["parallel", "reduction"]
} }
#CSR = #sparse_tensor.encoding<{ dimLevelType = ["dense", "compressed"] }> #CSR = #sparse_tensor.encoding<{ lvlTypes = ["dense", "compressed"] }>
func.func @sparse_case(%arg0: tensor<8x8xf32, #CSR>, %arg1: tensor<8xf32>) -> tensor<8xf32> { func.func @sparse_case(%arg0: tensor<8x8xf32, #CSR>, %arg1: tensor<8xf32>) -> tensor<8xf32> {
%0 = tensor.empty() : tensor<8xf32> %0 = tensor.empty() : tensor<8xf32>
%1 = linalg.generic #matvec %1 = linalg.generic #matvec
ins(%arg0, %arg1: tensor<8x8xf32, #CSR>, tensor<8xf32>) ins(%arg0, %arg1: tensor<8x8xf32, #CSR>, tensor<8xf32>)
outs(%0: tensor<8xf32>) { outs(%0: tensor<8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%m = arith.mulf %a, %b : f32 %m = arith.mulf %a, %b : f32
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/GPU/gpu_combi.mlir

// RUN: mlir-opt %s --linalg-generalize-named-ops \ // RUN: mlir-opt %s --linalg-generalize-named-ops \
// RUN: --pre-sparsification-rewrite \ // RUN: --pre-sparsification-rewrite \
// RUN: --sparsification="parallelization-strategy=dense-outer-loop" \ // RUN: --sparsification="parallelization-strategy=dense-outer-loop" \
// RUN: --sparse-gpu-codegen | FileCheck %s // RUN: --sparse-gpu-codegen | FileCheck %s
#CSR = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }> #CSR = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>
// //
// CHECK-LABEL: gpu.module @sparse_kernels // CHECK-LABEL: gpu.module @sparse_kernels
// CHECK: gpu.func @kernel1 // CHECK: gpu.func @kernel1
// CHECK: gpu.func @kernel0 // CHECK: gpu.func @kernel0
// //
// CHECK-LABEL: func.func @matmuls // CHECK-LABEL: func.func @matmuls
// CHECK: gpu.alloc async // CHECK: gpu.alloc async
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/GPU/gpu_matmul.mlir

// RUN: mlir-opt %s --linalg-generalize-named-ops \ // RUN: mlir-opt %s --linalg-generalize-named-ops \
// RUN: --pre-sparsification-rewrite \ // RUN: --pre-sparsification-rewrite \
// RUN: --sparsification="parallelization-strategy=dense-outer-loop" \ // RUN: --sparsification="parallelization-strategy=dense-outer-loop" \
// RUN: --sparse-gpu-codegen | FileCheck %s // RUN: --sparse-gpu-codegen | FileCheck %s
#CSR = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }> #CSR = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>
// //
// Compute matrix matrix C = AB // Compute matrix matrix C = AB
// //
// CHECK-LABEL: gpu.module @sparse_kernels // CHECK-LABEL: gpu.module @sparse_kernels
// CHECK-LABEL: gpu.func @kernel0( // CHECK-LABEL: gpu.func @kernel0(
// CHECK-SAME: %[[VAL_0:.*0]]: index, // CHECK-SAME: %[[VAL_0:.*0]]: index,
// CHECK-SAME: %[[VAL_1:.*1]]: index, // CHECK-SAME: %[[VAL_1:.*1]]: index,
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/GPU/gpu_matvec.mlir

// RUN: mlir-opt %s --linalg-generalize-named-ops \ // RUN: mlir-opt %s --linalg-generalize-named-ops \
// RUN: --pre-sparsification-rewrite \ // RUN: --pre-sparsification-rewrite \
// RUN: --sparsification="parallelization-strategy=dense-outer-loop" \ // RUN: --sparsification="parallelization-strategy=dense-outer-loop" \
// RUN: --sparse-gpu-codegen | FileCheck %s // RUN: --sparse-gpu-codegen | FileCheck %s
#CSR = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }> #CSR = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>
// //
// Compute matrix vector y = Ax // Compute matrix vector y = Ax
// //
// CHECK-LABEL: gpu.module @sparse_kernels // CHECK-LABEL: gpu.module @sparse_kernels
// CHECK: gpu.func @kernel0( // CHECK: gpu.func @kernel0(
// CHECK-SAME: %[[VAL_0:.*0]]: index, // CHECK-SAME: %[[VAL_0:.*0]]: index,
// CHECK-SAME: %[[VAL_1:.*1]]: memref<?xf64>, // CHECK-SAME: %[[VAL_1:.*1]]: memref<?xf64>,
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/codegen.mlir

// RUN: mlir-opt %s --sparse-tensor-codegen --canonicalize -cse | FileCheck %s // RUN: mlir-opt %s --sparse-tensor-codegen --canonicalize -cse | FileCheck %s
#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = [ "compressed" ], lvlTypes = [ "compressed" ],
crdWidth = 64, crdWidth = 64,
posWidth = 32 posWidth = 32
}> }>
#Dense2D = #sparse_tensor.encoding<{ #Dense2D = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense" ], lvlTypes = [ "dense", "dense" ],
crdWidth = 64, crdWidth = 64,
posWidth = 32 posWidth = 32
}> }>
#Row = #sparse_tensor.encoding<{ #Row = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense" ], lvlTypes = [ "compressed", "dense" ],
crdWidth = 64, crdWidth = 64,
posWidth = 32 posWidth = 32
}> }>
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
crdWidth = 64, crdWidth = 64,
posWidth = 32 posWidth = 32
}> }>
#UCSR = #sparse_tensor.encoding<{ #UCSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed-no" ] lvlTypes = [ "dense", "compressed-no" ]
}> }>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i, j) -> (j, i)> dimOrdering = affine_map<(i, j) -> (j, i)>
}> }>
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
crdWidth = 64, crdWidth = 64,
posWidth = 32 posWidth = 32
}> }>
#Dense3D = #sparse_tensor.encoding<{ #Dense3D = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense", "dense" ], lvlTypes = [ "dense", "dense", "dense" ],
dimOrdering = affine_map<(i, j, k) -> (k, i, j)> dimOrdering = affine_map<(i, j, k) -> (k, i, j)>
}> }>
#Coo = #sparse_tensor.encoding<{ #Coo = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
#CooPNo = #sparse_tensor.encoding<{ #CooPNo = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton-no" ], lvlTypes = [ "compressed-nu", "singleton-no" ],
dimOrdering = affine_map<(i, j) -> (j, i)> dimOrdering = affine_map<(i, j) -> (j, i)>
}> }>
#ccoo = #sparse_tensor.encoding<{ #ccoo = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed-nu", "singleton" ] lvlTypes = [ "compressed", "compressed-nu", "singleton" ]
}> }>
// CHECK-LABEL: func @sparse_nop( // CHECK-LABEL: func @sparse_nop(
// CHECK-SAME: %[[A0:.*]]: memref<?xi32>, // CHECK-SAME: %[[A0:.*]]: memref<?xi32>,
// CHECK-SAME: %[[A1:.*]]: memref<?xi64>, // CHECK-SAME: %[[A1:.*]]: memref<?xi64>,
// CHECK-SAME: %[[A2:.*]]: memref<?xf64>, // CHECK-SAME: %[[A2:.*]]: memref<?xf64>,
// CHECK-SAME: %[[A3:.*]]: !sparse_tensor.storage_specifier // CHECK-SAME: %[[A3:.*]]: !sparse_tensor.storage_specifier
// CHECK: return %[[A0]], %[[A1]], %[[A2]], %[[A3]] : // CHECK: return %[[A0]], %[[A1]], %[[A2]], %[[A3]] :
▲ Show 20 Lines • Show All 607 Lines • ▼ Show 20 Lines
// CHECK: return %{{.*}}, %{{.*}}, %{{.*}}, %[[A4]] : // CHECK: return %{{.*}}, %{{.*}}, %{{.*}}, %[[A4]] :
// CHECK-SAME: memref<?xi32>, memref<?xi64>, memref<?xi32>, !sparse_tensor.storage_specifier // CHECK-SAME: memref<?xi32>, memref<?xi64>, memref<?xi32>, !sparse_tensor.storage_specifier
func.func @sparse_convert_element_type(%arg0: tensor<32xf32, #SparseVector>) -> tensor<?xi32, #SparseVector> { func.func @sparse_convert_element_type(%arg0: tensor<32xf32, #SparseVector>) -> tensor<?xi32, #SparseVector> {
%0 = sparse_tensor.convert %arg0 : tensor<32xf32, #SparseVector> to tensor<?xi32, #SparseVector> %0 = sparse_tensor.convert %arg0 : tensor<32xf32, #SparseVector> to tensor<?xi32, #SparseVector>
return %0 : tensor<?xi32, #SparseVector> return %0 : tensor<?xi32, #SparseVector>
} }
// CHECK-LABEL: func.func @sparse_new_coo( // CHECK-LABEL: func.func @sparse_new_coo(
// CHECK-SAME: %[[A0:.*]]: !llvm.ptr<i8>) -> (memref<?xindex>, memref<?xindex>, memref<?xf32>, !sparse_tensor.storage_specifier<#sparse_tensor.encoding<{ dimLevelType = [ "compressed", "singleton" ] }>>) { // CHECK-SAME: %[[A0:.*]]: !llvm.ptr<i8>) -> (memref<?xindex>, memref<?xindex>, memref<?xf32>, !sparse_tensor.storage_specifier<#sparse_tensor.encoding<{ lvlTypes = [ "compressed", "singleton" ] }>>) {
// CHECK-DAG: %[[A1:.*]] = arith.constant false // CHECK-DAG: %[[A1:.*]] = arith.constant false
// CHECK-DAG: %[[A2:.*]] = arith.constant 1 : index // CHECK-DAG: %[[A2:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[A3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[A3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[A4:.*]] = arith.constant 2 : index // CHECK-DAG: %[[A4:.*]] = arith.constant 2 : index
// CHECK: %[[A5:.*]] = call @createSparseTensorReader(%[[A0]]) // CHECK: %[[A5:.*]] = call @createSparseTensorReader(%[[A0]])
// CHECK: %[[A6:.*]] = memref.alloca() : memref<2xindex> // CHECK: %[[A6:.*]] = memref.alloca() : memref<2xindex>
// CHECK: %[[A7:.*]] = memref.cast %[[A6]] : memref<2xindex> to memref<?xindex> // CHECK: %[[A7:.*]] = memref.cast %[[A6]] : memref<2xindex> to memref<?xindex>
// CHECK: call @copySparseTensorReaderDimSizes(%[[A5]], %[[A7]]) : (!llvm.ptr<i8>, memref<?xindex>) -> () // CHECK: call @copySparseTensorReaderDimSizes(%[[A5]], %[[A7]]) : (!llvm.ptr<i8>, memref<?xindex>) -> ()
// CHECK: %[[A8:.*]] = memref.load %[[A6]]{{\[}}%[[A3]]] : memref<2xindex> // CHECK: %[[A8:.*]] = memref.load %[[A6]]{{\[}}%[[A3]]] : memref<2xindex>
// CHECK: %[[A9:.*]] = memref.load %[[A6]]{{\[}}%[[A2]]] : memref<2xindex> // CHECK: %[[A9:.*]] = memref.load %[[A6]]{{\[}}%[[A2]]] : memref<2xindex>
// CHECK: %[[A10:.*]] = call @getSparseTensorReaderNSE(%[[A5]]) // CHECK: %[[A10:.*]] = call @getSparseTensorReaderNSE(%[[A5]])
// CHECK: %[[A11:.*]] = arith.muli %[[A10]], %[[A4]] : index // CHECK: %[[A11:.*]] = arith.muli %[[A10]], %[[A4]] : index
// CHECK: %[[A12:.*]] = memref.alloc() : memref<2xindex> // CHECK: %[[A12:.*]] = memref.alloc() : memref<2xindex>
// CHECK: %[[A13:.*]] = memref.cast %[[A12]] : memref<2xindex> to memref<?xindex> // CHECK: %[[A13:.*]] = memref.cast %[[A12]] : memref<2xindex> to memref<?xindex>
// CHECK: %[[A14:.*]] = memref.alloc(%[[A11]]) : memref<?xindex> // CHECK: %[[A14:.*]] = memref.alloc(%[[A11]]) : memref<?xindex>
// CHECK: %[[A15:.*]] = memref.alloc(%[[A10]]) : memref<?xf32> // CHECK: %[[A15:.*]] = memref.alloc(%[[A10]]) : memref<?xf32>
// CHECK: %[[A16:.*]] = sparse_tensor.storage_specifier.init : !sparse_tensor.storage_specifier<#sparse_tensor.encoding<{ dimLevelType = [ "compressed", "singleton" ] }>> // CHECK: %[[A16:.*]] = sparse_tensor.storage_specifier.init : !sparse_tensor.storage_specifier<#sparse_tensor.encoding<{ lvlTypes = [ "compressed", "singleton" ] }>>
// CHECK: %[[A18:.*]] = sparse_tensor.storage_specifier.set %[[A16]] lvl_sz at 0 with %[[A8]] // CHECK: %[[A18:.*]] = sparse_tensor.storage_specifier.set %[[A16]] lvl_sz at 0 with %[[A8]]
// CHECK: %[[A19:.*]] = sparse_tensor.storage_specifier.get %[[A18]] pos_mem_sz at 0 // CHECK: %[[A19:.*]] = sparse_tensor.storage_specifier.get %[[A18]] pos_mem_sz at 0
// CHECK: %[[A21:.*]], %[[A22:.*]] = sparse_tensor.push_back %[[A19]], %[[A13]], %[[A3]] // CHECK: %[[A21:.*]], %[[A22:.*]] = sparse_tensor.push_back %[[A19]], %[[A13]], %[[A3]]
// CHECK: %[[A24:.*]] = sparse_tensor.storage_specifier.set %[[A18]] pos_mem_sz at 0 with %[[A22]] // CHECK: %[[A24:.*]] = sparse_tensor.storage_specifier.set %[[A18]] pos_mem_sz at 0 with %[[A22]]
// CHECK: %[[A26:.*]] = sparse_tensor.storage_specifier.set %[[A24]] lvl_sz at 1 with %[[A9]] // CHECK: %[[A26:.*]] = sparse_tensor.storage_specifier.set %[[A24]] lvl_sz at 1 with %[[A9]]
// CHECK: %[[A27:.*]], %[[A28:.*]] = sparse_tensor.push_back %[[A22]], %[[A21]], %[[A3]], %[[A2]] // CHECK: %[[A27:.*]], %[[A28:.*]] = sparse_tensor.push_back %[[A22]], %[[A21]], %[[A3]], %[[A2]]
// CHECK: %[[A30:.*]] = sparse_tensor.storage_specifier.set %[[A26]] pos_mem_sz at 0 with %[[A28]] // CHECK: %[[A30:.*]] = sparse_tensor.storage_specifier.set %[[A26]] pos_mem_sz at 0 with %[[A28]]
// CHECK: %[[A31:.*]] = memref.alloca() : memref<2xindex> // CHECK: %[[A31:.*]] = memref.alloca() : memref<2xindex>
Show All 11 Lines
// CHECK: call @delSparseTensorReader(%[[A5]]) : (!llvm.ptr<i8>) -> () // CHECK: call @delSparseTensorReader(%[[A5]]) : (!llvm.ptr<i8>) -> ()
// CHECK: return %[[A27]], %[[A14]], %[[A15]], %[[A38]] // CHECK: return %[[A27]], %[[A14]], %[[A15]], %[[A38]]
func.func @sparse_new_coo(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf32, #Coo> { func.func @sparse_new_coo(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf32, #Coo> {
%0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<?x?xf32, #Coo> %0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<?x?xf32, #Coo>
return %0 : tensor<?x?xf32, #Coo> return %0 : tensor<?x?xf32, #Coo>
} }
// CHECK-LABEL: func.func @sparse_new_coo_permute_no( // CHECK-LABEL: func.func @sparse_new_coo_permute_no(
// CHECK-SAME: %[[A0:.*]]: !llvm.ptr<i8>) -> (memref<?xindex>, memref<?xindex>, memref<?xf32>, !sparse_tensor.storage_specifier<#sparse_tensor.encoding<{ dimLevelType = [ "compressed", "singleton" ] }>>) { // CHECK-SAME: %[[A0:.*]]: !llvm.ptr<i8>) -> (memref<?xindex>, memref<?xindex>, memref<?xf32>, !sparse_tensor.storage_specifier<#sparse_tensor.encoding<{ lvlTypes = [ "compressed", "singleton" ] }>>) {
// CHECK-DAG: %[[A1:.*]] = arith.constant 1 : index // CHECK-DAG: %[[A1:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[A2:.*]] = arith.constant 0 : index // CHECK-DAG: %[[A2:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[A3:.*]] = arith.constant 2 : index // CHECK-DAG: %[[A3:.*]] = arith.constant 2 : index
// CHECK: %[[A4:.*]] = call @createSparseTensorReader(%[[A0]]) // CHECK: %[[A4:.*]] = call @createSparseTensorReader(%[[A0]])
// CHECK: %[[A5:.*]] = memref.alloca() : memref<2xindex> // CHECK: %[[A5:.*]] = memref.alloca() : memref<2xindex>
// CHECK: %[[A6:.*]] = memref.cast %[[A5]] : memref<2xindex> to memref<?xindex> // CHECK: %[[A6:.*]] = memref.cast %[[A5]] : memref<2xindex> to memref<?xindex>
// CHECK: call @copySparseTensorReaderDimSizes(%[[A4]], %[[A6]]) // CHECK: call @copySparseTensorReaderDimSizes(%[[A4]], %[[A6]])
// CHECK: %[[A7:.*]] = memref.load %[[A5]]{{\[}}%[[A2]]] : memref<2xindex> // CHECK: %[[A7:.*]] = memref.load %[[A5]]{{\[}}%[[A2]]] : memref<2xindex>
// CHECK: %[[A8:.*]] = memref.load %[[A5]]{{\[}}%[[A1]]] : memref<2xindex> // CHECK: %[[A8:.*]] = memref.load %[[A5]]{{\[}}%[[A1]]] : memref<2xindex>
// CHECK: %[[A9:.*]] = call @getSparseTensorReaderNSE(%[[A4]]) // CHECK: %[[A9:.*]] = call @getSparseTensorReaderNSE(%[[A4]])
// CHECK: %[[A10:.*]] = arith.muli %[[A9]], %[[A3]] : index // CHECK: %[[A10:.*]] = arith.muli %[[A9]], %[[A3]] : index
// CHECK: %[[A11:.*]] = memref.alloc() : memref<2xindex> // CHECK: %[[A11:.*]] = memref.alloc() : memref<2xindex>
// CHECK: %[[A12:.*]] = memref.cast %[[A11]] : memref<2xindex> to memref<?xindex> // CHECK: %[[A12:.*]] = memref.cast %[[A11]] : memref<2xindex> to memref<?xindex>
// CHECK: %[[A13:.*]] = memref.alloc(%[[A10]]) : memref<?xindex> // CHECK: %[[A13:.*]] = memref.alloc(%[[A10]]) : memref<?xindex>
// CHECK: %[[A14:.*]] = memref.alloc(%[[A9]]) : memref<?xf32> // CHECK: %[[A14:.*]] = memref.alloc(%[[A9]]) : memref<?xf32>
// CHECK: %[[A15:.*]] = sparse_tensor.storage_specifier.init : !sparse_tensor.storage_specifier<#sparse_tensor.encoding<{ dimLevelType = [ "compressed", "singleton" ] }>> // CHECK: %[[A15:.*]] = sparse_tensor.storage_specifier.init : !sparse_tensor.storage_specifier<#sparse_tensor.encoding<{ lvlTypes = [ "compressed", "singleton" ] }>>
// CHECK: %[[A17:.*]] = sparse_tensor.storage_specifier.set %[[A15]] lvl_sz at 0 with %[[A8]] // CHECK: %[[A17:.*]] = sparse_tensor.storage_specifier.set %[[A15]] lvl_sz at 0 with %[[A8]]
// CHECK: %[[A18:.*]] = sparse_tensor.storage_specifier.get %[[A17]] pos_mem_sz at 0 // CHECK: %[[A18:.*]] = sparse_tensor.storage_specifier.get %[[A17]] pos_mem_sz at 0
// CHECK: %[[A20:.*]], %[[A21:.*]] = sparse_tensor.push_back %[[A18]], %[[A12]], %[[A2]] // CHECK: %[[A20:.*]], %[[A21:.*]] = sparse_tensor.push_back %[[A18]], %[[A12]], %[[A2]]
// CHECK: %[[A23:.*]] = sparse_tensor.storage_specifier.set %[[A17]] pos_mem_sz at 0 with %[[A21]] // CHECK: %[[A23:.*]] = sparse_tensor.storage_specifier.set %[[A17]] pos_mem_sz at 0 with %[[A21]]
// CHECK: %[[A25:.*]] = sparse_tensor.storage_specifier.set %[[A23]] lvl_sz at 1 with %[[A7]] // CHECK: %[[A25:.*]] = sparse_tensor.storage_specifier.set %[[A23]] lvl_sz at 1 with %[[A7]]
// CHECK: %[[A26:.*]], %[[A27:.*]] = sparse_tensor.push_back %[[A21]], %[[A20]], %[[A2]], %[[A1]] // CHECK: %[[A26:.*]], %[[A27:.*]] = sparse_tensor.push_back %[[A21]], %[[A20]], %[[A2]], %[[A1]]
// CHECK: %[[A29:.*]] = sparse_tensor.storage_specifier.set %[[A25]] pos_mem_sz at 0 with %[[A27]] // CHECK: %[[A29:.*]] = sparse_tensor.storage_specifier.set %[[A25]] pos_mem_sz at 0 with %[[A27]]
// CHECK: %[[A30:.*]] = memref.alloca() : memref<2xindex> // CHECK: %[[A30:.*]] = memref.alloca() : memref<2xindex>
Show All 13 Lines

mlir/test/Dialect/SparseTensor/codegen_buffer_initialization.mlir

// RUN: mlir-opt %s --sparse-tensor-codegen=enable-buffer-initialization=true --canonicalize --cse | FileCheck %s // RUN: mlir-opt %s --sparse-tensor-codegen=enable-buffer-initialization=true --canonicalize --cse | FileCheck %s
#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
// CHECK-LABEL: func.func @sparse_alloc_sparse_vector( // CHECK-LABEL: func.func @sparse_alloc_sparse_vector(
// CHECK-SAME: %[[VAL_0:.*]]: index) -> (memref<?xindex>, memref<?xindex>, memref<?xf64>, !sparse_tensor.storage_specifier // CHECK-SAME: %[[VAL_0:.*]]: index) -> (memref<?xindex>, memref<?xindex>, memref<?xf64>, !sparse_tensor.storage_specifier
// CHECK: %[[VAL_1:.*]] = arith.constant 1 : index // CHECK: %[[VAL_1:.*]] = arith.constant 1 : index
// CHECK: %[[VAL_2:.*]] = arith.constant 0.000000e+00 : f64 // CHECK: %[[VAL_2:.*]] = arith.constant 0.000000e+00 : f64
// CHECK: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK: %[[VAL_4:.*]] = memref.alloc() : memref<16xindex> // CHECK: %[[VAL_4:.*]] = memref.alloc() : memref<16xindex>
// CHECK: %[[VAL_5:.*]] = memref.cast %[[VAL_4]] : memref<16xindex> to memref<?xindex> // CHECK: %[[VAL_5:.*]] = memref.cast %[[VAL_4]] : memref<16xindex> to memref<?xindex>
Show All 20 Lines

mlir/test/Dialect/SparseTensor/codegen_sparse_alloc.mlir

// RUN: mlir-opt %s --sparse-tensor-codegen --canonicalize --cse | FileCheck %s // RUN: mlir-opt %s --sparse-tensor-codegen --canonicalize --cse | FileCheck %s
#CSR = #sparse_tensor.encoding<{ dimLevelType = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{ lvlTypes = ["dense", "compressed"]}>
#COO = #sparse_tensor.encoding<{ dimLevelType = ["compressed-nu", "singleton"]}> #COO = #sparse_tensor.encoding<{ lvlTypes = ["compressed-nu", "singleton"]}>
// CHECK-LABEL: func.func @sparse_alloc_copy_CSR( // CHECK-LABEL: func.func @sparse_alloc_copy_CSR(
// CHECK-SAME: %[[VAL_0:.*0]]: memref<?xindex>, // CHECK-SAME: %[[VAL_0:.*0]]: memref<?xindex>,
// CHECK-SAME: %[[VAL_1:.*1]]: memref<?xindex>, // CHECK-SAME: %[[VAL_1:.*1]]: memref<?xindex>,
// CHECK-SAME: %[[VAL_2:.*2]]: memref<?xf32>, // CHECK-SAME: %[[VAL_2:.*2]]: memref<?xf32>,
// CHECK-SAME: %[[VAL_3:.*]]: !sparse_tensor.storage_specifier<#{{.*}}>) -> (memref<?xindex>, memref<?xindex>, memref<?xf32>, !sparse_tensor.storage_specifier<#{{.*}}>) { // CHECK-SAME: %[[VAL_3:.*]]: !sparse_tensor.storage_specifier<#{{.*}}>) -> (memref<?xindex>, memref<?xindex>, memref<?xf32>, !sparse_tensor.storage_specifier<#{{.*}}>) {
// CHECK: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK: %[[VAL_5:.*]] = memref.dim %[[VAL_0]], %[[VAL_4]] : memref<?xindex> // CHECK: %[[VAL_5:.*]] = memref.dim %[[VAL_0]], %[[VAL_4]] : memref<?xindex>
Show All 32 Lines

mlir/test/Dialect/SparseTensor/codegen_sparse_dealloc.mlir

// RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false" \ // RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false" \
// RUN: --sparse-tensor-codegen=create-sparse-deallocs=false \ // RUN: --sparse-tensor-codegen=create-sparse-deallocs=false \
// RUN: --canonicalize --cse | FileCheck %s -check-prefix=CHECK-NO-DEALLOC // RUN: --canonicalize --cse | FileCheck %s -check-prefix=CHECK-NO-DEALLOC
// RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false" \ // RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false" \
// RUN: --sparse-tensor-codegen=create-sparse-deallocs=true \ // RUN: --sparse-tensor-codegen=create-sparse-deallocs=true \
// RUN: --canonicalize --cse | FileCheck %s -check-prefix=CHECK-DEALLOC // RUN: --canonicalize --cse | FileCheck %s -check-prefix=CHECK-DEALLOC
#CSR = #sparse_tensor.encoding<{ dimLevelType = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{ lvlTypes = ["dense", "compressed"]}>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = ["dense", "compressed"], lvlTypes = ["dense", "compressed"],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
// //
// No memref.dealloc is user-requested so // No memref.dealloc is user-requested so
// CHECK-NO-DEALLOC-LABEL: @sparse_convert_permuted // CHECK-NO-DEALLOC-LABEL: @sparse_convert_permuted
// CHECK-NO-DEALLOC-NOT: memref.dealloc // CHECK-NO-DEALLOC-NOT: memref.dealloc
// //
// Otherwise memref.dealloc is created to free temporary sparse buffers. // Otherwise memref.dealloc is created to free temporary sparse buffers.
// CHECK-DEALLOC-LABEL: @sparse_convert_permuted // CHECK-DEALLOC-LABEL: @sparse_convert_permuted
// CHECK-DEALLOC: memref.dealloc // CHECK-DEALLOC: memref.dealloc
// //
func.func @sparse_convert_permuted(%arg0: tensor<?x?xf32, #CSR>) -> tensor<?x?xf32, #CSC> { func.func @sparse_convert_permuted(%arg0: tensor<?x?xf32, #CSR>) -> tensor<?x?xf32, #CSC> {
%0 = sparse_tensor.convert %arg0 : tensor<?x?xf32, #CSR> to tensor<?x?xf32, #CSC> %0 = sparse_tensor.convert %arg0 : tensor<?x?xf32, #CSR> to tensor<?x?xf32, #CSC>
return %0 : tensor<?x?xf32, #CSC> return %0 : tensor<?x?xf32, #CSC>
} }

mlir/test/Dialect/SparseTensor/codegen_to_llvm.mlir

// RUN: mlir-opt %s --sparse-tensor-codegen --sparse-storage-specifier-to-llvm | FileCheck %s // RUN: mlir-opt %s --sparse-tensor-codegen --sparse-storage-specifier-to-llvm | FileCheck %s
#SparseVector = #sparse_tensor.encoding<{ dimLevelType = ["compressed"] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = ["compressed"] }>
// CHECK-LABEL: func @sparse_nop( // CHECK-LABEL: func @sparse_nop(
// CHECK-SAME: %[[A0:.*0]]: memref<?xindex>, // CHECK-SAME: %[[A0:.*0]]: memref<?xindex>,
// CHECK-SAME: %[[A1:.*1]]: memref<?xindex>, // CHECK-SAME: %[[A1:.*1]]: memref<?xindex>,
// CHECK-SAME: %[[A2:.*2]]: memref<?xf64>, // CHECK-SAME: %[[A2:.*2]]: memref<?xf64>,
// CHECK-SAME: %[[A3:.*3]]: !llvm.struct<(array<1 x i64>, array<3 x i64>)>) // CHECK-SAME: %[[A3:.*3]]: !llvm.struct<(array<1 x i64>, array<3 x i64>)>)
// CHECK: return %[[A0]], %[[A1]], %[[A2]], %[[A3]] : // CHECK: return %[[A0]], %[[A1]], %[[A2]], %[[A3]] :
// CHECK-SAME: memref<?xindex>, memref<?xindex>, memref<?xf64>, !llvm.struct<(array<1 x i64>, array<3 x i64>)> // CHECK-SAME: memref<?xindex>, memref<?xindex>, memref<?xf64>, !llvm.struct<(array<1 x i64>, array<3 x i64>)>
func.func @sparse_nop(%arg0: tensor<?xf64, #SparseVector>) -> tensor<?xf64, #SparseVector> { func.func @sparse_nop(%arg0: tensor<?xf64, #SparseVector>) -> tensor<?xf64, #SparseVector> {
return %arg0 : tensor<?xf64, #SparseVector> return %arg0 : tensor<?xf64, #SparseVector>
} }

mlir/test/Dialect/SparseTensor/constant_index_map.mlir

// Reported by https://github.com/llvm/llvm-project/issues/61530 // Reported by https://github.com/llvm/llvm-project/issues/61530
// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#map1 = affine_map<(d0) -> (0, d0)> #map1 = affine_map<(d0) -> (0, d0)>
#map2 = affine_map<(d0) -> (d0)> #map2 = affine_map<(d0) -> (d0)>
#SpVec = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SpVec = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
// CHECK-LABEL: func.func @main( // CHECK-LABEL: func.func @main(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<1x77xi1>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<1x77xi1>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<1x77xi1>) -> tensor<77xi1, #{{.*}}> { // CHECK-SAME: %[[VAL_1:.*1]]: tensor<1x77xi1>) -> tensor<77xi1, #{{.*}}> {
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 77 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 77 : index
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = bufferization.alloc_tensor() : tensor<77xi1, #{{.*}}> // CHECK-DAG: %[[VAL_5:.*]] = bufferization.alloc_tensor() : tensor<77xi1, #{{.*}}>
Show All 25 Lines

mlir/test/Dialect/SparseTensor/conversion.mlir

// RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s // RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] lvlTypes = ["compressed"]
}> }>
#SparseVector64 = #sparse_tensor.encoding<{ #SparseVector64 = #sparse_tensor.encoding<{
dimLevelType = ["compressed"], lvlTypes = ["compressed"],
posWidth = 64, posWidth = 64,
crdWidth = 64 crdWidth = 64
}> }>
#SparseVector32 = #sparse_tensor.encoding<{ #SparseVector32 = #sparse_tensor.encoding<{
dimLevelType = ["compressed"], lvlTypes = ["compressed"],
posWidth = 32, posWidth = 32,
crdWidth = 32 crdWidth = 32
}> }>
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = ["dense", "compressed"] lvlTypes = ["dense", "compressed"]
}> }>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = ["dense", "compressed"], lvlTypes = ["dense", "compressed"],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
dimLevelType = ["dense", "compressed", "compressed"], lvlTypes = ["dense", "compressed", "compressed"],
dimOrdering = affine_map<(i,j,k) -> (k,i,j)> dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
}> }>
// CHECK-LABEL: func @sparse_nop( // CHECK-LABEL: func @sparse_nop(
// 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(%arg0: tensor<?xf64, #SparseVector>) -> tensor<?xf64, #SparseVector> { func.func @sparse_nop(%arg0: tensor<?xf64, #SparseVector>) -> tensor<?xf64, #SparseVector> {
return %arg0 : tensor<?xf64, #SparseVector> return %arg0 : tensor<?xf64, #SparseVector>
▲ Show 20 Lines • Show All 406 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/convert_dense2sparse.mlir

// RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s // RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s
// RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-foreach=false" \ // RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-foreach=false" \
// RUN: --canonicalize --cse | FileCheck %s --check-prefix=CHECK-RWT // RUN: --canonicalize --cse | FileCheck %s --check-prefix=CHECK-RWT
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] lvlTypes = ["compressed"]
}> }>
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = ["dense", "compressed"] lvlTypes = ["dense", "compressed"]
}> }>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i, j) -> (j, i)> dimOrdering = affine_map<(i, j) -> (j, i)>
}> }>
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
dimLevelType = ["dense", "compressed", "compressed"], lvlTypes = ["dense", "compressed", "compressed"],
dimOrdering = affine_map<(i,j,k) -> (k,i,j)> dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
}> }>
// CHECK-LABEL: func @sparse_convert_1d( // CHECK-LABEL: func @sparse_convert_1d(
// CHECK-SAME: %[[A:.*]]: tensor<?xi32>) -> !llvm.ptr<i8> { // CHECK-SAME: %[[A:.*]]: tensor<?xi32>) -> !llvm.ptr<i8> {
// CHECK-DAG: %[[EmptyCOO:.*]] = arith.constant 4 : i32 // CHECK-DAG: %[[EmptyCOO:.*]] = arith.constant 4 : i32
// CHECK-DAG: %[[FromCOO:.*]] = arith.constant 2 : i32 // CHECK-DAG: %[[FromCOO:.*]] = arith.constant 2 : i32
// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : i32 // CHECK-DAG: %[[I0:.*]] = arith.constant 0 : i32
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
// CHECK: call @addEltF64(%[[C]], %[[BUF]], %[[T]], %[[IotaP]]) // CHECK: call @addEltF64(%[[C]], %[[BUF]], %[[T]], %[[IotaP]])
// CHECK: } // CHECK: }
// CHECK: } // CHECK: }
// CHECK: %[[T:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[FromCOO]], %[[C]]) // CHECK: %[[T:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[FromCOO]], %[[C]])
// CHECK: call @delSparseTensorCOOF64(%[[C]]) // CHECK: call @delSparseTensorCOOF64(%[[C]])
// CHECK: return %[[T]] : !llvm.ptr<i8> // CHECK: return %[[T]] : !llvm.ptr<i8>
// CHECK-RWT-LABEL: func.func @sparse_convert_2d( // CHECK-RWT-LABEL: func.func @sparse_convert_2d(
// CHECK-RWT-SAME: %[[T0:.*]]: tensor<2x4xf64>) -> tensor<2x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> { // CHECK-RWT-SAME: %[[T0:.*]]: tensor<2x4xf64>) -> tensor<2x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> {
// CHECK-RWT: %[[T1:.*]] = bufferization.alloc_tensor() // CHECK-RWT: %[[T1:.*]] = bufferization.alloc_tensor()
// CHECK-RWT: %[[T2:.*]] = sparse_tensor.foreach in %[[T0]] init(%[[T1]]) // CHECK-RWT: %[[T2:.*]] = sparse_tensor.foreach in %[[T0]] init(%[[T1]])
// CHECK-RWT: ^bb0(%[[L0I0:.*]]: index, %[[L0I1:.*]]: index, %[[L0V:.*]]: f64, %[[L0T:.*]]: tensor // CHECK-RWT: ^bb0(%[[L0I0:.*]]: index, %[[L0I1:.*]]: index, %[[L0V:.*]]: f64, %[[L0T:.*]]: tensor
// CHECK-RWT: %[[CMP:.*]] = arith.cmpf une, %[[L0V]] // CHECK-RWT: %[[CMP:.*]] = arith.cmpf une, %[[L0V]]
// CHECK-RWT: %[[IFR:.*]] = scf.if %[[CMP]] // CHECK-RWT: %[[IFR:.*]] = scf.if %[[CMP]]
// CHECK-RWT: %[[L0T2:.*]] = sparse_tensor.insert %[[L0V]] into %[[L0T]]{{\[}}%[[L0I0]], %[[L0I1]]] // CHECK-RWT: %[[L0T2:.*]] = sparse_tensor.insert %[[L0V]] into %[[L0T]]{{\[}}%[[L0I0]], %[[L0I1]]]
// CHECK-RWT: scf.yield %[[L0T2]] // CHECK-RWT: scf.yield %[[L0T2]]
// CHECK-RWT: } else { // CHECK-RWT: } else {
Show All 34 Lines
// CHECK-DAG: %[[V:.*]] = tensor.extract %{{.*}}[%[[I]]] : tensor<2xf32> // CHECK-DAG: %[[V:.*]] = tensor.extract %{{.*}}[%[[I]]] : tensor<2xf32>
// CHECK: memref.store %[[V]], %[[BUF]][] : memref<f32> // CHECK: memref.store %[[V]], %[[BUF]][] : memref<f32>
// CHECK: call @addEltF32(%{{.*}}, %[[BUF]], %[[N]], %[[IotaP]]) // CHECK: call @addEltF32(%{{.*}}, %[[BUF]], %[[N]], %[[IotaP]])
// CHECK: } // CHECK: }
// CHECK: %[[T:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[FromCOO]], %[[C]]) // CHECK: %[[T:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[FromCOO]], %[[C]])
// CHECK: call @delSparseTensorCOOF32(%[[C]]) // CHECK: call @delSparseTensorCOOF32(%[[C]])
// CHECK: return %[[T]] : !llvm.ptr<i8> // CHECK: return %[[T]] : !llvm.ptr<i8>
// CHECK-RWT-LABEL: func.func @sparse_constant() -> tensor<8x7xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> { // CHECK-RWT-LABEL: func.func @sparse_constant() -> tensor<8x7xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> {
// CHECK-RWT: %[[F0:.*]] = arith.constant sparse<{{\[\[}}0, 0], [1, 6]], [1.000000e+00, 5.000000e+00]> : tensor<8x7xf32> // CHECK-RWT: %[[F0:.*]] = arith.constant sparse<{{\[\[}}0, 0], [1, 6]], [1.000000e+00, 5.000000e+00]> : tensor<8x7xf32>
// CHECK-RWT: %[[T0:.*]] = bufferization.alloc_tensor() // CHECK-RWT: %[[T0:.*]] = bufferization.alloc_tensor()
// CHECK-RWT: %[[T1:.*]] = sparse_tensor.foreach in %[[F0]] init(%[[T0]]) // CHECK-RWT: %[[T1:.*]] = sparse_tensor.foreach in %[[F0]] init(%[[T0]])
// CHECK-RWT: ^bb0(%[[L0I0:.*]]: index, %[[L0I1:.*]]: index, %[[L0V:.*]]: f32, %[[L0T:.*]]: tensor // CHECK-RWT: ^bb0(%[[L0I0:.*]]: index, %[[L0I1:.*]]: index, %[[L0V:.*]]: f32, %[[L0T:.*]]: tensor
// CHECK-RWT: %[[L0T2:.*]] = sparse_tensor.insert %[[L0V]] into %[[L0T]]{{\[}}%[[L0I0]], %[[L0I1]]] // CHECK-RWT: %[[L0T2:.*]] = sparse_tensor.insert %[[L0V]] into %[[L0T]]{{\[}}%[[L0I0]], %[[L0I1]]]
// CHECK-RWT: sparse_tensor.yield %[[L0T2]] // CHECK-RWT: sparse_tensor.yield %[[L0T2]]
// CHECK-RWT: } // CHECK-RWT: }
// CHECK-RWT: %[[R:.*]] = sparse_tensor.load %[[T1]] hasInserts // CHECK-RWT: %[[R:.*]] = sparse_tensor.load %[[T1]] hasInserts
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/convert_sparse2dense.mlir

// RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s // RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s
// RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-foreach=false" \ // RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-foreach=false" \
// RUN: --canonicalize --cse | FileCheck %s --check-prefix=CHECK-RWT // RUN: --canonicalize --cse | FileCheck %s --check-prefix=CHECK-RWT
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] lvlTypes = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = ["dense", "compressed"] lvlTypes = ["dense", "compressed"]
}> }>
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
dimLevelType = ["dense", "compressed", "compressed"], lvlTypes = ["dense", "compressed", "compressed"],
dimOrdering = affine_map<(i,j,k) -> (k,i,j)> dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
}> }>
// CHECK-LABEL: func @sparse_convert_1d( // CHECK-LABEL: func @sparse_convert_1d(
// CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<13xi32> // CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<13xi32>
// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index // CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[I13:.*]] = arith.constant 13 : index // CHECK-DAG: %[[I13:.*]] = arith.constant 13 : index
// CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8 // CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8
▲ Show 20 Lines • Show All 116 Lines • ▼ Show 20 Lines
// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64> // CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64>
// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<2x4xf64> // CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<2x4xf64>
// CHECK: scf.yield // CHECK: scf.yield
// CHECK: } // CHECK: }
// CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref<2x4xf64> // CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref<2x4xf64>
// CHECK: return %[[T]] : tensor<2x4xf64> // CHECK: return %[[T]] : tensor<2x4xf64>
// CHECK-RWT-LABEL: func.func @sparse_convert_2d( // CHECK-RWT-LABEL: func.func @sparse_convert_2d(
// CHECK-RWT-SAME: %[[A:.*]]: tensor<2x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>) -> tensor<2x4xf64> { // CHECK-RWT-SAME: %[[A:.*]]: tensor<2x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>) -> tensor<2x4xf64> {
// CHECK-RWT: %[[F0:.*]] = arith.constant 0.000000e+00 : f64 // CHECK-RWT: %[[F0:.*]] = arith.constant 0.000000e+00 : f64
// CHECK-RWT: %[[B:.*]] = memref.alloc() : memref<2x4xf64> // CHECK-RWT: %[[B:.*]] = memref.alloc() : memref<2x4xf64>
// CHECK-RWT: linalg.fill ins(%[[F0]] : f64) outs(%[[B]] // CHECK-RWT: linalg.fill ins(%[[F0]] : f64) outs(%[[B]]
// CHECK-RWT: sparse_tensor.foreach in %[[A]] // CHECK-RWT: sparse_tensor.foreach in %[[A]]
// CHECK-RWT: ^bb0(%[[FI0:.*]]: index, %[[FI1:.*]]: index, %[[FV:.*]]: f64): // CHECK-RWT: ^bb0(%[[FI0:.*]]: index, %[[FI1:.*]]: index, %[[FV:.*]]: f64):
// CHECK-RWT: memref.store %[[FV]], %[[B]]{{\[}}%[[FI0]], %[[FI1]]] // CHECK-RWT: memref.store %[[FV]], %[[B]]{{\[}}%[[FI0]], %[[FI1]]]
// CHECK-RWT: } // CHECK-RWT: }
// CHECK-RWT: %[[T:.*]] = bufferization.to_tensor %[[B]] // CHECK-RWT: %[[T:.*]] = bufferization.to_tensor %[[B]]
▲ Show 20 Lines • Show All 139 Lines • ▼ Show 20 Lines
// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64> // CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64>
// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<?x?xf64> // CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<?x?xf64>
// CHECK: scf.yield // CHECK: scf.yield
// CHECK: } // CHECK: }
// CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref<?x?xf64> // CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref<?x?xf64>
// CHECK: return %[[T]] : tensor<?x?xf64> // CHECK: return %[[T]] : tensor<?x?xf64>
// CHECK-RWT-LABEL: func.func @sparse_convert_2d_dyn2( // CHECK-RWT-LABEL: func.func @sparse_convert_2d_dyn2(
// CHECK-RWT-SAME: %[[A:.*]]: tensor<?x?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>) -> tensor<?x?xf64> { // CHECK-RWT-SAME: %[[A:.*]]: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>) -> tensor<?x?xf64> {
// CHECK-RWT-DAG: %[[C0:.*]] = arith.constant 0 : index // CHECK-RWT-DAG: %[[C0:.*]] = arith.constant 0 : index
// CHECK-RWT-DAG: %[[C1:.*]] = arith.constant 1 : index // CHECK-RWT-DAG: %[[C1:.*]] = arith.constant 1 : index
// CHECK-RWT-DAG: %[[F0:.*]] = arith.constant 0.000000e+00 : f64 // CHECK-RWT-DAG: %[[F0:.*]] = arith.constant 0.000000e+00 : f64
// CHECK-RWT: %[[D0:.*]] = tensor.dim %[[A]], %[[C0]] // CHECK-RWT: %[[D0:.*]] = tensor.dim %[[A]], %[[C0]]
// CHECK-RWT: %[[D1:.*]] = tensor.dim %[[A]], %[[C1]] // CHECK-RWT: %[[D1:.*]] = tensor.dim %[[A]], %[[C1]]
// CHECK-RWT: %[[B:.*]] = memref.alloc(%[[D0]], %[[D1]]) // CHECK-RWT: %[[B:.*]] = memref.alloc(%[[D0]], %[[D1]])
// CHECK-RWT: linalg.fill ins(%[[F0]] : f64) outs(%[[B]] // CHECK-RWT: linalg.fill ins(%[[F0]] : f64) outs(%[[B]]
// CHECK-RWT: sparse_tensor.foreach in %[[A]] // CHECK-RWT: sparse_tensor.foreach in %[[A]]
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/convert_sparse2sparse.mlir

// First use with `kViaCOO` for sparse2sparse conversion (the old way). // First use with `kViaCOO` for sparse2sparse conversion (the old way).
// RUN: mlir-opt %s --sparse-tensor-conversion="s2s-strategy=1" \ // RUN: mlir-opt %s --sparse-tensor-conversion="s2s-strategy=1" \
// RUN: --canonicalize --cse | FileCheck %s -check-prefix=CHECK-COO // RUN: --canonicalize --cse | FileCheck %s -check-prefix=CHECK-COO
// //
// Now again with `kAuto` (the new default). // Now again with `kAuto` (the new default).
// RUN: mlir-opt %s --sparse-tensor-conversion="s2s-strategy=0" \ // RUN: mlir-opt %s --sparse-tensor-conversion="s2s-strategy=0" \
// RUN: --canonicalize --cse | FileCheck %s -check-prefixes=CHECK-AUTO,CHECK // RUN: --canonicalize --cse | FileCheck %s -check-prefixes=CHECK-AUTO,CHECK
// RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-foreach=false" \ // RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-foreach=false" \
// RUN: --canonicalize --cse | FileCheck %s --check-prefix=CHECK-RWT // RUN: --canonicalize --cse | FileCheck %s --check-prefix=CHECK-RWT
#SparseVector64 = #sparse_tensor.encoding<{ #SparseVector64 = #sparse_tensor.encoding<{
dimLevelType = ["compressed"], lvlTypes = ["compressed"],
posWidth = 64, posWidth = 64,
crdWidth = 64 crdWidth = 64
}> }>
#SparseVector32 = #sparse_tensor.encoding<{ #SparseVector32 = #sparse_tensor.encoding<{
dimLevelType = ["compressed"], lvlTypes = ["compressed"],
posWidth = 32, posWidth = 32,
crdWidth = 32 crdWidth = 32
}> }>
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] lvlTypes = ["compressed"]
}> }>
#SortedCOO2D = #sparse_tensor.encoding<{ #SortedCOO2D = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ], lvlTypes = [ "compressed-nu", "singleton" ],
}> }>
#SortedCOO3D = #sparse_tensor.encoding<{ #SortedCOO3D = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ]
}> }>
#TsssPermuted = #sparse_tensor.encoding<{ #TsssPermuted = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (k,i,j)> dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
}> }>
#COOSlice = #sparse_tensor.encoding<{ #COOSlice = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ], lvlTypes = [ "compressed-nu", "singleton" ],
slice = [ (2, 2, 1), (12, 13, 1) ] slice = [ (2, 2, 1), (12, 13, 1) ]
}> }>
// 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 58 Lines • ▼ Show 20 Lines
// CHECK-AUTO: return %[[T]] : !llvm.ptr<i8> // CHECK-AUTO: return %[[T]] : !llvm.ptr<i8>
func.func @sparse_convert(%arg0: tensor<?xf32, #SparseVector64>) -> tensor<?xf32, #SparseVector32> { func.func @sparse_convert(%arg0: tensor<?xf32, #SparseVector64>) -> tensor<?xf32, #SparseVector32> {
%0 = sparse_tensor.convert %arg0 : tensor<?xf32, #SparseVector64> to tensor<?xf32, #SparseVector32> %0 = sparse_tensor.convert %arg0 : tensor<?xf32, #SparseVector64> to tensor<?xf32, #SparseVector32>
return %0 : tensor<?xf32, #SparseVector32> return %0 : tensor<?xf32, #SparseVector32>
} }
#SparseSingleton64 = #sparse_tensor.encoding<{ #SparseSingleton64 = #sparse_tensor.encoding<{
dimLevelType = ["singleton"], lvlTypes = ["singleton"],
posWidth = 64, posWidth = 64,
crdWidth = 64 crdWidth = 64
}> }>
#SparseSingleton32 = #sparse_tensor.encoding<{ #SparseSingleton32 = #sparse_tensor.encoding<{
dimLevelType = ["singleton"], lvlTypes = ["singleton"],
posWidth = 32, posWidth = 32,
crdWidth = 32 crdWidth = 32
}> }>
// CHECK-COO-LABEL: func @sparse_convert_singleton( // CHECK-COO-LABEL: func @sparse_convert_singleton(
// CHECK-COO-SAME: %[[A:.*]]: !llvm.ptr<i8>) // CHECK-COO-SAME: %[[A:.*]]: !llvm.ptr<i8>)
// CHECK-COO-DAG: %[[ToCOO:.*]] = arith.constant 5 : i32 // CHECK-COO-DAG: %[[ToCOO:.*]] = arith.constant 5 : i32
// CHECK-COO-DAG: %[[FromCOO:.*]] = arith.constant 2 : i32 // CHECK-COO-DAG: %[[FromCOO:.*]] = arith.constant 2 : i32
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/convert_sparse2sparse_element.mlir

// RUN: mlir-opt %s --sparse-tensor-codegen --canonicalize --cse | FileCheck %s // RUN: mlir-opt %s --sparse-tensor-codegen --canonicalize --cse | FileCheck %s
#SparseVector64 = #sparse_tensor.encoding<{ #SparseVector64 = #sparse_tensor.encoding<{
dimLevelType = ["compressed"], lvlTypes = ["compressed"],
posWidth = 64, posWidth = 64,
crdWidth = 64 crdWidth = 64
}> }>
#SparseVector32 = #sparse_tensor.encoding<{ #SparseVector32 = #sparse_tensor.encoding<{
dimLevelType = ["compressed"], lvlTypes = ["compressed"],
posWidth = 32, posWidth = 32,
crdWidth = 32 crdWidth = 32
}> }>
// CHECK-LABEL: func.func @sparse_convert( // CHECK-LABEL: func.func @sparse_convert(
// CHECK-SAME: %[[VAL_0:.*0]]: memref<?xi64>, // CHECK-SAME: %[[VAL_0:.*0]]: memref<?xi64>,
// CHECK-SAME: %[[VAL_1:.*1]]: memref<?xi64>, // CHECK-SAME: %[[VAL_1:.*1]]: memref<?xi64>,
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/dense.mlir

// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
// Test to demonstrate the difference between non-annotated dense tensors // Test to demonstrate the difference between non-annotated dense tensors
// and all-dense-annotated "sparse" tensors. The former class remains as // and all-dense-annotated "sparse" tensors. The former class remains as
// two-dimensional tensors that are bufferized by subsequent passes. The // two-dimensional tensors that are bufferized by subsequent passes. The
// latter class is linearized into one-dimensional buffers that are backed // latter class is linearized into one-dimensional buffers that are backed
// by the runtime support library. // by the runtime support library.
#DenseMatrix = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense" ] }> #DenseMatrix = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ] }>
#trait_2d = { #trait_2d = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
doc = "X(i,j) = A(i,j) + 1" doc = "X(i,j) = A(i,j) + 1"
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/fold.mlir

// RUN: mlir-opt %s --canonicalize --cse | FileCheck %s // RUN: mlir-opt %s --canonicalize --cse | FileCheck %s
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
// CHECK-LABEL: func @sparse_nop_dense2dense_convert( // CHECK-LABEL: func @sparse_nop_dense2dense_convert(
// CHECK-SAME: %[[A:.*]]: tensor<64xf32>) // CHECK-SAME: %[[A:.*]]: tensor<64xf32>)
// CHECK-NOT: sparse_tensor.convert // CHECK-NOT: sparse_tensor.convert
// CHECK: return %[[A]] : tensor<64xf32> // CHECK: return %[[A]] : tensor<64xf32>
func.func @sparse_nop_dense2dense_convert(%arg0: tensor<64xf32>) -> tensor<64xf32> { func.func @sparse_nop_dense2dense_convert(%arg0: tensor<64xf32>) -> tensor<64xf32> {
%0 = sparse_tensor.convert %arg0 : tensor<64xf32> to tensor<64xf32> %0 = sparse_tensor.convert %arg0 : tensor<64xf32> to tensor<64xf32>
return %0 : tensor<64xf32> return %0 : tensor<64xf32>
▲ Show 20 Lines • Show All 53 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>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"], crdWidth=32}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"], crdWidth=32}>
func.func @non_static_pack_ret(%values: tensor<6xf64>, %coordinates: tensor<6x1xi32>) func.func @non_static_pack_ret(%values: tensor<6xf64>, %coordinates: tensor<6x1xi32>)
-> tensor<?xf64, #SparseVector> { -> tensor<?xf64, #SparseVector> {
// expected-error@+1 {{the sparse-tensor must have static shape}} // expected-error@+1 {{the sparse-tensor must have static shape}}
%0 = sparse_tensor.pack %values, %coordinates %0 = sparse_tensor.pack %values, %coordinates
: tensor<6xf64>, tensor<6x1xi32> to tensor<?xf64, #SparseVector> : tensor<6xf64>, tensor<6x1xi32> to tensor<?xf64, #SparseVector>
return %0 : tensor<?xf64, #SparseVector> return %0 : tensor<?xf64, #SparseVector>
} }
// ----- // -----
#DenseVector = #sparse_tensor.encoding<{dimLevelType = ["dense"], crdWidth=32}> #DenseVector = #sparse_tensor.encoding<{lvlTypes = ["dense"], crdWidth=32}>
func.func @invalid_pack_dense(%values: tensor<6xf64>, %coordinates: tensor<6x1xi32>) func.func @invalid_pack_dense(%values: tensor<6xf64>, %coordinates: tensor<6x1xi32>)
-> tensor<100xf64, #DenseVector> { -> tensor<100xf64, #DenseVector> {
// expected-error@+1 {{the sparse-tensor must have a COO type}} // expected-error@+1 {{the sparse-tensor must have a COO type}}
%0 = sparse_tensor.pack %values, %coordinates %0 = sparse_tensor.pack %values, %coordinates
: tensor<6xf64>, tensor<6x1xi32> to tensor<100xf64, #DenseVector> : tensor<6xf64>, tensor<6x1xi32> to tensor<100xf64, #DenseVector>
return %0 : tensor<100xf64, #DenseVector> return %0 : tensor<100xf64, #DenseVector>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"], crdWidth=32}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"], crdWidth=32}>
func.func @invalid_pack_data(%values: tensor<6x1xf64>, %coordinates: tensor<6x1xi32>) func.func @invalid_pack_data(%values: tensor<6x1xf64>, %coordinates: tensor<6x1xi32>)
-> tensor<100xf64, #SparseVector> { -> tensor<100xf64, #SparseVector> {
// expected-error@+1 {{values must have rank 1 + batched_lvls}} // expected-error@+1 {{values must have rank 1 + batched_lvls}}
%0 = sparse_tensor.pack %values, %coordinates %0 = sparse_tensor.pack %values, %coordinates
: tensor<6x1xf64>, tensor<6x1xi32> to tensor<100xf64, #SparseVector> : tensor<6x1xf64>, tensor<6x1xi32> to tensor<100xf64, #SparseVector>
return %0 : tensor<100xf64, #SparseVector> return %0 : tensor<100xf64, #SparseVector>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"], crdWidth=32}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"], crdWidth=32}>
func.func @invalid_pack_type(%values: tensor<6xf64>, %coordinates: tensor<6x1xi32>) func.func @invalid_pack_type(%values: tensor<6xf64>, %coordinates: tensor<6x1xi32>)
-> tensor<100xf32, #SparseVector> { -> tensor<100xf32, #SparseVector> {
// expected-error@+1 {{input/output element-types don't match}} // expected-error@+1 {{input/output element-types don't match}}
%0 = sparse_tensor.pack %values, %coordinates %0 = sparse_tensor.pack %values, %coordinates
: tensor<6xf64>, tensor<6x1xi32> to tensor<100xf32, #SparseVector> : tensor<6xf64>, tensor<6x1xi32> to tensor<100xf32, #SparseVector>
return %0 : tensor<100xf32, #SparseVector> return %0 : tensor<100xf32, #SparseVector>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"], crdWidth=32}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"], crdWidth=32}>
func.func @invalid_pack_type(%values: tensor<5xf64>, %coordinates: tensor<6x1xi32>) func.func @invalid_pack_type(%values: tensor<5xf64>, %coordinates: tensor<6x1xi32>)
-> tensor<100xf64, #SparseVector> { -> tensor<100xf64, #SparseVector> {
// expected-error@+1 {{values/coordinates number-of-elements don't match}} // expected-error@+1 {{values/coordinates number-of-elements don't match}}
%0 = sparse_tensor.pack %values, %coordinates %0 = sparse_tensor.pack %values, %coordinates
: tensor<5xf64>, tensor<6x1xi32> to tensor<100xf64, #SparseVector> : tensor<5xf64>, tensor<6x1xi32> to tensor<100xf64, #SparseVector>
return %0 : tensor<100xf64, #SparseVector> return %0 : tensor<100xf64, #SparseVector>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"], crdWidth=32}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"], crdWidth=32}>
func.func @invalid_pack_type(%values: tensor<6xf64>, %coordinates: tensor<6x2xi32>) func.func @invalid_pack_type(%values: tensor<6xf64>, %coordinates: tensor<6x2xi32>)
-> tensor<100xf64, #SparseVector> { -> tensor<100xf64, #SparseVector> {
// expected-error@+1 {{input/output level-ranks don't match}} // expected-error@+1 {{input/output level-ranks don't match}}
%0 = sparse_tensor.pack %values, %coordinates %0 = sparse_tensor.pack %values, %coordinates
: tensor<6xf64>, tensor<6x2xi32> to tensor<100xf64, #SparseVector> : tensor<6xf64>, tensor<6x2xi32> to tensor<100xf64, #SparseVector>
return %0 : tensor<100xf64, #SparseVector> return %0 : tensor<100xf64, #SparseVector>
} }
// ----- // -----
#BCOO = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed-hi"], crdWidth=32}> #BCOO = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed-hi"], crdWidth=32}>
func.func @invalid_pack_batched(%values: tensor<2x6xf64>, %coordinates: tensor<3x6x1xi32>) func.func @invalid_pack_batched(%values: tensor<2x6xf64>, %coordinates: tensor<3x6x1xi32>)
-> tensor<2x100xf64, #BCOO> { -> tensor<2x100xf64, #BCOO> {
// expected-error@+1 {{values/coordinates batched level sizes don't match statically}} // expected-error@+1 {{values/coordinates batched level sizes don't match statically}}
%0 = sparse_tensor.pack %values, %coordinates batched_lvls=1 %0 = sparse_tensor.pack %values, %coordinates batched_lvls=1
: tensor<2x6xf64>, tensor<3x6x1xi32> to tensor<2x100xf64, #BCOO> : tensor<2x6xf64>, tensor<3x6x1xi32> to tensor<2x100xf64, #BCOO>
return %0 : tensor<2x100xf64, #BCOO> return %0 : tensor<2x100xf64, #BCOO>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"], crdWidth=32}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"], crdWidth=32}>
func.func @invalid_unpack_type(%sp: tensor<100xf32, #SparseVector>) func.func @invalid_unpack_type(%sp: tensor<100xf32, #SparseVector>)
-> (tensor<6xf64>, tensor<6x1xi32>, i32) { -> (tensor<6xf64>, tensor<6x1xi32>, i32) {
// expected-error@+1 {{input/output element-types don't match}} // expected-error@+1 {{input/output element-types don't match}}
%values, %coordinates, %nse = sparse_tensor.unpack %sp %values, %coordinates, %nse = sparse_tensor.unpack %sp
: tensor<100xf32, #SparseVector> to tensor<6xf64>, tensor<6x1xi32>, i32 : tensor<100xf32, #SparseVector> to tensor<6xf64>, tensor<6x1xi32>, i32
return %values, %coordinates, %nse : tensor<6xf64>, tensor<6x1xi32>, i32 return %values, %coordinates, %nse : tensor<6xf64>, tensor<6x1xi32>, i32
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"], crdWidth=32}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"], crdWidth=32}>
func.func @invalid_unpack_type(%sp: tensor<100xf32, #SparseVector>) func.func @invalid_unpack_type(%sp: tensor<100xf32, #SparseVector>)
-> (tensor<5xf32>, tensor<6x1xi32>, i32) { -> (tensor<5xf32>, tensor<6x1xi32>, i32) {
// expected-error@+1 {{values/coordinates number-of-elements don't match}} // expected-error@+1 {{values/coordinates number-of-elements don't match}}
%values, %coordinates, %nse = sparse_tensor.unpack %sp %values, %coordinates, %nse = sparse_tensor.unpack %sp
: tensor<100xf32, #SparseVector> to tensor<5xf32>, tensor<6x1xi32>, i32 : tensor<100xf32, #SparseVector> to tensor<5xf32>, tensor<6x1xi32>, i32
return %values, %coordinates, %nse : tensor<5xf32>, tensor<6x1xi32>, i32 return %values, %coordinates, %nse : tensor<5xf32>, tensor<6x1xi32>, i32
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"], crdWidth=32}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"], crdWidth=32}>
func.func @invalid_unpack_type(%sp: tensor<100xf32, #SparseVector>) func.func @invalid_unpack_type(%sp: tensor<100xf32, #SparseVector>)
-> (tensor<6xf32>, tensor<6x2xi32>, i32) { -> (tensor<6xf32>, tensor<6x2xi32>, i32) {
// expected-error@+1 {{input/output level-ranks don't match}} // expected-error@+1 {{input/output level-ranks don't match}}
%values, %coordinates, %nse = sparse_tensor.unpack %sp %values, %coordinates, %nse = sparse_tensor.unpack %sp
: tensor<100xf32, #SparseVector> to tensor<6xf32>, tensor<6x2xi32>, i32 : tensor<100xf32, #SparseVector> to tensor<6xf32>, tensor<6x2xi32>, i32
return %values, %coordinates, %nse : tensor<6xf32>, tensor<6x2xi32>, i32 return %values, %coordinates, %nse : tensor<6xf32>, tensor<6x2xi32>, i32
} }
// ----- // -----
#BCOO = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed-hi"], crdWidth=32}> #BCOO = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed-hi"], crdWidth=32}>
func.func @invalid_unpack_type(%sp: tensor<2x100xf32, #BCOO>) func.func @invalid_unpack_type(%sp: tensor<2x100xf32, #BCOO>)
-> (tensor<2x6xf32>, tensor<3x6x2xi32>, i32) { -> (tensor<2x6xf32>, tensor<3x6x2xi32>, i32) {
// expected-error@+1 {{values/coordinates batched level sizes don't match statically}} // expected-error@+1 {{values/coordinates batched level sizes don't match statically}}
%values, %coordinates, %nse = sparse_tensor.unpack %sp batched_lvls=1 %values, %coordinates, %nse = sparse_tensor.unpack %sp batched_lvls=1
: tensor<2x100xf32, #BCOO> to tensor<2x6xf32>, tensor<3x6x2xi32>, i32 : tensor<2x100xf32, #BCOO> to tensor<2x6xf32>, tensor<3x6x2xi32>, i32
return %values, %coordinates, %nse : tensor<2x6xf32>, tensor<3x6x2xi32>, i32 return %values, %coordinates, %nse : tensor<2x6xf32>, tensor<3x6x2xi32>, i32
} }
Show All 11 Lines
func.func @invalid_positions_unranked(%arg0: tensor<*xf64>) -> memref<?xindex> { func.func @invalid_positions_unranked(%arg0: tensor<*xf64>) -> memref<?xindex> {
// expected-error@+1 {{'sparse_tensor.positions' op operand #0 must be sparse tensor of any type values, but got 'tensor<*xf64>'}} // expected-error@+1 {{'sparse_tensor.positions' op operand #0 must be sparse tensor of any type values, but got 'tensor<*xf64>'}}
%0 = sparse_tensor.positions %arg0 { level = 0 : index } : tensor<*xf64> to memref<?xindex> %0 = sparse_tensor.positions %arg0 { level = 0 : index } : tensor<*xf64> to memref<?xindex>
return %0 : memref<?xindex> return %0 : memref<?xindex>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"], posWidth=32}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"], posWidth=32}>
func.func @mismatch_positions_types(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xindex> { func.func @mismatch_positions_types(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xindex> {
// expected-error@+1 {{unexpected type for positions}} // expected-error@+1 {{unexpected type for positions}}
%0 = sparse_tensor.positions %arg0 { level = 0 : index } : tensor<128xf64, #SparseVector> to memref<?xindex> %0 = sparse_tensor.positions %arg0 { level = 0 : index } : tensor<128xf64, #SparseVector> to memref<?xindex>
return %0 : memref<?xindex> return %0 : memref<?xindex>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
func.func @positions_oob(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xindex> { func.func @positions_oob(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xindex> {
// expected-error@+1 {{requested level is out of bounds}} // expected-error@+1 {{requested level is out of bounds}}
%0 = sparse_tensor.positions %arg0 { level = 1 : index } : tensor<128xf64, #SparseVector> to memref<?xindex> %0 = sparse_tensor.positions %arg0 { level = 1 : index } : tensor<128xf64, #SparseVector> to memref<?xindex>
return %0 : memref<?xindex> return %0 : memref<?xindex>
} }
// ----- // -----
Show All 9 Lines
func.func @invalid_indices_unranked(%arg0: tensor<*xf64>) -> memref<?xindex> { func.func @invalid_indices_unranked(%arg0: tensor<*xf64>) -> memref<?xindex> {
// expected-error@+1 {{'sparse_tensor.coordinates' op operand #0 must be sparse tensor of any type values, but got 'tensor<*xf64>'}} // expected-error@+1 {{'sparse_tensor.coordinates' op operand #0 must be sparse tensor of any type values, but got 'tensor<*xf64>'}}
%0 = sparse_tensor.coordinates %arg0 { level = 0 : index } : tensor<*xf64> to memref<?xindex> %0 = sparse_tensor.coordinates %arg0 { level = 0 : index } : tensor<*xf64> to memref<?xindex>
return %0 : memref<?xindex> return %0 : memref<?xindex>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
func.func @mismatch_indices_types(%arg0: tensor<?xf64, #SparseVector>) -> memref<?xi32> { func.func @mismatch_indices_types(%arg0: tensor<?xf64, #SparseVector>) -> memref<?xi32> {
// expected-error@+1 {{unexpected type for coordinates}} // expected-error@+1 {{unexpected type for coordinates}}
%0 = sparse_tensor.coordinates %arg0 { level = 0 : index } : tensor<?xf64, #SparseVector> to memref<?xi32> %0 = sparse_tensor.coordinates %arg0 { level = 0 : index } : tensor<?xf64, #SparseVector> to memref<?xi32>
return %0 : memref<?xi32> return %0 : memref<?xi32>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
func.func @indices_oob(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xindex> { func.func @indices_oob(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xindex> {
// expected-error@+1 {{requested level is out of bounds}} // expected-error@+1 {{requested level is out of bounds}}
%0 = sparse_tensor.coordinates %arg0 { level = 1 : index } : tensor<128xf64, #SparseVector> to memref<?xindex> %0 = sparse_tensor.coordinates %arg0 { level = 1 : index } : tensor<128xf64, #SparseVector> to memref<?xindex>
return %0 : memref<?xindex> return %0 : memref<?xindex>
} }
// ----- // -----
func.func @invalid_values_dense(%arg0: tensor<1024xf32>) -> memref<?xf32> { func.func @invalid_values_dense(%arg0: tensor<1024xf32>) -> memref<?xf32> {
// expected-error@+1 {{'sparse_tensor.values' op operand #0 must be sparse tensor of any type values, but got 'tensor<1024xf32>'}} // expected-error@+1 {{'sparse_tensor.values' op operand #0 must be sparse tensor of any type values, but got 'tensor<1024xf32>'}}
%0 = sparse_tensor.values %arg0 : tensor<1024xf32> to memref<?xf32> %0 = sparse_tensor.values %arg0 : tensor<1024xf32> to memref<?xf32>
return %0 : memref<?xf32> return %0 : memref<?xf32>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
func.func @indices_buffer_noncoo(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xindex> { func.func @indices_buffer_noncoo(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xindex> {
// expected-error@+1 {{expected sparse tensor with a COO region}} // expected-error@+1 {{expected sparse tensor with a COO region}}
%0 = sparse_tensor.coordinates_buffer %arg0 : tensor<128xf64, #SparseVector> to memref<?xindex> %0 = sparse_tensor.coordinates_buffer %arg0 : tensor<128xf64, #SparseVector> to memref<?xindex>
return %0 : memref<?xindex> return %0 : memref<?xindex>
} }
// ----- // -----
func.func @indices_buffer_dense(%arg0: tensor<1024xf32>) -> memref<?xindex> { func.func @indices_buffer_dense(%arg0: tensor<1024xf32>) -> memref<?xindex> {
// expected-error@+1 {{must be sparse tensor of any type values}} // expected-error@+1 {{must be sparse tensor of any type values}}
%0 = sparse_tensor.coordinates_buffer %arg0 : tensor<1024xf32> to memref<?xindex> %0 = sparse_tensor.coordinates_buffer %arg0 : tensor<1024xf32> to memref<?xindex>
return %0 : memref<?xindex> return %0 : memref<?xindex>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
func.func @mismatch_values_types(%arg0: tensor<?xf64, #SparseVector>) -> memref<?xf32> { func.func @mismatch_values_types(%arg0: tensor<?xf64, #SparseVector>) -> memref<?xf32> {
// expected-error@+1 {{unexpected mismatch in element types}} // expected-error@+1 {{unexpected mismatch in element types}}
%0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf32> %0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf32>
return %0 : memref<?xf32> return %0 : memref<?xf32>
} }
// ----- // -----
#CSR_SLICE = #sparse_tensor.encoding<{ #CSR_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (1, 4, 1), (1, 4, 2) ] slice = [ (1, 4, 1), (1, 4, 2) ]
}> }>
func.func @sparse_slice_offset(%arg0: tensor<2x8xf64, #CSR_SLICE>) -> index { func.func @sparse_slice_offset(%arg0: tensor<2x8xf64, #CSR_SLICE>) -> index {
// expected-error@+1 {{requested dimension out of bound}} // expected-error@+1 {{requested dimension out of bound}}
%0 = sparse_tensor.slice.offset %arg0 at 2 : tensor<2x8xf64, #CSR_SLICE> %0 = sparse_tensor.slice.offset %arg0 at 2 : tensor<2x8xf64, #CSR_SLICE>
return %0 : index return %0 : index
} }
// ----- // -----
#CSR_SLICE = #sparse_tensor.encoding<{ #CSR_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (1, 4, 1), (1, 4, 2) ] slice = [ (1, 4, 1), (1, 4, 2) ]
}> }>
func.func @sparse_slice_stride(%arg0: tensor<2x8xf64, #CSR_SLICE>) -> index { func.func @sparse_slice_stride(%arg0: tensor<2x8xf64, #CSR_SLICE>) -> index {
// expected-error@+1 {{requested dimension out of bound}} // expected-error@+1 {{requested dimension out of bound}}
%0 = sparse_tensor.slice.stride %arg0 at 2 : tensor<2x8xf64, #CSR_SLICE> %0 = sparse_tensor.slice.stride %arg0 at 2 : tensor<2x8xf64, #CSR_SLICE>
return %0 : index return %0 : index
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>) -> index { func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>) -> index {
// expected-error@+1 {{redundant level argument for querying value memory size}} // expected-error@+1 {{redundant level argument for querying value memory size}}
%0 = sparse_tensor.storage_specifier.get %arg0 val_mem_sz at 0 %0 = sparse_tensor.storage_specifier.get %arg0 val_mem_sz at 0
: !sparse_tensor.storage_specifier<#SparseVector> : !sparse_tensor.storage_specifier<#SparseVector>
return %0 : index return %0 : index
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>) -> i64 { func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>) -> i64 {
// expected-error@+1 {{requested slice data on non-slice tensor}} // expected-error@+1 {{requested slice data on non-slice tensor}}
%0 = sparse_tensor.storage_specifier.get %arg0 dim_offset at 0 %0 = sparse_tensor.storage_specifier.get %arg0 dim_offset at 0
: !sparse_tensor.storage_specifier<#SparseVector> : !sparse_tensor.storage_specifier<#SparseVector>
return %0 : index return %0 : index
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>) -> index { func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>) -> index {
// expected-error@+1 {{missing level argument}} // expected-error@+1 {{missing level argument}}
%0 = sparse_tensor.storage_specifier.get %arg0 crd_mem_sz %0 = sparse_tensor.storage_specifier.get %arg0 crd_mem_sz
: !sparse_tensor.storage_specifier<#SparseVector> : !sparse_tensor.storage_specifier<#SparseVector>
return %0 : index return %0 : index
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>) -> index { func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>) -> index {
// expected-error@+1 {{requested level is out of bounds}} // expected-error@+1 {{requested level is out of bounds}}
%0 = sparse_tensor.storage_specifier.get %arg0 lvl_sz at 1 %0 = sparse_tensor.storage_specifier.get %arg0 lvl_sz at 1
: !sparse_tensor.storage_specifier<#SparseVector> : !sparse_tensor.storage_specifier<#SparseVector>
return %0 : index return %0 : index
} }
// ----- // -----
#COO = #sparse_tensor.encoding<{dimLevelType = ["compressed-nu", "singleton"]}> #COO = #sparse_tensor.encoding<{lvlTypes = ["compressed-nu", "singleton"]}>
func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#COO>) -> index { func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#COO>) -> index {
// expected-error@+1 {{requested position memory size on a singleton level}} // expected-error@+1 {{requested position memory size on a singleton level}}
%0 = sparse_tensor.storage_specifier.get %arg0 pos_mem_sz at 1 %0 = sparse_tensor.storage_specifier.get %arg0 pos_mem_sz at 1
: !sparse_tensor.storage_specifier<#COO> : !sparse_tensor.storage_specifier<#COO>
return %0 : index return %0 : index
} }
Show All 10 Lines
func.func @sparse_unannotated_insert(%arg0: tensor<128xf64>, %arg1: index, %arg2: f64) { func.func @sparse_unannotated_insert(%arg0: tensor<128xf64>, %arg1: index, %arg2: f64) {
// expected-error@+1 {{'sparse_tensor.insert' 'tensor' must be sparse tensor of any type values, but got 'tensor<128xf64>'}} // expected-error@+1 {{'sparse_tensor.insert' 'tensor' must be sparse tensor of any type values, but got 'tensor<128xf64>'}}
sparse_tensor.insert %arg2 into %arg0[%arg1] : tensor<128xf64> sparse_tensor.insert %arg2 into %arg0[%arg1] : tensor<128xf64>
return return
} }
// ----- // -----
#CSR = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
func.func @sparse_wrong_arity_insert(%arg0: tensor<128x64xf64, #CSR>, %arg1: index, %arg2: f64) { func.func @sparse_wrong_arity_insert(%arg0: tensor<128x64xf64, #CSR>, %arg1: index, %arg2: f64) {
// expected-error@+1 {{'sparse_tensor.insert' op incorrect number of coordinates}} // expected-error@+1 {{'sparse_tensor.insert' op incorrect number of coordinates}}
sparse_tensor.insert %arg2 into %arg0[%arg1] : tensor<128x64xf64, #CSR> sparse_tensor.insert %arg2 into %arg0[%arg1] : tensor<128x64xf64, #CSR>
return return
} }
// ----- // -----
Show All 33 Linesfunc.func @sparse_unannotated_compression(%arg0: memref<?xf64>,
// expected-error@+1 {{'sparse_tensor.compress' op operand #4 must be sparse tensor of any type values, but got 'tensor<8x8xf64>'}} // expected-error@+1 {{'sparse_tensor.compress' op operand #4 must be sparse tensor of any type values, but got 'tensor<8x8xf64>'}}
sparse_tensor.compress %arg0, %arg1, %arg2, %arg3 into %arg4[%arg5] sparse_tensor.compress %arg0, %arg1, %arg2, %arg3 into %arg4[%arg5]
: memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<8x8xf64> : memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<8x8xf64>
return return
} }
// ----- // -----
#CSR = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
func.func @sparse_wrong_arity_compression(%arg0: memref<?xf64>, func.func @sparse_wrong_arity_compression(%arg0: memref<?xf64>,
%arg1: memref<?xi1>, %arg1: memref<?xi1>,
%arg2: memref<?xindex>, %arg2: memref<?xindex>,
%arg3: index, %arg3: index,
%arg4: tensor<8x8xf64, #CSR>, %arg4: tensor<8x8xf64, #CSR>,
%arg5: index) { %arg5: index) {
// expected-error@+1 {{'sparse_tensor.compress' op incorrect number of coordinates}} // expected-error@+1 {{'sparse_tensor.compress' op incorrect number of coordinates}}
sparse_tensor.compress %arg0, %arg1, %arg2, %arg3 into %arg4[%arg5,%arg5] sparse_tensor.compress %arg0, %arg1, %arg2, %arg3 into %arg4[%arg5,%arg5]
: memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<8x8xf64, #CSR> : memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<8x8xf64, #CSR>
return return
} }
// ----- // -----
func.func @sparse_convert_unranked(%arg0: tensor<*xf32>) -> tensor<10xf32> { func.func @sparse_convert_unranked(%arg0: tensor<*xf32>) -> tensor<10xf32> {
// expected-error@+1 {{unexpected type in convert}} // expected-error@+1 {{unexpected type in convert}}
%0 = sparse_tensor.convert %arg0 : tensor<*xf32> to tensor<10xf32> %0 = sparse_tensor.convert %arg0 : tensor<*xf32> to tensor<10xf32>
return %0 : tensor<10xf32> return %0 : tensor<10xf32>
} }
// ----- // -----
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
func.func @sparse_convert_rank_mismatch(%arg0: tensor<10x10xf64, #DCSR>) -> tensor<?xf64> { func.func @sparse_convert_rank_mismatch(%arg0: tensor<10x10xf64, #DCSR>) -> tensor<?xf64> {
// expected-error@+1 {{unexpected conversion mismatch in rank}} // expected-error@+1 {{unexpected conversion mismatch in rank}}
%0 = sparse_tensor.convert %arg0 : tensor<10x10xf64, #DCSR> to tensor<?xf64> %0 = sparse_tensor.convert %arg0 : tensor<10x10xf64, #DCSR> to tensor<?xf64>
return %0 : tensor<?xf64> return %0 : tensor<?xf64>
} }
// ----- // -----
#CSR = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
func.func @sparse_convert_dim_mismatch(%arg0: tensor<10x?xf32>) -> tensor<10x10xf32, #CSR> { func.func @sparse_convert_dim_mismatch(%arg0: tensor<10x?xf32>) -> tensor<10x10xf32, #CSR> {
// expected-error@+1 {{unexpected conversion mismatch in dimension 1}} // expected-error@+1 {{unexpected conversion mismatch in dimension 1}}
%0 = sparse_tensor.convert %arg0 : tensor<10x?xf32> to tensor<10x10xf32, #CSR> %0 = sparse_tensor.convert %arg0 : tensor<10x?xf32> to tensor<10x10xf32, #CSR>
return %0 : tensor<10x10xf32, #CSR> return %0 : tensor<10x10xf32, #CSR>
} }
// ----- // -----
func.func @invalid_out_dense(%arg0: tensor<10xf64>, %arg1: !llvm.ptr<i8>) { func.func @invalid_out_dense(%arg0: tensor<10xf64>, %arg1: !llvm.ptr<i8>) {
// expected-error@+1 {{'sparse_tensor.out' op operand #0 must be sparse tensor of any type values, but got 'tensor<10xf64>'}} // expected-error@+1 {{'sparse_tensor.out' op operand #0 must be sparse tensor of any type values, but got 'tensor<10xf64>'}}
sparse_tensor.out %arg0, %arg1 : tensor<10xf64>, !llvm.ptr<i8> sparse_tensor.out %arg0, %arg1 : tensor<10xf64>, !llvm.ptr<i8>
return return
} }
// ----- // -----
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = ["dense", "compressed"], lvlTypes = ["dense", "compressed"],
slice = [ (1, 4, 1), (1, 4, 2) ] slice = [ (1, 4, 1), (1, 4, 2) ]
}> }>
func.func @sparse_convert_to_slice(%arg0: tensor<10x?xf32>) -> tensor<10x10xf32, #CSR> { func.func @sparse_convert_to_slice(%arg0: tensor<10x?xf32>) -> tensor<10x10xf32, #CSR> {
// expected-error@+1 {{cannot convert to a sparse tensor slice}} // expected-error@+1 {{cannot convert to a sparse tensor slice}}
%0 = sparse_tensor.convert %arg0 : tensor<10x?xf32> to tensor<10x10xf32, #CSR> %0 = sparse_tensor.convert %arg0 : tensor<10x?xf32> to tensor<10x10xf32, #CSR>
return %0 : tensor<10x10xf32, #CSR> return %0 : tensor<10x10xf32, #CSR>
} }
▲ Show 20 Lines • Show All 215 Lines • ▼ Show 20 Lines %r = sparse_tensor.select %arg0 : f64 {
^bb0(%x: f64): ^bb0(%x: f64):
tensor.yield %x : f64 tensor.yield %x : f64
} }
return %r : f64 return %r : f64
} }
// ----- // -----
#DC = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #DC = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
func.func @invalid_concat_less_inputs(%arg: tensor<9x4xf64, #DC>) -> tensor<9x4xf64, #DC> { func.func @invalid_concat_less_inputs(%arg: tensor<9x4xf64, #DC>) -> tensor<9x4xf64, #DC> {
// expected-error@+1 {{Need at least two tensors to concatenate.}} // expected-error@+1 {{Need at least two tensors to concatenate.}}
%0 = sparse_tensor.concatenate %arg {dimension = 1 : index} %0 = sparse_tensor.concatenate %arg {dimension = 1 : index}
: tensor<9x4xf64, #DC> to tensor<9x4xf64, #DC> : tensor<9x4xf64, #DC> to tensor<9x4xf64, #DC>
return %0 : tensor<9x4xf64, #DC> return %0 : tensor<9x4xf64, #DC>
} }
// ----- // -----
#DC = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #DC = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
func.func @invalid_concat_dim(%arg0: tensor<2x4xf64, #DC>, func.func @invalid_concat_dim(%arg0: tensor<2x4xf64, #DC>,
%arg1: tensor<3x4xf64, #DC>, %arg1: tensor<3x4xf64, #DC>,
%arg2: tensor<4x4xf64, #DC>) -> tensor<9x4xf64, #DC> { %arg2: tensor<4x4xf64, #DC>) -> tensor<9x4xf64, #DC> {
// expected-error@+1 {{Concat-dimension is out of bounds for dimension-rank (4 >= 2)}} // expected-error@+1 {{Concat-dimension is out of bounds for dimension-rank (4 >= 2)}}
%0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 4 : index} %0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 4 : index}
: tensor<2x4xf64, #DC>, : tensor<2x4xf64, #DC>,
tensor<3x4xf64, #DC>, tensor<3x4xf64, #DC>,
tensor<4x4xf64, #DC> to tensor<9x4xf64, #DC> tensor<4x4xf64, #DC> to tensor<9x4xf64, #DC>
return %0 : tensor<9x4xf64, #DC> return %0 : tensor<9x4xf64, #DC>
} }
// ----- // -----
#C = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #C = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#DC = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #DC = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#DCC = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed", "compressed"]}> #DCC = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed", "compressed"]}>
func.func @invalid_concat_rank_mismatch(%arg0: tensor<2xf64, #C>, func.func @invalid_concat_rank_mismatch(%arg0: tensor<2xf64, #C>,
%arg1: tensor<3x4xf64, #DC>, %arg1: tensor<3x4xf64, #DC>,
%arg2: tensor<4x4x4xf64, #DCC>) -> tensor<9x4xf64, #DC> { %arg2: tensor<4x4x4xf64, #DCC>) -> tensor<9x4xf64, #DC> {
// expected-error@+1 {{Input tensor $0 has a different rank (rank=1) from the output tensor (rank=2)}} // expected-error@+1 {{Input tensor $0 has a different rank (rank=1) from the output tensor (rank=2)}}
%0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index} %0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index}
: tensor<2xf64, #C>, : tensor<2xf64, #C>,
tensor<3x4xf64, #DC>, tensor<3x4xf64, #DC>,
tensor<4x4x4xf64, #DCC> to tensor<9x4xf64, #DC> tensor<4x4x4xf64, #DCC> to tensor<9x4xf64, #DC>
return %0 : tensor<9x4xf64, #DC> return %0 : tensor<9x4xf64, #DC>
} }
// ----- // -----
#DC = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #DC = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
func.func @invalid_concat_size_mismatch_dyn(%arg0: tensor<?x4xf64, #DC>, func.func @invalid_concat_size_mismatch_dyn(%arg0: tensor<?x4xf64, #DC>,
%arg1: tensor<5x4xf64, #DC>, %arg1: tensor<5x4xf64, #DC>,
%arg2: tensor<4x4xf64, #DC>) -> tensor<9x4xf64, #DC> { %arg2: tensor<4x4xf64, #DC>) -> tensor<9x4xf64, #DC> {
// expected-error@+1 {{Input tensor $0 has dynamic shape}} // expected-error@+1 {{Input tensor $0 has dynamic shape}}
%0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index} %0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index}
: tensor<?x4xf64, #DC>, : tensor<?x4xf64, #DC>,
tensor<5x4xf64, #DC>, tensor<5x4xf64, #DC>,
tensor<4x4xf64, #DC> to tensor<9x4xf64, #DC> tensor<4x4xf64, #DC> to tensor<9x4xf64, #DC>
return %0 : tensor<9x4xf64, #DC> return %0 : tensor<9x4xf64, #DC>
} }
// ----- // -----
#DC = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #DC = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
func.func @invalid_concat_size_mismatch(%arg0: tensor<3x4xf64, #DC>, func.func @invalid_concat_size_mismatch(%arg0: tensor<3x4xf64, #DC>,
%arg1: tensor<5x4xf64, #DC>, %arg1: tensor<5x4xf64, #DC>,
%arg2: tensor<4x4xf64, #DC>) -> tensor<9x4xf64, #DC> { %arg2: tensor<4x4xf64, #DC>) -> tensor<9x4xf64, #DC> {
// expected-error@+1 {{The concatenation dimension of the output tensor should be the sum of}} // expected-error@+1 {{The concatenation dimension of the output tensor should be the sum of}}
%0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index} %0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index}
: tensor<3x4xf64, #DC>, : tensor<3x4xf64, #DC>,
tensor<5x4xf64, #DC>, tensor<5x4xf64, #DC>,
tensor<4x4xf64, #DC> to tensor<9x4xf64, #DC> tensor<4x4xf64, #DC> to tensor<9x4xf64, #DC>
return %0 : tensor<9x4xf64, #DC> return %0 : tensor<9x4xf64, #DC>
} }
// ----- // -----
#DC = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #DC = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
func.func @invalid_concat_size_mismatch(%arg0: tensor<2x4xf64, #DC>, func.func @invalid_concat_size_mismatch(%arg0: tensor<2x4xf64, #DC>,
%arg1: tensor<3x3xf64, #DC>, %arg1: tensor<3x3xf64, #DC>,
%arg2: tensor<4x4xf64, #DC>) -> tensor<9x4xf64, #DC> { %arg2: tensor<4x4xf64, #DC>) -> tensor<9x4xf64, #DC> {
// expected-error@+1 {{All dimensions (expect for the concatenating one) should be equal}} // expected-error@+1 {{All dimensions (expect for the concatenating one) should be equal}}
%0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index} %0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index}
: tensor<2x4xf64, #DC>, : tensor<2x4xf64, #DC>,
tensor<3x3xf64, #DC>, tensor<3x3xf64, #DC>,
tensor<4x4xf64, #DC> to tensor<9x4xf64, #DC> tensor<4x4xf64, #DC> to tensor<9x4xf64, #DC>
return %0 : tensor<9x4xf64, #DC> return %0 : tensor<9x4xf64, #DC>
} }
// ----- // -----
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>) -> () { func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>) -> () {
// expected-error@+1 {{Unmatched number of arguments in the block}} // expected-error@+1 {{Unmatched number of arguments in the block}}
sparse_tensor.foreach in %arg0 : tensor<2x4xf64, #DCSR> do { sparse_tensor.foreach in %arg0 : tensor<2x4xf64, #DCSR> do {
^bb0(%1: index, %2: index, %3: index, %v: f64) : ^bb0(%1: index, %2: index, %3: index, %v: f64) :
} }
return return
} }
// ----- // -----
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>) -> () { func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>) -> () {
// expected-error@+1 {{Expecting Index type for argument at index 1}} // expected-error@+1 {{Expecting Index type for argument at index 1}}
sparse_tensor.foreach in %arg0 : tensor<2x4xf64, #DCSR> do { sparse_tensor.foreach in %arg0 : tensor<2x4xf64, #DCSR> do {
^bb0(%1: index, %2: f64, %v: f64) : ^bb0(%1: index, %2: f64, %v: f64) :
} }
return return
} }
// ----- // -----
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>) -> () { func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>) -> () {
// expected-error@+1 {{Unmatched element type between input tensor and block argument}} // expected-error@+1 {{Unmatched element type between input tensor and block argument}}
sparse_tensor.foreach in %arg0 : tensor<2x4xf64, #DCSR> do { sparse_tensor.foreach in %arg0 : tensor<2x4xf64, #DCSR> do {
^bb0(%1: index, %2: index, %v: f32) : ^bb0(%1: index, %2: index, %v: f32) :
} }
return return
} }
// ----- // -----
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>) -> () { func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>) -> () {
// expected-error@+1 {{Unmatched element type between input tensor and block argument}} // expected-error@+1 {{Unmatched element type between input tensor and block argument}}
sparse_tensor.foreach in %arg0 : tensor<2x4xf64, #DCSR> do { sparse_tensor.foreach in %arg0 : tensor<2x4xf64, #DCSR> do {
^bb0(%1: index, %2: index, %v: f32) : ^bb0(%1: index, %2: index, %v: f32) :
} }
return return
} }
// ----- // -----
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>, %arg1: f32) -> () { func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>, %arg1: f32) -> () {
// expected-error@+1 {{Mismatch in number of init arguments and results}} // expected-error@+1 {{Mismatch in number of init arguments and results}}
sparse_tensor.foreach in %arg0 init(%arg1) : tensor<2x4xf64, #DCSR>, f32 do { sparse_tensor.foreach in %arg0 init(%arg1) : tensor<2x4xf64, #DCSR>, f32 do {
^bb0(%1: index, %2: index, %v: f32, %r1 : i32) : ^bb0(%1: index, %2: index, %v: f32, %r1 : i32) :
} }
return return
} }
// ----- // -----
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>, %arg1: f32) -> () { func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>, %arg1: f32) -> () {
// expected-error@+1 {{Mismatch in types of init arguments and results}} // expected-error@+1 {{Mismatch in types of init arguments and results}}
%1 = sparse_tensor.foreach in %arg0 init(%arg1) : tensor<2x4xf64, #DCSR>, f32 -> i32 do { %1 = sparse_tensor.foreach in %arg0 init(%arg1) : tensor<2x4xf64, #DCSR>, f32 -> i32 do {
^bb0(%1: index, %2: index, %v: f32, %r0 : f32) : ^bb0(%1: index, %2: index, %v: f32, %r0 : f32) :
} }
return return
} }
// ----- // -----
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>, %arg1: f32) -> () { func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>, %arg1: f32) -> () {
// expected-error@+1 {{Mismatch in types of yield values and results}} // expected-error@+1 {{Mismatch in types of yield values and results}}
%1 = sparse_tensor.foreach in %arg0 init(%arg1) : tensor<2x4xf64, #DCSR>, f32 -> f32 do { %1 = sparse_tensor.foreach in %arg0 init(%arg1) : tensor<2x4xf64, #DCSR>, f32 -> f32 do {
^bb0(%1: index, %2: index, %v: f32, %r0 : f32) : ^bb0(%1: index, %2: index, %v: f32, %r0 : f32) :
sparse_tensor.yield %1 : index sparse_tensor.yield %1 : index
} }
return return
} }
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linesfunc.func @sparse_sort_coo_y_too_small(%arg0: memref<60xindex>, %arg1: memref<10xf32>) {
%i20 = arith.constant 20 : index %i20 = arith.constant 20 : index
// expected-error@+1 {{Expected dimension(y) >= n got 10 < 20}} // expected-error@+1 {{Expected dimension(y) >= n got 10 < 20}}
sparse_tensor.sort_coo insertion_sort_stable %i20, %arg0 jointly %arg1 {nx = 2 : index, ny = 1 : index} : memref<60xindex> jointly memref<10xf32> sparse_tensor.sort_coo insertion_sort_stable %i20, %arg0 jointly %arg1 {nx = 2 : index, ny = 1 : index} : memref<60xindex> jointly memref<10xf32>
return return
} }
// ----- // -----
#CSR = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
func.func @sparse_alloc_escapes(%arg0: index) -> tensor<10x?xf64, #CSR> { func.func @sparse_alloc_escapes(%arg0: index) -> tensor<10x?xf64, #CSR> {
// expected-error@+1 {{sparse tensor allocation should not escape function}} // expected-error@+1 {{sparse tensor allocation should not escape function}}
%0 = bufferization.alloc_tensor(%arg0) : tensor<10x?xf64, #CSR> %0 = bufferization.alloc_tensor(%arg0) : tensor<10x?xf64, #CSR>
return %0: tensor<10x?xf64, #CSR> return %0: tensor<10x?xf64, #CSR>
} }

mlir/test/Dialect/SparseTensor/invalid_encoding.mlir

// RUN: mlir-opt %s -split-input-file -verify-diagnostics // RUN: mlir-opt %s -split-input-file -verify-diagnostics
// expected-error@+1 {{expected a non-empty array for level types}} // expected-error@+1 {{expected a non-empty array for level types}}
#a = #sparse_tensor.encoding<{dimLevelType = []}> #a = #sparse_tensor.encoding<{lvlTypes = []}>
func.func private @scalar(%arg0: tensor<f64, #a>) -> () func.func private @scalar(%arg0: tensor<f64, #a>) -> ()
// ----- // -----
#a = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
func.func private @tensor_dimlevel_size_mismatch(%arg0: tensor<8xi32, #a>) -> () // expected-error {{expected an array of size 1 for dimension level types}} func.func private @tensor_dimlevel_size_mismatch(%arg0: tensor<8xi32, #a>) -> () // expected-error {{expected an array of size 1 for dimension level types}}
// ----- // -----
#a = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"], dimOrdering = affine_map<(i) -> (i)>}> // expected-error {{unexpected mismatch in ordering and dimension level types size}} #a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"], dimOrdering = affine_map<(i) -> (i)>}> // expected-error {{unexpected mismatch in ordering and dimension level types size}}
func.func private @tensor_sizes_mismatch(%arg0: tensor<8xi32, #a>) -> () func.func private @tensor_sizes_mismatch(%arg0: tensor<8xi32, #a>) -> ()
// ----- // -----
#a = #sparse_tensor.encoding<{dimLevelType = [1]}> // expected-error {{expected a string value in dimension level types}} #a = #sparse_tensor.encoding<{lvlTypes = [1]}> // expected-error {{expected a string value in dimension level types}}
func.func private @tensor_type_mismatch(%arg0: tensor<8xi32, #a>) -> () func.func private @tensor_type_mismatch(%arg0: tensor<8xi32, #a>) -> ()
// ----- // -----
#a = #sparse_tensor.encoding<{dimLevelType = ["strange"]}> // expected-error {{unexpected dimension level type: strange}} #a = #sparse_tensor.encoding<{lvlTypes = ["strange"]}> // expected-error {{unexpected dimension level type: strange}}
func.func private @tensor_value_mismatch(%arg0: tensor<8xi32, #a>) -> () func.func private @tensor_value_mismatch(%arg0: tensor<8xi32, #a>) -> ()
// ----- // -----
#a = #sparse_tensor.encoding<{dimOrdering = "wrong"}> // expected-error {{expected an affine map for dimension ordering}} #a = #sparse_tensor.encoding<{dimOrdering = "wrong"}> // expected-error {{expected an affine map for dimension ordering}}
func.func private @tensor_dimorder_mismatch(%arg0: tensor<8xi32, #a>) -> () func.func private @tensor_dimorder_mismatch(%arg0: tensor<8xi32, #a>) -> ()
// ----- // -----
#a = #sparse_tensor.encoding<{higherOrdering = "wrong"}> // expected-error {{expected an affine map for higher ordering}} #a = #sparse_tensor.encoding<{higherOrdering = "wrong"}> // expected-error {{expected an affine map for higher ordering}}
func.func private @tensor_highorder_mismatch(%arg0: tensor<8xi32, #a>) -> () func.func private @tensor_highorder_mismatch(%arg0: tensor<8xi32, #a>) -> ()
// ----- // -----
// expected-error@+1 {{expected a permutation affine map for dimension ordering}} // expected-error@+1 {{expected a permutation affine map for dimension ordering}}
#a = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"], dimOrdering = affine_map<(i,j) -> (i,i)>}> #a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"], dimOrdering = affine_map<(i,j) -> (i,i)>}>
func.func private @tensor_no_permutation(%arg0: tensor<16x32xf32, #a>) -> () func.func private @tensor_no_permutation(%arg0: tensor<16x32xf32, #a>) -> ()
// ----- // -----
#a = #sparse_tensor.encoding<{posWidth = "x"}> // expected-error {{expected an integral position bitwidth}} #a = #sparse_tensor.encoding<{posWidth = "x"}> // expected-error {{expected an integral position bitwidth}}
func.func private @tensor_no_int_ptr(%arg0: tensor<16x32xf32, #a>) -> () func.func private @tensor_no_int_ptr(%arg0: tensor<16x32xf32, #a>) -> ()
// ----- // -----
Show All 13 Lines
// ----- // -----
#a = #sparse_tensor.encoding<{key = 1}> // expected-error {{unexpected key: key}} #a = #sparse_tensor.encoding<{key = 1}> // expected-error {{unexpected key: key}}
func.func private @tensor_invalid_key(%arg0: tensor<16x32xf32, #a>) -> () func.func private @tensor_invalid_key(%arg0: tensor<16x32xf32, #a>) -> ()
// ----- // -----
#a = #sparse_tensor.encoding<{dimLevelType = [ "compressed", "compressed", "dense", "dense" ], dimOrdering = affine_map<(ii, jj, i, j) -> (ii, jj, i, j)>, higherOrdering = affine_map<(i, j) -> (j, i)>}> // expected-error {{unexpected higher ordering mapping from 2 to 2}} #a = #sparse_tensor.encoding<{lvlTypes = [ "compressed", "compressed", "dense", "dense" ], dimOrdering = affine_map<(ii, jj, i, j) -> (ii, jj, i, j)>, higherOrdering = affine_map<(i, j) -> (j, i)>}> // expected-error {{unexpected higher ordering mapping from 2 to 2}}
func.func private @tensor_invalid_key(%arg0: tensor<10x60xf32, #a>) -> () func.func private @tensor_invalid_key(%arg0: tensor<10x60xf32, #a>) -> ()
// ----- // -----
#CSR_SLICE = #sparse_tensor.encoding<{ #CSR_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (-1, ?, 1), (?, 4, 2) ] // expected-error{{expect positive value or ? for slice offset/size/stride}} slice = [ (-1, ?, 1), (?, 4, 2) ] // expected-error{{expect positive value or ? for slice offset/size/stride}}
}> }>
func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>) func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>)

mlir/test/Dialect/SparseTensor/one_shot_bufferize_tensor_copy_insertion.mlir

// RUN: mlir-opt %s -test-tensor-copy-insertion="allow-return-allocs" | FileCheck %s // RUN: mlir-opt %s -test-tensor-copy-insertion="allow-return-allocs" | FileCheck %s
// RUN: mlir-opt %s -test-tensor-copy-insertion="bufferize-function-boundaries allow-return-allocs" | FileCheck %s --check-prefix=CHECK-FUNC // RUN: mlir-opt %s -test-tensor-copy-insertion="bufferize-function-boundaries allow-return-allocs" | FileCheck %s --check-prefix=CHECK-FUNC
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (i,j)> dimOrdering = affine_map<(i,j) -> (i,j)>
}> }>
// CHECK-LABEL: func @bufferization_alloc_tensor // CHECK-LABEL: func @bufferization_alloc_tensor
// CHECK-FUNC-LABEL: func @bufferization_alloc_tensor // CHECK-FUNC-LABEL: func @bufferization_alloc_tensor
func.func @bufferization_alloc_tensor() -> tensor<20x40xf32, #DCSR> { func.func @bufferization_alloc_tensor() -> tensor<20x40xf32, #DCSR> {
// CHECK: bufferization.alloc_tensor() {bufferization.escape = [false]} // CHECK: bufferization.alloc_tensor() {bufferization.escape = [false]}
// CHECK-FUNC: bufferization.alloc_tensor() {bufferization.escape = [true]} // CHECK-FUNC: bufferization.alloc_tensor() {bufferization.escape = [true]}
Show All 22 Linesfunc.func @sparse_tensor_convert() -> tensor<20x40xf32> {
// CHECK-FUNC: %[[loaded:.*]] = sparse_tensor.load %[[alloc]] // CHECK-FUNC: %[[loaded:.*]] = sparse_tensor.load %[[alloc]]
%1 = sparse_tensor.load %0 : tensor<20x40xf32, #DCSR> %1 = sparse_tensor.load %0 : tensor<20x40xf32, #DCSR>
// CHECK: sparse_tensor.convert %[[loaded]] {bufferization.escape = [false]} // CHECK: sparse_tensor.convert %[[loaded]] {bufferization.escape = [false]}
// CHECK-FUNC: sparse_tensor.convert %[[loaded]] {bufferization.escape = [true]} // CHECK-FUNC: sparse_tensor.convert %[[loaded]] {bufferization.escape = [true]}
%2 = sparse_tensor.convert %1 : tensor<20x40xf32, #DCSR> to tensor<20x40xf32> %2 = sparse_tensor.convert %1 : tensor<20x40xf32, #DCSR> to tensor<20x40xf32>
return %2 : tensor<20x40xf32> return %2 : tensor<20x40xf32>
} }
#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // A (in) affine_map<(i) -> (i)>, // A (in)
affine_map<(i) -> (i)> // X (out) affine_map<(i) -> (i)> // X (out)
], ],
iterator_types = ["parallel"] iterator_types = ["parallel"]
} }
Show All 21 Lines

mlir/test/Dialect/SparseTensor/one_trip.mlir

// RUN: mlir-opt %s -sparsification -cse | FileCheck %s // RUN: mlir-opt %s -sparsification -cse | FileCheck %s
#Dense = #sparse_tensor.encoding<{ #Dense = #sparse_tensor.encoding<{
dimLevelType = [ "dense" , "dense" ] lvlTypes = [ "dense" , "dense" ]
}> }>
#trait_scale = { #trait_scale = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
doc = "X(i,j) = X(i,j) * 2.0" doc = "X(i,j) = X(i,j) * 2.0"
} }
// CHECK-LABEL: func.func @sparse_scale( // CHECK-LABEL: func.func @sparse_scale(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<1x1xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense" ] }>>) // CHECK-SAME: %[[VAL_0:.*]]: tensor<1x1xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ] }>>)
// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 2.000000e+00 : f32 // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 2.000000e+00 : f32
// CHECK: %[[VAL_3:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<1x1xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense" ] }>> to memref<?xf32> // CHECK: %[[VAL_3:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<1x1xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ] }>> to memref<?xf32>
// CHECK: %[[VAL_4:.*]] = memref.load %[[VAL_3]]{{\[}}%[[VAL_1]]] : memref<?xf32> // CHECK: %[[VAL_4:.*]] = memref.load %[[VAL_3]]{{\[}}%[[VAL_1]]] : memref<?xf32>
// CHECK: %[[VAL_5:.*]] = arith.mulf %[[VAL_4]], %[[VAL_2]] : f32 // CHECK: %[[VAL_5:.*]] = arith.mulf %[[VAL_4]], %[[VAL_2]] : f32
// CHECK: memref.store %[[VAL_5]], %[[VAL_3]]{{\[}}%[[VAL_1]]] : memref<?xf32> // CHECK: memref.store %[[VAL_5]], %[[VAL_3]]{{\[}}%[[VAL_1]]] : memref<?xf32>
// CHECK: %[[VAL_6:.*]] = sparse_tensor.load %[[VAL_0]] : tensor<1x1xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense" ] }>> // CHECK: %[[VAL_6:.*]] = sparse_tensor.load %[[VAL_0]] : tensor<1x1xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ] }>>
// CHECK: return %[[VAL_6]] : tensor<1x1xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense" ] }>> // CHECK: return %[[VAL_6]] : tensor<1x1xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ] }>>
func.func @sparse_scale(%argx: tensor<1x1xf32, #Dense>) -> tensor<1x1xf32, #Dense> { func.func @sparse_scale(%argx: tensor<1x1xf32, #Dense>) -> tensor<1x1xf32, #Dense> {
%c = arith.constant 2.0 : f32 %c = arith.constant 2.0 : f32
%0 = linalg.generic #trait_scale %0 = linalg.generic #trait_scale
outs(%argx: tensor<1x1xf32, #Dense>) { outs(%argx: tensor<1x1xf32, #Dense>) {
^bb(%x: f32): ^bb(%x: f32):
%1 = arith.mulf %x, %c : f32 %1 = arith.mulf %x, %c : f32
linalg.yield %1 : f32 linalg.yield %1 : f32
} -> tensor<1x1xf32, #Dense> } -> tensor<1x1xf32, #Dense>
return %0 : tensor<1x1xf32, #Dense> return %0 : tensor<1x1xf32, #Dense>
} }

mlir/test/Dialect/SparseTensor/post_rewriting.mlir

// RUN: mlir-opt %s -post-sparsification-rewrite | FileCheck %s // RUN: mlir-opt %s -post-sparsification-rewrite | FileCheck %s
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] lvlTypes = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = ["compressed", "compressed"] lvlTypes = ["compressed", "compressed"]
}> }>
// CHECK-LABEL: func.func @expand_dense( // CHECK-LABEL: func.func @expand_dense(
// CHECK-SAME: %[[A:.*]]: tensor<12xf64>) -> tensor<3x4xf64> { // CHECK-SAME: %[[A:.*]]: tensor<12xf64>) -> tensor<3x4xf64> {
// CHECK: %[[E:.*]] = tensor.expand_shape %[[A]] {{.*}} : tensor<12xf64> into tensor<3x4xf64> // CHECK: %[[E:.*]] = tensor.expand_shape %[[A]] {{.*}} : tensor<12xf64> into tensor<3x4xf64>
// CHECK: return %[[E]] : tensor<3x4xf64> // CHECK: return %[[E]] : tensor<3x4xf64>
// CHECK: } // CHECK: }
func.func @expand_dense(%arg0: tensor<12xf64>) -> tensor<3x4xf64> { func.func @expand_dense(%arg0: tensor<12xf64>) -> tensor<3x4xf64> {
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/pre_rewriting.mlir

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

mlir/test/Dialect/SparseTensor/rejected.mlir

// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
// The file contains examples that will be rejected by sparse compiler // The file contains examples that will be rejected by sparse compiler
// (we expect the linalg.generic unchanged). // (we expect the linalg.generic unchanged).
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> ()> // x (out) affine_map<(i) -> ()> // x (out)
], ],
iterator_types = ["reduction"] iterator_types = ["reduction"]
} }
// CHECK-LABEL: func.func @sparse_reduction_subi( // CHECK-LABEL: func.func @sparse_reduction_subi(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<i32>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<i32>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i32> { // CHECK-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i32> {
// CHECK: %[[VAL_2:.*]] = linalg.generic // CHECK: %[[VAL_2:.*]] = linalg.generic
// CHECK: ^bb0(%[[VAL_3:.*]]: i32, %[[VAL_4:.*]]: i32): // CHECK: ^bb0(%[[VAL_3:.*]]: i32, %[[VAL_4:.*]]: i32):
// CHECK: %[[VAL_5:.*]] = arith.subi %[[VAL_3]], %[[VAL_4]] : i32 // CHECK: %[[VAL_5:.*]] = arith.subi %[[VAL_3]], %[[VAL_4]] : i32
// CHECK: linalg.yield %[[VAL_5]] : i32 // CHECK: linalg.yield %[[VAL_5]] : i32
// CHECK: } -> tensor<i32> // CHECK: } -> tensor<i32>
// CHECK: return %[[VAL_6:.*]] : tensor<i32> // CHECK: return %[[VAL_6:.*]] : tensor<i32>
func.func @sparse_reduction_subi(%argx: tensor<i32>, func.func @sparse_reduction_subi(%argx: tensor<i32>,
%arga: tensor<?xi32, #SparseVector>) %arga: tensor<?xi32, #SparseVector>)
Show All 13 Lines

mlir/test/Dialect/SparseTensor/rewriting_for_codegen.mlir

// RUN: mlir-opt %s -post-sparsification-rewrite="enable-runtime-library=false enable-convert=false" | \ // RUN: mlir-opt %s -post-sparsification-rewrite="enable-runtime-library=false enable-convert=false" | \
// RUN: FileCheck %s // RUN: FileCheck %s
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = ["dense", "compressed"] lvlTypes = ["dense", "compressed"]
}> }>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i, j) -> (j, i)> dimOrdering = affine_map<(i, j) -> (j, i)>
}> }>
#COO = #sparse_tensor.encoding<{ #COO = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
// CHECK-LABEL: func.func @sparse_new( // CHECK-LABEL: func.func @sparse_new(
// CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> { // CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> {
// CHECK: %[[COO:.*]] = sparse_tensor.new %[[A]] : !llvm.ptr<i8> to tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> // CHECK: %[[COO:.*]] = sparse_tensor.new %[[A]] : !llvm.ptr<i8> to tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>>
// CHECK: %[[R:.*]] = sparse_tensor.convert %[[COO]] // CHECK: %[[R:.*]] = sparse_tensor.convert %[[COO]]
// CHECK: bufferization.dealloc_tensor %[[COO]] // CHECK: bufferization.dealloc_tensor %[[COO]]
// CHECK: return %[[R]] // CHECK: return %[[R]]
func.func @sparse_new(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf32, #CSR> { func.func @sparse_new(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf32, #CSR> {
%0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<?x?xf32, #CSR> %0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<?x?xf32, #CSR>
return %0 : tensor<?x?xf32, #CSR> return %0 : tensor<?x?xf32, #CSR>
} }
// CHECK-LABEL: func.func @sparse_new_csc( // CHECK-LABEL: func.func @sparse_new_csc(
// CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> { // CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> {
// CHECK: %[[COO:.*]] = sparse_tensor.new %[[A]] : !llvm.ptr<i8> to tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> // CHECK: %[[COO:.*]] = sparse_tensor.new %[[A]] : !llvm.ptr<i8> to tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>
// CHECK: %[[R:.*]] = sparse_tensor.convert %[[COO]] // CHECK: %[[R:.*]] = sparse_tensor.convert %[[COO]]
// CHECK: bufferization.dealloc_tensor %[[COO]] // CHECK: bufferization.dealloc_tensor %[[COO]]
// CHECK: return %[[R]] // CHECK: return %[[R]]
func.func @sparse_new_csc(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf32, #CSC> { func.func @sparse_new_csc(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf32, #CSC> {
%0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<?x?xf32, #CSC> %0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<?x?xf32, #CSC>
return %0 : tensor<?x?xf32, #CSC> return %0 : tensor<?x?xf32, #CSC>
} }
// CHECK-LABEL: func.func @sparse_new_coo( // CHECK-LABEL: func.func @sparse_new_coo(
// CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> { // CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> {
// CHECK: %[[COO:.*]] = sparse_tensor.new %[[A]] : !llvm.ptr<i8> to tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> // CHECK: %[[COO:.*]] = sparse_tensor.new %[[A]] : !llvm.ptr<i8> to tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>>
// CHECK: return %[[COO]] // CHECK: return %[[COO]]
func.func @sparse_new_coo(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf32, #COO> { func.func @sparse_new_coo(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf32, #COO> {
%0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<?x?xf32, #COO> %0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<?x?xf32, #COO>
return %0 : tensor<?x?xf32, #COO> return %0 : tensor<?x?xf32, #COO>
} }
// CHECK-LABEL: func.func @sparse_out( // CHECK-LABEL: func.func @sparse_out(
// CHECK-SAME: %[[A:.*]]: tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>, // CHECK-SAME: %[[A:.*]]: tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>,
// CHECK-SAME: %[[B:.*]]: !llvm.ptr<i8>) { // CHECK-SAME: %[[B:.*]]: !llvm.ptr<i8>) {
// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index // CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index // CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[C2:.*]] = arith.constant 2 : index // CHECK-DAG: %[[C2:.*]] = arith.constant 2 : index
// CHECK-DAG: %[[C10:.*]] = arith.constant 10 : index // CHECK-DAG: %[[C10:.*]] = arith.constant 10 : index
// CHECK-DAG: %[[C20:.*]] = arith.constant 20 : index // CHECK-DAG: %[[C20:.*]] = arith.constant 20 : index
// CHECK: %[[NNZ:.*]] = sparse_tensor.number_of_entries %[[A]] // CHECK: %[[NNZ:.*]] = sparse_tensor.number_of_entries %[[A]]
// CHECK: %[[DS:.*]] = memref.alloca(%[[C2]]) : memref<?xindex> // CHECK: %[[DS:.*]] = memref.alloca(%[[C2]]) : memref<?xindex>
Show All 17 Lines

mlir/test/Dialect/SparseTensor/roundtrip.mlir

// RUN: mlir-opt %s -split-input-file | mlir-opt -split-input-file | FileCheck %s // RUN: mlir-opt %s -split-input-file | mlir-opt -split-input-file | FileCheck %s
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
// CHECK-LABEL: func @sparse_new( // CHECK-LABEL: func @sparse_new(
// CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) // CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>)
// CHECK: %[[T:.*]] = sparse_tensor.new %[[A]] : !llvm.ptr<i8> to tensor<128xf64, #{{.*}}> // CHECK: %[[T:.*]] = sparse_tensor.new %[[A]] : !llvm.ptr<i8> to tensor<128xf64, #{{.*}}>
// CHECK: return %[[T]] : tensor<128xf64, #{{.*}}> // CHECK: return %[[T]] : tensor<128xf64, #{{.*}}>
func.func @sparse_new(%arg0: !llvm.ptr<i8>) -> tensor<128xf64, #SparseVector> { func.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"], crdWidth=32}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"], crdWidth=32}>
// CHECK-LABEL: func @sparse_pack( // CHECK-LABEL: func @sparse_pack(
// CHECK-SAME: %[[D:.*]]: tensor<6xf64>, // CHECK-SAME: %[[D:.*]]: tensor<6xf64>,
// CHECK-SAME: %[[I:.*]]: tensor<6x1xi32>) // CHECK-SAME: %[[I:.*]]: tensor<6x1xi32>)
// CHECK: %[[R:.*]] = sparse_tensor.pack %[[D]], %[[I]] // CHECK: %[[R:.*]] = sparse_tensor.pack %[[D]], %[[I]]
// CHECK: return %[[R]] : tensor<100xf64, #{{.*}}> // CHECK: return %[[R]] : tensor<100xf64, #{{.*}}>
func.func @sparse_pack(%data: tensor<6xf64>, %index: tensor<6x1xi32>) func.func @sparse_pack(%data: tensor<6xf64>, %index: tensor<6x1xi32>)
-> tensor<100xf64, #SparseVector> { -> tensor<100xf64, #SparseVector> {
%0 = sparse_tensor.pack %data, %index : tensor<6xf64>, tensor<6x1xi32> %0 = sparse_tensor.pack %data, %index : tensor<6xf64>, tensor<6x1xi32>
to tensor<100xf64, #SparseVector> to tensor<100xf64, #SparseVector>
return %0 : tensor<100xf64, #SparseVector> return %0 : tensor<100xf64, #SparseVector>
} }
// ----- // -----
#BCOO = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed-hi"], crdWidth=32}> #BCOO = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed-hi"], crdWidth=32}>
// CHECK-LABEL: func @sparse_pack_batched( // CHECK-LABEL: func @sparse_pack_batched(
// CHECK-SAME: %[[D:.*]]: tensor<2x6xf64>, // CHECK-SAME: %[[D:.*]]: tensor<2x6xf64>,
// CHECK-SAME: %[[I:.*]]: tensor<2x6x1xi32>) // CHECK-SAME: %[[I:.*]]: tensor<2x6x1xi32>)
// CHECK: %[[R:.*]] = sparse_tensor.pack %[[D]], %[[I]] batched_lvls = 1 // CHECK: %[[R:.*]] = sparse_tensor.pack %[[D]], %[[I]] batched_lvls = 1
// CHECK: return %[[R]] : tensor<2x100xf64, #{{.*}}> // CHECK: return %[[R]] : tensor<2x100xf64, #{{.*}}>
func.func @sparse_pack_batched(%values: tensor<2x6xf64>, %coordinates: tensor<2x6x1xi32>) func.func @sparse_pack_batched(%values: tensor<2x6xf64>, %coordinates: tensor<2x6x1xi32>)
-> tensor<2x100xf64, #BCOO> { -> tensor<2x100xf64, #BCOO> {
%0 = sparse_tensor.pack %values, %coordinates batched_lvls=1 %0 = sparse_tensor.pack %values, %coordinates batched_lvls=1
: tensor<2x6xf64>, tensor<2x6x1xi32> to tensor<2x100xf64, #BCOO> : tensor<2x6xf64>, tensor<2x6x1xi32> to tensor<2x100xf64, #BCOO>
return %0 : tensor<2x100xf64, #BCOO> return %0 : tensor<2x100xf64, #BCOO>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"], crdWidth=32}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"], crdWidth=32}>
// CHECK-LABEL: func @sparse_unpack( // CHECK-LABEL: func @sparse_unpack(
// CHECK-SAME: %[[T:.*]]: tensor<100xf64, # // CHECK-SAME: %[[T:.*]]: tensor<100xf64, #
// CHECK: %[[D:.*]], %[[I:.*]], %[[N:.*]] = sparse_tensor.unpack %[[T]] // CHECK: %[[D:.*]], %[[I:.*]], %[[N:.*]] = sparse_tensor.unpack %[[T]]
// CHECK: return %[[D]], %[[I]], %[[N]] // CHECK: return %[[D]], %[[I]], %[[N]]
func.func @sparse_unpack(%sp : tensor<100xf64, #SparseVector>) func.func @sparse_unpack(%sp : tensor<100xf64, #SparseVector>)
-> (tensor<6xf64>, tensor<6x1xi32>, i32) { -> (tensor<6xf64>, tensor<6x1xi32>, i32) {
%data, %indices, %nnz = sparse_tensor.unpack %sp : tensor<100xf64, #SparseVector> %data, %indices, %nnz = sparse_tensor.unpack %sp : tensor<100xf64, #SparseVector>
to tensor<6xf64>, tensor<6x1xi32>, i32 to tensor<6xf64>, tensor<6x1xi32>, i32
return %data, %indices, %nnz : tensor<6xf64>, tensor<6x1xi32>, i32 return %data, %indices, %nnz : tensor<6xf64>, tensor<6x1xi32>, i32
} }
// ----- // -----
#BatchedSparseVector = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed-hi"], crdWidth=32}> #BatchedSparseVector = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed-hi"], crdWidth=32}>
// CHECK-LABEL: func @sparse_unpack( // CHECK-LABEL: func @sparse_unpack(
// CHECK-SAME: %[[T:.*]]: tensor<2x100xf64, # // CHECK-SAME: %[[T:.*]]: tensor<2x100xf64, #
// CHECK: %[[D:.*]], %[[I:.*]], %[[N:.*]] = sparse_tensor.unpack %[[T]] batched_lvls = 1 // CHECK: %[[D:.*]], %[[I:.*]], %[[N:.*]] = sparse_tensor.unpack %[[T]] batched_lvls = 1
// CHECK: return %[[D]], %[[I]], %[[N]] // CHECK: return %[[D]], %[[I]], %[[N]]
func.func @sparse_unpack(%sp : tensor<2x100xf64, #BatchedSparseVector>) func.func @sparse_unpack(%sp : tensor<2x100xf64, #BatchedSparseVector>)
-> (tensor<2x6xf64>, tensor<2x6x1xi32>, i32) { -> (tensor<2x6xf64>, tensor<2x6x1xi32>, i32) {
%data, %indices, %nnz = sparse_tensor.unpack %sp batched_lvls=1 %data, %indices, %nnz = sparse_tensor.unpack %sp batched_lvls=1
: tensor<2x100xf64, #BatchedSparseVector> to tensor<2x6xf64>, tensor<2x6x1xi32>, i32 : tensor<2x100xf64, #BatchedSparseVector> to tensor<2x6xf64>, tensor<2x6x1xi32>, i32
return %data, %indices, %nnz : tensor<2x6xf64>, tensor<2x6x1xi32>, i32 return %data, %indices, %nnz : tensor<2x6xf64>, tensor<2x6x1xi32>, i32
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
// CHECK-LABEL: func @sparse_dealloc( // CHECK-LABEL: func @sparse_dealloc(
// CHECK-SAME: %[[A:.*]]: tensor<128xf64, #{{.*}}> // CHECK-SAME: %[[A:.*]]: tensor<128xf64, #{{.*}}>
// CHECK: bufferization.dealloc_tensor %[[A]] : tensor<128xf64, #{{.*}}> // CHECK: bufferization.dealloc_tensor %[[A]] : tensor<128xf64, #{{.*}}>
// CHECK: return // CHECK: return
func.func @sparse_dealloc(%arg0: tensor<128xf64, #SparseVector>) { func.func @sparse_dealloc(%arg0: tensor<128xf64, #SparseVector>) {
bufferization.dealloc_tensor %arg0 : tensor<128xf64, #SparseVector> bufferization.dealloc_tensor %arg0 : tensor<128xf64, #SparseVector>
return return
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
// CHECK-LABEL: func @sparse_convert_1d_to_sparse( // CHECK-LABEL: func @sparse_convert_1d_to_sparse(
// CHECK-SAME: %[[A:.*]]: tensor<64xf32>) // CHECK-SAME: %[[A:.*]]: tensor<64xf32>)
// CHECK: %[[T:.*]] = sparse_tensor.convert %[[A]] : tensor<64xf32> to tensor<64xf32, #{{.*}}> // CHECK: %[[T:.*]] = sparse_tensor.convert %[[A]] : tensor<64xf32> to tensor<64xf32, #{{.*}}>
// CHECK: return %[[T]] : tensor<64xf32, #{{.*}}> // CHECK: return %[[T]] : tensor<64xf32, #{{.*}}>
func.func @sparse_convert_1d_to_sparse(%arg0: tensor<64xf32>) -> tensor<64xf32, #SparseVector> { func.func @sparse_convert_1d_to_sparse(%arg0: tensor<64xf32>) -> tensor<64xf32, #SparseVector> {
%0 = sparse_tensor.convert %arg0 : tensor<64xf32> to tensor<64xf32, #SparseVector> %0 = sparse_tensor.convert %arg0 : tensor<64xf32> to tensor<64xf32, #SparseVector>
return %0 : tensor<64xf32, #SparseVector> return %0 : tensor<64xf32, #SparseVector>
} }
// ----- // -----
#SparseTensor = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }> #SparseTensor = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>
// CHECK-LABEL: func @sparse_convert_3d_from_sparse( // CHECK-LABEL: func @sparse_convert_3d_from_sparse(
// CHECK-SAME: %[[A:.*]]: tensor<8x8x8xf64, #{{.*}}>) // CHECK-SAME: %[[A:.*]]: tensor<8x8x8xf64, #{{.*}}>)
// CHECK: %[[T:.*]] = sparse_tensor.convert %[[A]] : tensor<8x8x8xf64, #{{.*}}> to tensor<8x8x8xf64> // CHECK: %[[T:.*]] = sparse_tensor.convert %[[A]] : tensor<8x8x8xf64, #{{.*}}> to tensor<8x8x8xf64>
// CHECK: return %[[T]] : tensor<8x8x8xf64> // CHECK: return %[[T]] : tensor<8x8x8xf64>
func.func @sparse_convert_3d_from_sparse(%arg0: tensor<8x8x8xf64, #SparseTensor>) -> tensor<8x8x8xf64> { func.func @sparse_convert_3d_from_sparse(%arg0: tensor<8x8x8xf64, #SparseTensor>) -> tensor<8x8x8xf64> {
%0 = sparse_tensor.convert %arg0 : tensor<8x8x8xf64, #SparseTensor> to tensor<8x8x8xf64> %0 = sparse_tensor.convert %arg0 : tensor<8x8x8xf64, #SparseTensor> to tensor<8x8x8xf64>
return %0 : tensor<8x8x8xf64> return %0 : tensor<8x8x8xf64>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
// CHECK-LABEL: func @sparse_positions( // CHECK-LABEL: func @sparse_positions(
// CHECK-SAME: %[[A:.*]]: tensor<128xf64, #{{.*}}>) // CHECK-SAME: %[[A:.*]]: tensor<128xf64, #{{.*}}>)
// CHECK: %[[T:.*]] = sparse_tensor.positions %[[A]] {level = 0 : index} : tensor<128xf64, #{{.*}}> to memref<?xindex> // CHECK: %[[T:.*]] = sparse_tensor.positions %[[A]] {level = 0 : index} : tensor<128xf64, #{{.*}}> to memref<?xindex>
// CHECK: return %[[T]] : memref<?xindex> // CHECK: return %[[T]] : memref<?xindex>
func.func @sparse_positions(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xindex> { func.func @sparse_positions(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xindex> {
%0 = sparse_tensor.positions %arg0 {level = 0 : index} : tensor<128xf64, #SparseVector> to memref<?xindex> %0 = sparse_tensor.positions %arg0 {level = 0 : index} : tensor<128xf64, #SparseVector> to memref<?xindex>
return %0 : memref<?xindex> return %0 : memref<?xindex>
} }
// ----- // -----
#COO = #sparse_tensor.encoding<{dimLevelType = ["compressed-nu", "singleton"]}> #COO = #sparse_tensor.encoding<{lvlTypes = ["compressed-nu", "singleton"]}>
// CHECK-LABEL: func @sparse_indices_buffer( // CHECK-LABEL: func @sparse_indices_buffer(
// CHECK-SAME: %[[A:.*]]: tensor<?x?xf64, #{{.*}}>) // CHECK-SAME: %[[A:.*]]: tensor<?x?xf64, #{{.*}}>)
// CHECK: %[[T:.*]] = sparse_tensor.coordinates_buffer %[[A]] : tensor<?x?xf64, #{{.*}}> to memref<?xindex> // CHECK: %[[T:.*]] = sparse_tensor.coordinates_buffer %[[A]] : tensor<?x?xf64, #{{.*}}> to memref<?xindex>
// CHECK: return %[[T]] : memref<?xindex> // CHECK: return %[[T]] : memref<?xindex>
func.func @sparse_indices_buffer(%arg0: tensor<?x?xf64, #COO>) -> memref<?xindex> { func.func @sparse_indices_buffer(%arg0: tensor<?x?xf64, #COO>) -> memref<?xindex> {
%0 = sparse_tensor.coordinates_buffer %arg0 : tensor<?x?xf64, #COO> to memref<?xindex> %0 = sparse_tensor.coordinates_buffer %arg0 : tensor<?x?xf64, #COO> to memref<?xindex>
return %0 : memref<?xindex> return %0 : memref<?xindex>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
// CHECK-LABEL: func @sparse_indices( // CHECK-LABEL: func @sparse_indices(
// CHECK-SAME: %[[A:.*]]: tensor<128xf64, #{{.*}}>) // CHECK-SAME: %[[A:.*]]: tensor<128xf64, #{{.*}}>)
// CHECK: %[[T:.*]] = sparse_tensor.coordinates %[[A]] {level = 0 : index} : tensor<128xf64, #{{.*}}> to memref<?xindex> // CHECK: %[[T:.*]] = sparse_tensor.coordinates %[[A]] {level = 0 : index} : tensor<128xf64, #{{.*}}> to memref<?xindex>
// CHECK: return %[[T]] : memref<?xindex> // CHECK: return %[[T]] : memref<?xindex>
func.func @sparse_indices(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xindex> { func.func @sparse_indices(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xindex> {
%0 = sparse_tensor.coordinates %arg0 {level = 0 : index} : tensor<128xf64, #SparseVector> to memref<?xindex> %0 = sparse_tensor.coordinates %arg0 {level = 0 : index} : tensor<128xf64, #SparseVector> to memref<?xindex>
return %0 : memref<?xindex> return %0 : memref<?xindex>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
// CHECK-LABEL: func @sparse_values( // CHECK-LABEL: func @sparse_values(
// CHECK-SAME: %[[A:.*]]: tensor<128xf64, #{{.*}}>) // CHECK-SAME: %[[A:.*]]: tensor<128xf64, #{{.*}}>)
// CHECK: %[[T:.*]] = sparse_tensor.values %[[A]] : tensor<128xf64, #{{.*}}> to memref<?xf64> // CHECK: %[[T:.*]] = sparse_tensor.values %[[A]] : tensor<128xf64, #{{.*}}> to memref<?xf64>
// CHECK: return %[[T]] : memref<?xf64> // CHECK: return %[[T]] : memref<?xf64>
func.func @sparse_values(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xf64> { func.func @sparse_values(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xf64> {
%0 = sparse_tensor.values %arg0 : tensor<128xf64, #SparseVector> to memref<?xf64> %0 = sparse_tensor.values %arg0 : tensor<128xf64, #SparseVector> to memref<?xf64>
return %0 : memref<?xf64> return %0 : memref<?xf64>
} }
// ----- // -----
#CSR_SLICE = #sparse_tensor.encoding<{ #CSR_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (1, 4, 1), (1, 4, 2) ] slice = [ (1, 4, 1), (1, 4, 2) ]
}> }>
// CHECK-LABEL: func @sparse_slice_offset( // CHECK-LABEL: func @sparse_slice_offset(
// CHECK-SAME: %[[A:.*]]: tensor<2x8xf64, #{{.*}}>) // CHECK-SAME: %[[A:.*]]: tensor<2x8xf64, #{{.*}}>)
// CHECK: %[[T:.*]] = sparse_tensor.slice.offset %[[A]] at 1 : tensor<2x8xf64, #{{.*}}> // CHECK: %[[T:.*]] = sparse_tensor.slice.offset %[[A]] at 1 : tensor<2x8xf64, #{{.*}}>
// CHECK: return %[[T]] : index // CHECK: return %[[T]] : index
func.func @sparse_slice_offset(%arg0: tensor<2x8xf64, #CSR_SLICE>) -> index { func.func @sparse_slice_offset(%arg0: tensor<2x8xf64, #CSR_SLICE>) -> index {
%0 = sparse_tensor.slice.offset %arg0 at 1 : tensor<2x8xf64, #CSR_SLICE> %0 = sparse_tensor.slice.offset %arg0 at 1 : tensor<2x8xf64, #CSR_SLICE>
return %0 : index return %0 : index
} }
// ----- // -----
#CSR_SLICE = #sparse_tensor.encoding<{ #CSR_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (1, 4, 1), (1, 4, 2) ] slice = [ (1, 4, 1), (1, 4, 2) ]
}> }>
// CHECK-LABEL: func @sparse_slice_stride( // CHECK-LABEL: func @sparse_slice_stride(
// CHECK-SAME: %[[A:.*]]: tensor<2x8xf64, #{{.*}}>) // CHECK-SAME: %[[A:.*]]: tensor<2x8xf64, #{{.*}}>)
// CHECK: %[[T:.*]] = sparse_tensor.slice.stride %[[A]] at 1 : tensor<2x8xf64, #{{.*}}> // CHECK: %[[T:.*]] = sparse_tensor.slice.stride %[[A]] at 1 : tensor<2x8xf64, #{{.*}}>
// CHECK: return %[[T]] : index // CHECK: return %[[T]] : index
func.func @sparse_slice_stride(%arg0: tensor<2x8xf64, #CSR_SLICE>) -> index { func.func @sparse_slice_stride(%arg0: tensor<2x8xf64, #CSR_SLICE>) -> index {
%0 = sparse_tensor.slice.stride %arg0 at 1 : tensor<2x8xf64, #CSR_SLICE> %0 = sparse_tensor.slice.stride %arg0 at 1 : tensor<2x8xf64, #CSR_SLICE>
return %0 : index return %0 : index
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
// CHECK-LABEL: func @sparse_metadata_init( // CHECK-LABEL: func @sparse_metadata_init(
// CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.init : !sparse_tensor.storage_specifier<#{{.*}}> // CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.init : !sparse_tensor.storage_specifier<#{{.*}}>
// CHECK: return %[[T]] : !sparse_tensor.storage_specifier<#{{.*}}> // CHECK: return %[[T]] : !sparse_tensor.storage_specifier<#{{.*}}>
func.func @sparse_metadata_init() -> !sparse_tensor.storage_specifier<#SparseVector> { func.func @sparse_metadata_init() -> !sparse_tensor.storage_specifier<#SparseVector> {
%0 = sparse_tensor.storage_specifier.init : !sparse_tensor.storage_specifier<#SparseVector> %0 = sparse_tensor.storage_specifier.init : !sparse_tensor.storage_specifier<#SparseVector>
return %0 : !sparse_tensor.storage_specifier<#SparseVector> return %0 : !sparse_tensor.storage_specifier<#SparseVector>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#SparseVector_Slice = #sparse_tensor.encoding<{ #SparseVector_Slice = #sparse_tensor.encoding<{
dimLevelType = ["compressed"], lvlTypes = ["compressed"],
slice = [ (?, ?, ?) ] slice = [ (?, ?, ?) ]
}> }>
// CHECK-LABEL: func @sparse_metadata_init( // CHECK-LABEL: func @sparse_metadata_init(
// CHECK-SAME: %[[A:.*]]: !sparse_tensor.storage_specifier<#{{.*}}> // CHECK-SAME: %[[A:.*]]: !sparse_tensor.storage_specifier<#{{.*}}>
// CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.init with %[[A]] : // CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.init with %[[A]] :
// CHECK: return %[[T]] : !sparse_tensor.storage_specifier<#{{.*}}> // CHECK: return %[[T]] : !sparse_tensor.storage_specifier<#{{.*}}>
func.func @sparse_metadata_init(%src : !sparse_tensor.storage_specifier<#SparseVector>) func.func @sparse_metadata_init(%src : !sparse_tensor.storage_specifier<#SparseVector>)
-> !sparse_tensor.storage_specifier<#SparseVector_Slice> { -> !sparse_tensor.storage_specifier<#SparseVector_Slice> {
%0 = sparse_tensor.storage_specifier.init with %src : from !sparse_tensor.storage_specifier<#SparseVector> %0 = sparse_tensor.storage_specifier.init with %src : from !sparse_tensor.storage_specifier<#SparseVector>
to !sparse_tensor.storage_specifier<#SparseVector_Slice> to !sparse_tensor.storage_specifier<#SparseVector_Slice>
return %0 : !sparse_tensor.storage_specifier<#SparseVector_Slice> return %0 : !sparse_tensor.storage_specifier<#SparseVector_Slice>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
// CHECK-LABEL: func @sparse_get_md( // CHECK-LABEL: func @sparse_get_md(
// CHECK-SAME: %[[A:.*]]: !sparse_tensor.storage_specifier<#{{.*}}> // CHECK-SAME: %[[A:.*]]: !sparse_tensor.storage_specifier<#{{.*}}>
// CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.get %[[A]] lvl_sz at 0 // CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.get %[[A]] lvl_sz at 0
// CHECK: return %[[T]] : index // CHECK: return %[[T]] : index
func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>) -> index { func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>) -> index {
%0 = sparse_tensor.storage_specifier.get %arg0 lvl_sz at 0 %0 = sparse_tensor.storage_specifier.get %arg0 lvl_sz at 0
: !sparse_tensor.storage_specifier<#SparseVector> : !sparse_tensor.storage_specifier<#SparseVector>
return %0 : index return %0 : index
} }
// ----- // -----
#SparseVector_Slice = #sparse_tensor.encoding<{ #SparseVector_Slice = #sparse_tensor.encoding<{
dimLevelType = ["compressed"], lvlTypes = ["compressed"],
slice = [ (?, ?, ?) ] slice = [ (?, ?, ?) ]
}> }>
// CHECK-LABEL: func @sparse_get_md( // CHECK-LABEL: func @sparse_get_md(
// CHECK-SAME: %[[A:.*]]: !sparse_tensor.storage_specifier<#{{.*}}> // CHECK-SAME: %[[A:.*]]: !sparse_tensor.storage_specifier<#{{.*}}>
// CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.get %[[A]] dim_offset at 0 // CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.get %[[A]] dim_offset at 0
// CHECK: return %[[T]] : index // CHECK: return %[[T]] : index
func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector_Slice>) -> index { func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector_Slice>) -> index {
%0 = sparse_tensor.storage_specifier.get %arg0 dim_offset at 0 %0 = sparse_tensor.storage_specifier.get %arg0 dim_offset at 0
: !sparse_tensor.storage_specifier<#SparseVector_Slice> : !sparse_tensor.storage_specifier<#SparseVector_Slice>
return %0 : index return %0 : index
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"], lvlTypes = ["compressed"],
slice = [ (?, ?, ?) ] slice = [ (?, ?, ?) ]
}> }>
// CHECK-LABEL: func @sparse_get_md( // CHECK-LABEL: func @sparse_get_md(
// CHECK-SAME: %[[A:.*]]: !sparse_tensor.storage_specifier<#{{.*}}> // CHECK-SAME: %[[A:.*]]: !sparse_tensor.storage_specifier<#{{.*}}>
// CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.get %[[A]] dim_stride at 0 // CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.get %[[A]] dim_stride at 0
// CHECK: return %[[T]] : index // CHECK: return %[[T]] : index
func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>) -> index { func.func @sparse_get_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>) -> index {
%0 = sparse_tensor.storage_specifier.get %arg0 dim_stride at 0 %0 = sparse_tensor.storage_specifier.get %arg0 dim_stride at 0
: !sparse_tensor.storage_specifier<#SparseVector> : !sparse_tensor.storage_specifier<#SparseVector>
return %0 : index return %0 : index
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
// CHECK-LABEL: func @sparse_set_md( // CHECK-LABEL: func @sparse_set_md(
// CHECK-SAME: %[[A:.*]]: !sparse_tensor.storage_specifier<#{{.*}}>, // CHECK-SAME: %[[A:.*]]: !sparse_tensor.storage_specifier<#{{.*}}>,
// CHECK-SAME: %[[I:.*]]: index) // CHECK-SAME: %[[I:.*]]: index)
// CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.set %[[A]] lvl_sz at 0 with %[[I]] // CHECK: %[[T:.*]] = sparse_tensor.storage_specifier.set %[[A]] lvl_sz at 0 with %[[I]]
// CHECK: return %[[T]] : !sparse_tensor.storage_specifier<#{{.*}}> // CHECK: return %[[T]] : !sparse_tensor.storage_specifier<#{{.*}}>
func.func @sparse_set_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>, %arg1: index) func.func @sparse_set_md(%arg0: !sparse_tensor.storage_specifier<#SparseVector>, %arg1: index)
-> !sparse_tensor.storage_specifier<#SparseVector> { -> !sparse_tensor.storage_specifier<#SparseVector> {
%0 = sparse_tensor.storage_specifier.set %arg0 lvl_sz at 0 with %arg1 %0 = sparse_tensor.storage_specifier.set %arg0 lvl_sz at 0 with %arg1
: !sparse_tensor.storage_specifier<#SparseVector> : !sparse_tensor.storage_specifier<#SparseVector>
return %0 : !sparse_tensor.storage_specifier<#SparseVector> return %0 : !sparse_tensor.storage_specifier<#SparseVector>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
// CHECK-LABEL: func @sparse_noe( // CHECK-LABEL: func @sparse_noe(
// CHECK-SAME: %[[A:.*]]: tensor<128xf64, #{{.*}}>) // CHECK-SAME: %[[A:.*]]: tensor<128xf64, #{{.*}}>)
// CHECK: %[[T:.*]] = sparse_tensor.number_of_entries %[[A]] : tensor<128xf64, #{{.*}}> // CHECK: %[[T:.*]] = sparse_tensor.number_of_entries %[[A]] : tensor<128xf64, #{{.*}}>
// CHECK: return %[[T]] : index // CHECK: return %[[T]] : index
func.func @sparse_noe(%arg0: tensor<128xf64, #SparseVector>) -> index { func.func @sparse_noe(%arg0: tensor<128xf64, #SparseVector>) -> index {
%0 = sparse_tensor.number_of_entries %arg0 : tensor<128xf64, #SparseVector> %0 = sparse_tensor.number_of_entries %arg0 : tensor<128xf64, #SparseVector>
return %0 : index return %0 : index
} }
// ----- // -----
#DenseMatrix = #sparse_tensor.encoding<{dimLevelType = ["dense","dense"]}> #DenseMatrix = #sparse_tensor.encoding<{lvlTypes = ["dense","dense"]}>
// CHECK-LABEL: func @sparse_load( // CHECK-LABEL: func @sparse_load(
// CHECK-SAME: %[[A:.*]]: tensor<16x32xf64, #{{.*}}>) // CHECK-SAME: %[[A:.*]]: tensor<16x32xf64, #{{.*}}>)
// CHECK: %[[T:.*]] = sparse_tensor.load %[[A]] : tensor<16x32xf64, #{{.*}}> // CHECK: %[[T:.*]] = sparse_tensor.load %[[A]] : tensor<16x32xf64, #{{.*}}>
// CHECK: return %[[T]] : tensor<16x32xf64, #{{.*}}> // CHECK: return %[[T]] : tensor<16x32xf64, #{{.*}}>
func.func @sparse_load(%arg0: tensor<16x32xf64, #DenseMatrix>) -> tensor<16x32xf64, #DenseMatrix> { func.func @sparse_load(%arg0: tensor<16x32xf64, #DenseMatrix>) -> tensor<16x32xf64, #DenseMatrix> {
%0 = sparse_tensor.load %arg0 : tensor<16x32xf64, #DenseMatrix> %0 = sparse_tensor.load %arg0 : tensor<16x32xf64, #DenseMatrix>
return %0 : tensor<16x32xf64, #DenseMatrix> return %0 : tensor<16x32xf64, #DenseMatrix>
} }
// ----- // -----
#DenseMatrix = #sparse_tensor.encoding<{dimLevelType = ["dense","dense"]}> #DenseMatrix = #sparse_tensor.encoding<{lvlTypes = ["dense","dense"]}>
// CHECK-LABEL: func @sparse_load_ins( // CHECK-LABEL: func @sparse_load_ins(
// CHECK-SAME: %[[A:.*]]: tensor<16x32xf64, #{{.*}}>) // CHECK-SAME: %[[A:.*]]: tensor<16x32xf64, #{{.*}}>)
// CHECK: %[[T:.*]] = sparse_tensor.load %[[A]] hasInserts : tensor<16x32xf64, #{{.*}}> // CHECK: %[[T:.*]] = sparse_tensor.load %[[A]] hasInserts : tensor<16x32xf64, #{{.*}}>
// CHECK: return %[[T]] : tensor<16x32xf64, #{{.*}}> // CHECK: return %[[T]] : tensor<16x32xf64, #{{.*}}>
func.func @sparse_load_ins(%arg0: tensor<16x32xf64, #DenseMatrix>) -> tensor<16x32xf64, #DenseMatrix> { func.func @sparse_load_ins(%arg0: tensor<16x32xf64, #DenseMatrix>) -> tensor<16x32xf64, #DenseMatrix> {
%0 = sparse_tensor.load %arg0 hasInserts : tensor<16x32xf64, #DenseMatrix> %0 = sparse_tensor.load %arg0 hasInserts : tensor<16x32xf64, #DenseMatrix>
return %0 : tensor<16x32xf64, #DenseMatrix> return %0 : tensor<16x32xf64, #DenseMatrix>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
// CHECK-LABEL: func @sparse_insert( // CHECK-LABEL: func @sparse_insert(
// CHECK-SAME: %[[A:.*]]: tensor<128xf64, #sparse_tensor.encoding<{{.*}}>>, // CHECK-SAME: %[[A:.*]]: tensor<128xf64, #sparse_tensor.encoding<{{.*}}>>,
// CHECK-SAME: %[[B:.*]]: index, // CHECK-SAME: %[[B:.*]]: index,
// CHECK-SAME: %[[C:.*]]: f64) // CHECK-SAME: %[[C:.*]]: f64)
// CHECK: %[[T:.*]] = sparse_tensor.insert %[[C]] into %[[A]][%[[B]]] : tensor<128xf64, #{{.*}}> // CHECK: %[[T:.*]] = sparse_tensor.insert %[[C]] into %[[A]][%[[B]]] : tensor<128xf64, #{{.*}}>
// CHECK: return %[[T]] : tensor<128xf64, #{{.*}}> // CHECK: return %[[T]] : tensor<128xf64, #{{.*}}>
func.func @sparse_insert(%arg0: tensor<128xf64, #SparseVector>, %arg1: index, %arg2: f64) -> tensor<128xf64, #SparseVector> { func.func @sparse_insert(%arg0: tensor<128xf64, #SparseVector>, %arg1: index, %arg2: f64) -> tensor<128xf64, #SparseVector> {
Show All 38 Lines
// CHECK: return %[[E]] // CHECK: return %[[E]]
func.func @sparse_push_back_n(%arg0: index, %arg1: memref<?xf64>, %arg2: f64, %arg3: index) -> (memref<?xf64>, index) { func.func @sparse_push_back_n(%arg0: index, %arg1: memref<?xf64>, %arg2: f64, %arg3: index) -> (memref<?xf64>, index) {
%0:2 = sparse_tensor.push_back %arg0, %arg1, %arg2, %arg3 : index, memref<?xf64>, f64, index %0:2 = sparse_tensor.push_back %arg0, %arg1, %arg2, %arg3 : index, memref<?xf64>, f64, index
return %0#0, %0#1 : memref<?xf64>, index return %0#0, %0#1 : memref<?xf64>, index
} }
// ----- // -----
#SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #SparseMatrix = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// CHECK-LABEL: func @sparse_expansion( // CHECK-LABEL: func @sparse_expansion(
// CHECK-SAME: %[[A:.*]]: tensor<8x8xf64, #sparse_tensor.encoding<{{.*}}>>) // CHECK-SAME: %[[A:.*]]: tensor<8x8xf64, #sparse_tensor.encoding<{{.*}}>>)
// CHECK: %{{.*}}, %{{.*}}, %{{.*}}, %[[T:.*]] = sparse_tensor.expand %[[A]] // CHECK: %{{.*}}, %{{.*}}, %{{.*}}, %[[T:.*]] = sparse_tensor.expand %[[A]]
// CHECK: return %[[T]] : index // CHECK: return %[[T]] : index
func.func @sparse_expansion(%tensor: tensor<8x8xf64, #SparseMatrix>) -> index { func.func @sparse_expansion(%tensor: tensor<8x8xf64, #SparseMatrix>) -> index {
%values, %filled, %added, %count = sparse_tensor.expand %tensor %values, %filled, %added, %count = sparse_tensor.expand %tensor
: tensor<8x8xf64, #SparseMatrix> to memref<?xf64>, memref<?xi1>, memref<?xindex> : tensor<8x8xf64, #SparseMatrix> to memref<?xf64>, memref<?xi1>, memref<?xindex>
return %count : index return %count : index
} }
// ----- // -----
#SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #SparseMatrix = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// CHECK-LABEL: func @sparse_compression( // CHECK-LABEL: func @sparse_compression(
// CHECK-SAME: %[[A0:.*0]]: memref<?xf64>, // CHECK-SAME: %[[A0:.*0]]: memref<?xf64>,
// CHECK-SAME: %[[A1:.*1]]: memref<?xi1>, // CHECK-SAME: %[[A1:.*1]]: memref<?xi1>,
// CHECK-SAME: %[[A2:.*2]]: memref<?xindex>, // CHECK-SAME: %[[A2:.*2]]: memref<?xindex>,
// CHECK-SAME: %[[A3:.*3]]: index // CHECK-SAME: %[[A3:.*3]]: index
// CHECK-SAME: %[[A4:.*4]]: tensor<8x8xf64, #sparse_tensor.encoding<{{.*}}>>, // CHECK-SAME: %[[A4:.*4]]: tensor<8x8xf64, #sparse_tensor.encoding<{{.*}}>>,
// CHECK-SAME: %[[A5:.*5]]: index) // CHECK-SAME: %[[A5:.*5]]: index)
// CHECK: %[[T:.*]] = sparse_tensor.compress %[[A0]], %[[A1]], %[[A2]], %[[A3]] into %[[A4]][%[[A5]] // CHECK: %[[T:.*]] = sparse_tensor.compress %[[A0]], %[[A1]], %[[A2]], %[[A3]] into %[[A4]][%[[A5]]
// CHECK: return %[[T]] : tensor<8x8xf64, #sparse_tensor.encoding<{{.*}}>> // CHECK: return %[[T]] : tensor<8x8xf64, #sparse_tensor.encoding<{{.*}}>>
func.func @sparse_compression(%values: memref<?xf64>, func.func @sparse_compression(%values: memref<?xf64>,
%filled: memref<?xi1>, %filled: memref<?xi1>,
%added: memref<?xindex>, %added: memref<?xindex>,
%count: index, %count: index,
%tensor: tensor<8x8xf64, #SparseMatrix>, %tensor: tensor<8x8xf64, #SparseMatrix>,
%index: index) -> tensor<8x8xf64, #SparseMatrix> { %index: index) -> tensor<8x8xf64, #SparseMatrix> {
%0 = sparse_tensor.compress %values, %filled, %added, %count into %tensor[%index] %0 = sparse_tensor.compress %values, %filled, %added, %count into %tensor[%index]
: memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<8x8xf64, #SparseMatrix> : memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<8x8xf64, #SparseMatrix>
return %0 : tensor<8x8xf64, #SparseMatrix> return %0 : tensor<8x8xf64, #SparseMatrix>
} }
// ----- // -----
#SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #SparseMatrix = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// CHECK-LABEL: func @sparse_out( // CHECK-LABEL: func @sparse_out(
// CHECK-SAME: %[[A:.*]]: tensor<?x?xf64, #sparse_tensor.encoding<{{.*}}>>, // CHECK-SAME: %[[A:.*]]: tensor<?x?xf64, #sparse_tensor.encoding<{{.*}}>>,
// CHECK-SAME: %[[B:.*]]: !llvm.ptr<i8>) // CHECK-SAME: %[[B:.*]]: !llvm.ptr<i8>)
// CHECK: sparse_tensor.out %[[A]], %[[B]] : tensor<?x?xf64, #sparse_tensor.encoding<{{.*}}>>, !llvm.ptr<i8> // CHECK: sparse_tensor.out %[[A]], %[[B]] : tensor<?x?xf64, #sparse_tensor.encoding<{{.*}}>>, !llvm.ptr<i8>
// CHECK: return // CHECK: return
func.func @sparse_out(%arg0: tensor<?x?xf64, #SparseMatrix>, %arg1: !llvm.ptr<i8>) { func.func @sparse_out(%arg0: tensor<?x?xf64, #SparseMatrix>, %arg1: !llvm.ptr<i8>) {
sparse_tensor.out %arg0, %arg1 : tensor<?x?xf64, #SparseMatrix>, !llvm.ptr<i8> sparse_tensor.out %arg0, %arg1 : tensor<?x?xf64, #SparseMatrix>, !llvm.ptr<i8>
return return
} }
// ----- // -----
#SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #SparseMatrix = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// CHECK-LABEL: func @sparse_binary( // CHECK-LABEL: func @sparse_binary(
// CHECK-SAME: %[[A:.*]]: f64, %[[B:.*]]: i64) -> f64 { // CHECK-SAME: %[[A:.*]]: f64, %[[B:.*]]: i64) -> f64 {
// CHECK: %[[Z:.*]] = arith.constant 0.000000e+00 : f64 // CHECK: %[[Z:.*]] = arith.constant 0.000000e+00 : f64
// CHECK: %[[C1:.*]] = sparse_tensor.binary %[[A]], %[[B]] : f64, i64 to f64 // CHECK: %[[C1:.*]] = sparse_tensor.binary %[[A]], %[[B]] : f64, i64 to f64
// CHECK: overlap = { // CHECK: overlap = {
// CHECK: ^bb0(%[[A1:.*]]: f64, %[[B1:.*]]: i64): // CHECK: ^bb0(%[[A1:.*]]: f64, %[[B1:.*]]: i64):
// CHECK: sparse_tensor.yield %[[A1]] : f64 // CHECK: sparse_tensor.yield %[[A1]] : f64
Show All 17 Lines right={
^bb0(%y: i64): ^bb0(%y: i64):
sparse_tensor.yield %cf0 : f64 sparse_tensor.yield %cf0 : f64
} }
return %r : f64 return %r : f64
} }
// ----- // -----
#SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #SparseMatrix = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// CHECK-LABEL: func @sparse_unary( // CHECK-LABEL: func @sparse_unary(
// CHECK-SAME: %[[A:.*]]: f64) -> f64 { // CHECK-SAME: %[[A:.*]]: f64) -> f64 {
// CHECK: %[[C1:.*]] = sparse_tensor.unary %[[A]] : f64 to f64 // CHECK: %[[C1:.*]] = sparse_tensor.unary %[[A]] : f64 to f64
// CHECK: present = { // CHECK: present = {
// CHECK: ^bb0(%[[A1:.*]]: f64): // CHECK: ^bb0(%[[A1:.*]]: f64):
// CHECK: sparse_tensor.yield %[[A1]] : f64 // CHECK: sparse_tensor.yield %[[A1]] : f64
// CHECK: } // CHECK: }
Show All 13 Lines present={
%cf1 = arith.constant -1.0 : f64 %cf1 = arith.constant -1.0 : f64
sparse_tensor.yield %cf1 : f64 sparse_tensor.yield %cf1 : f64
} }
return %r : f64 return %r : f64
} }
// ----- // -----
#SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #SparseMatrix = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// CHECK-LABEL: func @sparse_unary( // CHECK-LABEL: func @sparse_unary(
// CHECK-SAME: %[[A:.*]]: f64) -> i64 { // CHECK-SAME: %[[A:.*]]: f64) -> i64 {
// CHECK: %[[C1:.*]] = sparse_tensor.unary %[[A]] : f64 to i64 // CHECK: %[[C1:.*]] = sparse_tensor.unary %[[A]] : f64 to i64
// CHECK: present = { // CHECK: present = {
// CHECK: ^bb0(%[[A1:.*]]: f64): // CHECK: ^bb0(%[[A1:.*]]: f64):
// CHECK: %[[R:.*]] = arith.fptosi %[[A1]] : f64 to i64 // CHECK: %[[R:.*]] = arith.fptosi %[[A1]] : f64 to i64
// CHECK: sparse_tensor.yield %[[R]] : i64 // CHECK: sparse_tensor.yield %[[R]] : i64
Show All 10 Lines present={
sparse_tensor.yield %ret : i64 sparse_tensor.yield %ret : i64
} }
absent={} absent={}
return %r : i64 return %r : i64
} }
// ----- // -----
#SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #SparseMatrix = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// CHECK-LABEL: func @sparse_reduce_2d_to_1d( // CHECK-LABEL: func @sparse_reduce_2d_to_1d(
// CHECK-SAME: %[[A:.*]]: f64, %[[B:.*]]: f64) -> f64 { // CHECK-SAME: %[[A:.*]]: f64, %[[B:.*]]: f64) -> f64 {
// CHECK: %[[Z:.*]] = arith.constant 0.000000e+00 : f64 // CHECK: %[[Z:.*]] = arith.constant 0.000000e+00 : f64
// CHECK: %[[C1:.*]] = sparse_tensor.reduce %[[A]], %[[B]], %[[Z]] : f64 { // CHECK: %[[C1:.*]] = sparse_tensor.reduce %[[A]], %[[B]], %[[Z]] : f64 {
// CHECK: ^bb0(%[[A1:.*]]: f64, %[[B1:.*]]: f64): // CHECK: ^bb0(%[[A1:.*]]: f64, %[[B1:.*]]: f64):
// CHECK: sparse_tensor.yield %[[A1]] : f64 // CHECK: sparse_tensor.yield %[[A1]] : f64
// CHECK: } // CHECK: }
// CHECK: return %[[C1]] : f64 // CHECK: return %[[C1]] : f64
// CHECK: } // CHECK: }
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
} }
// ----- // -----
#SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #SparseMatrix = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// CHECK-LABEL: func @sparse_select( // CHECK-LABEL: func @sparse_select(
// CHECK-SAME: %[[A:.*]]: f64) -> f64 { // CHECK-SAME: %[[A:.*]]: f64) -> f64 {
// CHECK: %[[Z:.*]] = arith.constant 0.000000e+00 : f64 // CHECK: %[[Z:.*]] = arith.constant 0.000000e+00 : f64
// CHECK: %[[C1:.*]] = sparse_tensor.select %[[A]] : f64 { // CHECK: %[[C1:.*]] = sparse_tensor.select %[[A]] : f64 {
// CHECK: ^bb0(%[[A1:.*]]: f64): // CHECK: ^bb0(%[[A1:.*]]: f64):
// CHECK: %[[B1:.*]] = arith.cmpf ogt, %[[A1]], %[[Z]] : f64 // CHECK: %[[B1:.*]] = arith.cmpf ogt, %[[A1]], %[[Z]] : f64
// CHECK: sparse_tensor.yield %[[B1]] : i1 // CHECK: sparse_tensor.yield %[[B1]] : i1
// CHECK: } // CHECK: }
// CHECK: return %[[C1]] : f64 // CHECK: return %[[C1]] : f64
// CHECK: } // CHECK: }
func.func @sparse_select(%arg0: f64) -> f64 { func.func @sparse_select(%arg0: f64) -> f64 {
%cf0 = arith.constant 0.0 : f64 %cf0 = arith.constant 0.0 : f64
%r = sparse_tensor.select %arg0 : f64 { %r = sparse_tensor.select %arg0 : f64 {
^bb0(%x: f64): ^bb0(%x: f64):
%cmp = arith.cmpf "ogt", %x, %cf0 : f64 %cmp = arith.cmpf "ogt", %x, %cf0 : f64
sparse_tensor.yield %cmp : i1 sparse_tensor.yield %cmp : i1
} }
return %r : f64 return %r : f64
} }
// ----- // -----
#SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #SparseMatrix = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// CHECK-LABEL: func @concat_sparse_sparse( // CHECK-LABEL: func @concat_sparse_sparse(
// CHECK-SAME: %[[A0:.*]]: tensor<2x4xf64 // CHECK-SAME: %[[A0:.*]]: tensor<2x4xf64
// CHECK-SAME: %[[A1:.*]]: tensor<3x4xf64 // CHECK-SAME: %[[A1:.*]]: tensor<3x4xf64
// CHECK-SAME: %[[A2:.*]]: tensor<4x4xf64 // CHECK-SAME: %[[A2:.*]]: tensor<4x4xf64
// CHECK: %[[TMP0:.*]] = sparse_tensor.concatenate %[[A0]], %[[A1]], %[[A2]] {dimension = 0 : index} : // CHECK: %[[TMP0:.*]] = sparse_tensor.concatenate %[[A0]], %[[A1]], %[[A2]] {dimension = 0 : index} :
// CHECK-SAME: tensor<2x4xf64 // CHECK-SAME: tensor<2x4xf64
// CHECK-SAME: tensor<3x4xf64 // CHECK-SAME: tensor<3x4xf64
// CHECK-SAME: tensor<4x4xf64 // CHECK-SAME: tensor<4x4xf64
// CHECK-SAME: tensor<9x4xf64 // CHECK-SAME: tensor<9x4xf64
// CHECK: return %[[TMP0]] : tensor<9x4xf64 // CHECK: return %[[TMP0]] : tensor<9x4xf64
func.func @concat_sparse_sparse(%arg0: tensor<2x4xf64, #SparseMatrix>, func.func @concat_sparse_sparse(%arg0: tensor<2x4xf64, #SparseMatrix>,
%arg1: tensor<3x4xf64, #SparseMatrix>, %arg1: tensor<3x4xf64, #SparseMatrix>,
%arg2: tensor<4x4xf64, #SparseMatrix>) -> tensor<9x4xf64, #SparseMatrix> { %arg2: tensor<4x4xf64, #SparseMatrix>) -> tensor<9x4xf64, #SparseMatrix> {
%0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index} %0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index}
: tensor<2x4xf64, #SparseMatrix>, : tensor<2x4xf64, #SparseMatrix>,
tensor<3x4xf64, #SparseMatrix>, tensor<3x4xf64, #SparseMatrix>,
tensor<4x4xf64, #SparseMatrix> to tensor<9x4xf64, #SparseMatrix> tensor<4x4xf64, #SparseMatrix> to tensor<9x4xf64, #SparseMatrix>
return %0 : tensor<9x4xf64, #SparseMatrix> return %0 : tensor<9x4xf64, #SparseMatrix>
} }
// ----- // -----
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// CHECK-LABEL: func @sparse_tensor_foreach( // CHECK-LABEL: func @sparse_tensor_foreach(
// CHECK-SAME: %[[A0:.*]]: tensor<2x4xf64 // CHECK-SAME: %[[A0:.*]]: tensor<2x4xf64
// CHECK: sparse_tensor.foreach in %[[A0]] : // CHECK: sparse_tensor.foreach in %[[A0]] :
// CHECK: ^bb0(%arg1: index, %arg2: index, %arg3: f64): // CHECK: ^bb0(%arg1: index, %arg2: index, %arg3: f64):
func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>) -> () { func.func @sparse_tensor_foreach(%arg0: tensor<2x4xf64, #DCSR>) -> () {
sparse_tensor.foreach in %arg0 : tensor<2x4xf64, #DCSR> do { sparse_tensor.foreach in %arg0 : tensor<2x4xf64, #DCSR> do {
^bb0(%1: index, %2: index, %v: f64) : ^bb0(%1: index, %2: index, %v: f64) :
} }
return return
} }
// ----- // -----
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// CHECK-LABEL: func @sparse_tensor_foreach( // CHECK-LABEL: func @sparse_tensor_foreach(
// CHECK-SAME: %[[A0:.*]]: tensor<2x4xf64, #sparse_tensor.encoding<{{{.*}}}>>, // CHECK-SAME: %[[A0:.*]]: tensor<2x4xf64, #sparse_tensor.encoding<{{{.*}}}>>,
// CHECK-SAME: %[[A1:.*]]: f32 // CHECK-SAME: %[[A1:.*]]: f32
// CHECK-NEXT: %[[RET:.*]] = sparse_tensor.foreach in %[[A0]] init(%[[A1]]) // CHECK-NEXT: %[[RET:.*]] = sparse_tensor.foreach in %[[A0]] init(%[[A1]])
// CHECK-NEXT: ^bb0(%[[TMP_1:.*]]: index, %[[TMP_2:.*]]: index, %[[TMP_v:.*]]: f64, %[[TMP_r:.*]]: f32) // CHECK-NEXT: ^bb0(%[[TMP_1:.*]]: index, %[[TMP_2:.*]]: index, %[[TMP_v:.*]]: f64, %[[TMP_r:.*]]: f32)
// CHECK: sparse_tensor.yield %[[TMP_r]] : f32 // CHECK: sparse_tensor.yield %[[TMP_r]] : f32
// CHECK: } // CHECK: }
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/roundtrip_encoding.mlir

// RUN: mlir-opt %s -split-input-file | mlir-opt | FileCheck %s // RUN: mlir-opt %s -split-input-file | mlir-opt | FileCheck %s
// CHECK-LABEL: func private @sparse_1d_tensor( // CHECK-LABEL: func private @sparse_1d_tensor(
// CHECK-SAME: tensor<32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) // CHECK-SAME: tensor<32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>)
func.func private @sparse_1d_tensor(tensor<32xf64, #sparse_tensor.encoding<{ dimLevelType = ["compressed"] }>>) func.func private @sparse_1d_tensor(tensor<32xf64, #sparse_tensor.encoding<{ lvlTypes = ["compressed"] }>>)
// ----- // -----
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (i,j)>, dimOrdering = affine_map<(i,j) -> (i,j)>,
posWidth = 64, posWidth = 64,
crdWidth = 64 crdWidth = 64
}> }>
// CHECK-LABEL: func private @sparse_csr( // CHECK-LABEL: func private @sparse_csr(
// CHECK-SAME: tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ], posWidth = 64, crdWidth = 64 }>>) // CHECK-SAME: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], posWidth = 64, crdWidth = 64 }>>)
func.func private @sparse_csr(tensor<?x?xf32, #CSR>) func.func private @sparse_csr(tensor<?x?xf32, #CSR>)
// ----- // -----
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)>, dimOrdering = affine_map<(i,j) -> (j,i)>,
posWidth = 0, posWidth = 0,
crdWidth = 0 crdWidth = 0
}> }>
// CHECK-LABEL: func private @sparse_csc( // CHECK-LABEL: func private @sparse_csc(
// CHECK-SAME: tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>) // CHECK-SAME: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>)
func.func private @sparse_csc(tensor<?x?xf32, #CSC>) func.func private @sparse_csc(tensor<?x?xf32, #CSC>)
// ----- // -----
#DCSC = #sparse_tensor.encoding<{ #DCSC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)>, dimOrdering = affine_map<(i,j) -> (j,i)>,
posWidth = 0, posWidth = 0,
crdWidth = 64 crdWidth = 64
}> }>
// CHECK-LABEL: func private @sparse_dcsc( // CHECK-LABEL: func private @sparse_dcsc(
// CHECK-SAME: tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)>, crdWidth = 64 }>>) // CHECK-SAME: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)>, crdWidth = 64 }>>)
func.func private @sparse_dcsc(tensor<?x?xf32, #DCSC>) func.func private @sparse_dcsc(tensor<?x?xf32, #DCSC>)
// ----- // -----
#COO = #sparse_tensor.encoding<{ #COO = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu-no", "singleton-no" ] lvlTypes = [ "compressed-nu-no", "singleton-no" ]
}> }>
// CHECK-LABEL: func private @sparse_coo( // CHECK-LABEL: func private @sparse_coo(
// CHECK-SAME: tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu-no", "singleton-no" ] }>>) // CHECK-SAME: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu-no", "singleton-no" ] }>>)
func.func private @sparse_coo(tensor<?x?xf32, #COO>) func.func private @sparse_coo(tensor<?x?xf32, #COO>)
// ----- // -----
#BCOO = #sparse_tensor.encoding<{ #BCOO = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed-hi-nu", "singleton" ] lvlTypes = [ "dense", "compressed-hi-nu", "singleton" ]
}> }>
// CHECK-LABEL: func private @sparse_bcoo( // CHECK-LABEL: func private @sparse_bcoo(
// CHECK-SAME: tensor<?x?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed-hi-nu", "singleton" ] }>>) // CHECK-SAME: tensor<?x?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed-hi-nu", "singleton" ] }>>)
func.func private @sparse_bcoo(tensor<?x?x?xf32, #BCOO>) func.func private @sparse_bcoo(tensor<?x?x?xf32, #BCOO>)
// ----- // -----
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
// CHECK-LABEL: func private @sparse_sorted_coo( // CHECK-LABEL: func private @sparse_sorted_coo(
// CHECK-SAME: tensor<10x10xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>>) // CHECK-SAME: tensor<10x10xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>>)
func.func private @sparse_sorted_coo(tensor<10x10xf64, #SortedCOO>) func.func private @sparse_sorted_coo(tensor<10x10xf64, #SortedCOO>)
// ----- // -----
#BCSR = #sparse_tensor.encoding<{ #BCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "dense", "dense" ], lvlTypes = [ "compressed", "compressed", "dense", "dense" ],
dimOrdering = affine_map<(ii, jj, i, j) -> (ii, jj, i, j)>, dimOrdering = affine_map<(ii, jj, i, j) -> (ii, jj, i, j)>,
higherOrdering = affine_map<(i, j) -> (i floordiv 2, j floordiv 3, i mod 2, j mod 3)> higherOrdering = affine_map<(i, j) -> (i floordiv 2, j floordiv 3, i mod 2, j mod 3)>
}> }>
// CHECK-LABEL: func private @sparse_bcsr( // CHECK-LABEL: func private @sparse_bcsr(
// CHECK-SAME: tensor<10x60xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense", "dense" ], higherOrdering = affine_map<(d0, d1) -> (d0 floordiv 2, d1 floordiv 3, d0 mod 2, d1 mod 3)> }>> // CHECK-SAME: tensor<10x60xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense", "dense" ], higherOrdering = affine_map<(d0, d1) -> (d0 floordiv 2, d1 floordiv 3, d0 mod 2, d1 mod 3)> }>>
func.func private @sparse_bcsr(tensor<10x60xf64, #BCSR>) func.func private @sparse_bcsr(tensor<10x60xf64, #BCSR>)
// ----- // -----
#ELL = #sparse_tensor.encoding<{ #ELL = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense", "compressed" ], lvlTypes = [ "dense", "dense", "compressed" ],
dimOrdering = affine_map<(ii, i, j) -> (ii, i, j)>, dimOrdering = affine_map<(ii, i, j) -> (ii, i, j)>,
higherOrdering = affine_map<(i,j)[c] -> (c*4*i, i, j)> higherOrdering = affine_map<(i,j)[c] -> (c*4*i, i, j)>
}> }>
// CHECK-LABEL: func private @sparse_ell( // CHECK-LABEL: func private @sparse_ell(
// CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ], higherOrdering = affine_map<(d0, d1)[s0] -> (d0 * (s0 * 4), d0, d1)> }>> // CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ], higherOrdering = affine_map<(d0, d1)[s0] -> (d0 * (s0 * 4), d0, d1)> }>>
func.func private @sparse_ell(tensor<?x?xf64, #ELL>) func.func private @sparse_ell(tensor<?x?xf64, #ELL>)
// ----- // -----
#CSR_SLICE = #sparse_tensor.encoding<{ #CSR_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (1, 4, 1), (1, 4, 2) ] slice = [ (1, 4, 1), (1, 4, 2) ]
}> }>
// CHECK-LABEL: func private @sparse_slice( // CHECK-LABEL: func private @sparse_slice(
// CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ], slice = [ (1, 4, 1), (1, 4, 2) ] }>> // CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], slice = [ (1, 4, 1), (1, 4, 2) ] }>>
func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>) func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>)
// ----- // -----
#CSR_SLICE = #sparse_tensor.encoding<{ #CSR_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (1, 4, 1), (1, 4, 2) ] slice = [ (1, 4, 1), (1, 4, 2) ]
}> }>
// CHECK-LABEL: func private @sparse_slice( // CHECK-LABEL: func private @sparse_slice(
// CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ], slice = [ (1, 4, 1), (1, 4, 2) ] }>> // CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], slice = [ (1, 4, 1), (1, 4, 2) ] }>>
func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>) func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>)
// ----- // -----
#CSR_SLICE = #sparse_tensor.encoding<{ #CSR_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (1, ?, 1), (?, 4, 2) ] slice = [ (1, ?, 1), (?, 4, 2) ]
}> }>
// CHECK-LABEL: func private @sparse_slice( // CHECK-LABEL: func private @sparse_slice(
// CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ], slice = [ (1, ?, 1), (?, 4, 2) ] }>> // CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], slice = [ (1, ?, 1), (?, 4, 2) ] }>>
func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>) func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>)

mlir/test/Dialect/SparseTensor/scf_1_N_conversion.mlir

// RUN: mlir-opt %s -sparse-tensor-codegen -cse | FileCheck %s // RUN: mlir-opt %s -sparse-tensor-codegen -cse | FileCheck %s
#SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
// CHECK-LABEL: func.func @for( // CHECK-LABEL: func.func @for(
// CHECK-SAME: %[[VAL_1:.*0]]: memref<?xindex>, // CHECK-SAME: %[[VAL_1:.*0]]: memref<?xindex>,
// CHECK-SAME: %[[VAL_2:.*1]]: memref<?xindex>, // CHECK-SAME: %[[VAL_2:.*1]]: memref<?xindex>,
// CHECK-SAME: %[[VAL_3:.*2]]: memref<?xf32>, // CHECK-SAME: %[[VAL_3:.*2]]: memref<?xf32>,
// CHECK-SAME: %[[VAL_4:.*3]]: !sparse_tensor.storage_specifier // CHECK-SAME: %[[VAL_4:.*3]]: !sparse_tensor.storage_specifier
// CHECK-SAME: %[[VAL_5:.*4]]: index, // CHECK-SAME: %[[VAL_5:.*4]]: index,
// CHECK-SAME: %[[VAL_6:.*5]]: index, // CHECK-SAME: %[[VAL_6:.*5]]: index,
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sorted_coo.mlir

// RUN: mlir-opt %s -sparsification --canonicalize | FileCheck %s // RUN: mlir-opt %s -sparsification --canonicalize | FileCheck %s
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
#trait_scale = { #trait_scale = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
doc = "X(i,j) = X(i,j) * 2.0" doc = "X(i,j) = X(i,j) * 2.0"
Show All 19 Lines#trait_mul = {
doc = "Z(i,j) = X(i,j) * Y(i,j)" doc = "Z(i,j) = X(i,j) * Y(i,j)"
} }
// //
// Kernels that operate on SortedCOO format. // Kernels that operate on SortedCOO format.
// //
// CHECK-LABEL: func.func @sparse_scale( // CHECK-LABEL: func.func @sparse_scale(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> { // CHECK-SAME: %[[VAL_0:.*]]: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> {
// CHECK-DAG: %[[VAL_1:.*]] = arith.constant false // CHECK-DAG: %[[VAL_1:.*]] = arith.constant false
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 2.000000e+00 : f32 // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 2.000000e+00 : f32
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_8:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_10:.*]] = scf.while (%[[VAL_11:.*]] = %[[VAL_8]]) : (index) -> index { // CHECK: %[[VAL_10:.*]] = scf.while (%[[VAL_11:.*]] = %[[VAL_8]]) : (index) -> index {
// CHECK: %[[VAL_12:.*]] = arith.cmpi ult, %[[VAL_11]], %[[VAL_9]] : index // CHECK: %[[VAL_12:.*]] = arith.cmpi ult, %[[VAL_11]], %[[VAL_9]] : index
// CHECK: scf.condition(%[[VAL_12]]) %[[VAL_11]] : index // CHECK: scf.condition(%[[VAL_12]]) %[[VAL_11]] : index
// CHECK: } do { // CHECK: } do {
// CHECK: ^bb0(%[[VAL_13:.*]]: index): // CHECK: ^bb0(%[[VAL_13:.*]]: index):
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex, strided<[?], offset: ?>> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex, strided<[?], offset: ?>>
Show All 14 Lines
// CHECK: } // CHECK: }
// CHECK: scf.for %[[VAL_24:.*]] = %[[VAL_13]] to %[[VAL_25:.*]] step %[[VAL_3]] { // CHECK: scf.for %[[VAL_24:.*]] = %[[VAL_13]] to %[[VAL_25:.*]] step %[[VAL_3]] {
// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_24]]] : memref<?xf32> // CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_24]]] : memref<?xf32>
// CHECK: %[[VAL_27:.*]] = arith.mulf %[[VAL_26]], %[[VAL_4]] : f32 // CHECK: %[[VAL_27:.*]] = arith.mulf %[[VAL_26]], %[[VAL_4]] : f32
// CHECK: memref.store %[[VAL_27]], %[[VAL_7]]{{\[}}%[[VAL_24]]] : memref<?xf32> // CHECK: memref.store %[[VAL_27]], %[[VAL_7]]{{\[}}%[[VAL_24]]] : memref<?xf32>
// CHECK: } {"Emitted from" = "linalg.generic"} // CHECK: } {"Emitted from" = "linalg.generic"}
// CHECK: scf.yield %[[VAL_28:.*]] : index // CHECK: scf.yield %[[VAL_28:.*]] : index
// CHECK: } attributes {"Emitted from" = "linalg.generic"} // CHECK: } attributes {"Emitted from" = "linalg.generic"}
// CHECK: %[[VAL_29:.*]] = sparse_tensor.load %[[VAL_0]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> // CHECK: %[[VAL_29:.*]] = sparse_tensor.load %[[VAL_0]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>>
// CHECK: return %[[VAL_29]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> // CHECK: return %[[VAL_29]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>>
// CHECK: } // CHECK: }
func.func @sparse_scale(%argx: tensor<?x?xf32, #SortedCOO>) -> tensor<?x?xf32, #SortedCOO> { func.func @sparse_scale(%argx: tensor<?x?xf32, #SortedCOO>) -> tensor<?x?xf32, #SortedCOO> {
%c = arith.constant 2.0 : f32 %c = arith.constant 2.0 : f32
%0 = linalg.generic #trait_scale %0 = linalg.generic #trait_scale
outs(%argx: tensor<?x?xf32, #SortedCOO>) { outs(%argx: tensor<?x?xf32, #SortedCOO>) {
^bb(%x: f32): ^bb(%x: f32):
%1 = arith.mulf %x, %c : f32 %1 = arith.mulf %x, %c : f32
linalg.yield %1 : f32 linalg.yield %1 : f32
} -> tensor<?x?xf32, #SortedCOO> } -> tensor<?x?xf32, #SortedCOO>
return %0 : tensor<?x?xf32, #SortedCOO> return %0 : tensor<?x?xf32, #SortedCOO>
} }
// CHECK-LABEL: func.func @matvec( // CHECK-LABEL: func.func @matvec(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<64xf64>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<64xf64>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf64>) -> tensor<32xf64> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf64>) -> tensor<32xf64> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant false // CHECK-DAG: %[[VAL_3:.*]] = arith.constant false
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xf64> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xf64>
// CHECK: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32xf64> // CHECK: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32xf64>
// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_13:.*]] = scf.while (%[[VAL_14:.*]] = %[[VAL_11]]) : (index) -> index { // CHECK: %[[VAL_13:.*]] = scf.while (%[[VAL_14:.*]] = %[[VAL_11]]) : (index) -> index {
// CHECK: %[[VAL_15:.*]] = arith.cmpi ult, %[[VAL_14]], %[[VAL_12]] : index // CHECK: %[[VAL_15:.*]] = arith.cmpi ult, %[[VAL_14]], %[[VAL_12]] : index
// CHECK: scf.condition(%[[VAL_15]]) %[[VAL_14]] : index // CHECK: scf.condition(%[[VAL_15]]) %[[VAL_14]] : index
// CHECK: } do { // CHECK: } do {
// CHECK: ^bb0(%[[VAL_16:.*]]: index): // CHECK: ^bb0(%[[VAL_16:.*]]: index):
Show All 39 Lines ^bb(%A: f64, %b: f64, %x: f64):
%0 = arith.mulf %A, %b : f64 %0 = arith.mulf %A, %b : f64
%1 = arith.addf %x, %0 : f64 %1 = arith.addf %x, %0 : f64
linalg.yield %1 : f64 linalg.yield %1 : f64
} -> tensor<32xf64> } -> tensor<32xf64>
return %0 : tensor<32xf64> return %0 : tensor<32xf64>
} }
// CHECK-LABEL: func.func @mateltmul( // CHECK-LABEL: func.func @mateltmul(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>>,
// CHECK-SAME: %[[VAL_2:.*2]]: tensor<32x64xf64>) -> tensor<32x64xf64> { // CHECK-SAME: %[[VAL_2:.*2]]: tensor<32x64xf64>) -> tensor<32x64xf64> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant false // CHECK-DAG: %[[VAL_3:.*]] = arith.constant false
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0.000000e+00 : f64 // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0.000000e+00 : f64
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xf64> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xf64>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>>
// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>> // CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xindex, strided<[?], offset: ?>>
// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ] }>> to memref<?xf64> // CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>> to memref<?xf64>
// CHECK: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x64xf64> // CHECK: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x64xf64>
// CHECK: linalg.fill ins(%[[VAL_4]] : f64) outs(%[[VAL_15]] : memref<32x64xf64>) // CHECK: linalg.fill ins(%[[VAL_4]] : f64) outs(%[[VAL_15]] : memref<32x64xf64>)
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_6]]] : memref<?xindex> // CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_6]]] : memref<?xindex>
// CHECK: %[[VAL_20:.*]]:2 = scf.while (%[[VAL_21:.*]] = %[[VAL_16]], %[[VAL_22:.*]] = %[[VAL_18]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_20:.*]]:2 = scf.while (%[[VAL_21:.*]] = %[[VAL_16]], %[[VAL_22:.*]] = %[[VAL_18]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_23:.*]] = arith.cmpi ult, %[[VAL_21]], %[[VAL_17]] : index // CHECK: %[[VAL_23:.*]] = arith.cmpi ult, %[[VAL_21]], %[[VAL_17]] : index
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_1d.mlir

// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#DV = #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }> #DV = #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>
#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait1 = { #trait1 = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "x(i) = a(i) OP b" doc = "x(i) = a(i) OP b"
} }
// CHECK-LABEL: func @add_d( // CHECK-LABEL: func @add_d(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: f32, // CHECK-SAME: %[[VAL_1:.*]]: f32,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_2]] // CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_2]]
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_8]] : memref<32xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_8]] : memref<32xf32>)
// CHECK: scf.for %[[VAL_9:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_9:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_9]]] : memref<?xf32> // CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_9]]] : memref<?xf32>
// CHECK: %[[VAL_11:.*]] = arith.addf %[[VAL_10]], %[[VAL_1]] : f32 // CHECK: %[[VAL_11:.*]] = arith.addf %[[VAL_10]], %[[VAL_1]] : f32
// CHECK: memref.store %[[VAL_11]], %[[VAL_8]]{{\[}}%[[VAL_9]]] : memref<32xf32> // CHECK: memref.store %[[VAL_11]], %[[VAL_8]]{{\[}}%[[VAL_9]]] : memref<32xf32>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_12:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<32xf32> // CHECK: %[[VAL_12:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<32xf32>
// CHECK: return %[[VAL_12]] : tensor<32xf32> // CHECK: return %[[VAL_12]] : tensor<32xf32>
// CHECK: } // CHECK: }
func.func @add_d(%arga: tensor<32xf32, #DV>, %argb: f32, %argx: tensor<32xf32>) -> tensor<32xf32> { func.func @add_d(%arga: tensor<32xf32, #DV>, %argb: f32, %argx: tensor<32xf32>) -> tensor<32xf32> {
%0 = linalg.generic #trait1 %0 = linalg.generic #trait1
ins(%arga: tensor<32xf32, #DV>) ins(%arga: tensor<32xf32, #DV>)
outs(%argx: tensor<32xf32>) { outs(%argx: tensor<32xf32>) {
^bb(%a: f32, %x: f32): ^bb(%a: f32, %x: f32):
%0 = arith.addf %a, %argb : f32 %0 = arith.addf %a, %argb : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32xf32> } -> tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// CHECK-LABEL: func @add_d_init( // CHECK-LABEL: func @add_d_init(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: f32) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_1:.*]]: f32) -> tensor<32xf32> {
// CHECK: %[[VAL_2:.*]] = arith.constant 32 : index // CHECK: %[[VAL_2:.*]] = arith.constant 32 : index
// CHECK: %[[VAL_3:.*]] = arith.constant 0.000000e+00 : f32 // CHECK: %[[VAL_3:.*]] = arith.constant 0.000000e+00 : f32
// CHECK: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK: %[[VAL_INITTENSOR:.*]] = tensor.empty() : tensor<32xf32> // CHECK: %[[VAL_INITTENSOR:.*]] = tensor.empty() : tensor<32xf32>
// CHECK: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }>> to memref<?xf32> // CHECK: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>> to memref<?xf32>
// CHECK: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_INITTENSOR]] : memref<32xf32> // CHECK: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_INITTENSOR]] : memref<32xf32>
// CHECK: linalg.fill ins(%[[VAL_3]] : f32) outs(%[[VAL_7]] : memref<32xf32>) // CHECK: linalg.fill ins(%[[VAL_3]] : f32) outs(%[[VAL_7]] : memref<32xf32>)
// CHECK: scf.for %[[VAL_8:.*]] = %[[VAL_4]] to %[[VAL_2]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_8:.*]] = %[[VAL_4]] to %[[VAL_2]] step %[[VAL_5]] {
// CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_8]]] : memref<?xf32> // CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_8]]] : memref<?xf32>
// CHECK: %[[VAL_10:.*]] = arith.addf %[[VAL_9]], %[[VAL_1]] : f32 // CHECK: %[[VAL_10:.*]] = arith.addf %[[VAL_9]], %[[VAL_1]] : f32
// CHECK: memref.store %[[VAL_10]], %[[VAL_7]]{{\[}}%[[VAL_8]]] : memref<32xf32> // CHECK: memref.store %[[VAL_10]], %[[VAL_7]]{{\[}}%[[VAL_8]]] : memref<32xf32>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_11:.*]] = bufferization.to_tensor %[[VAL_7]] : memref<32xf32> // CHECK: %[[VAL_11:.*]] = bufferization.to_tensor %[[VAL_7]] : memref<32xf32>
// CHECK: return %[[VAL_11]] : tensor<32xf32> // CHECK: return %[[VAL_11]] : tensor<32xf32>
// CHECK: } // CHECK: }
func.func @add_d_init(%arga: tensor<32xf32, #DV>, %argb: f32) -> tensor<32xf32> { func.func @add_d_init(%arga: tensor<32xf32, #DV>, %argb: f32) -> tensor<32xf32> {
%u = tensor.empty() : tensor<32xf32> %u = tensor.empty() : tensor<32xf32>
%0 = linalg.generic #trait1 %0 = linalg.generic #trait1
ins(%arga: tensor<32xf32, #DV>) ins(%arga: tensor<32xf32, #DV>)
outs(%u: tensor<32xf32>) { outs(%u: tensor<32xf32>) {
^bb(%a: f32, %x: f32): ^bb(%a: f32, %x: f32):
%0 = arith.addf %a, %argb : f32 %0 = arith.addf %a, %argb : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32xf32> } -> tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// CHECK-LABEL: func @mul_d( // CHECK-LABEL: func @mul_d(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: f32, // CHECK-SAME: %[[VAL_1:.*]]: f32,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_2]] // CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_2]]
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_8]] : memref<32xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_8]] : memref<32xf32>)
// CHECK: scf.for %[[VAL_9:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_9:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_9]]] : memref<?xf32> // CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_9]]] : memref<?xf32>
// CHECK: %[[VAL_11:.*]] = arith.mulf %[[VAL_10]], %[[VAL_1]] : f32 // CHECK: %[[VAL_11:.*]] = arith.mulf %[[VAL_10]], %[[VAL_1]] : f32
// CHECK: memref.store %[[VAL_11]], %[[VAL_8]]{{\[}}%[[VAL_9]]] : memref<32xf32> // CHECK: memref.store %[[VAL_11]], %[[VAL_8]]{{\[}}%[[VAL_9]]] : memref<32xf32>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_12:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<32xf32> // CHECK: %[[VAL_12:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<32xf32>
// CHECK: return %[[VAL_12]] : tensor<32xf32> // CHECK: return %[[VAL_12]] : tensor<32xf32>
// CHECK: } // CHECK: }
func.func @mul_d(%arga: tensor<32xf32, #DV>, %argb: f32, %argx: tensor<32xf32>) -> tensor<32xf32> { func.func @mul_d(%arga: tensor<32xf32, #DV>, %argb: f32, %argx: tensor<32xf32>) -> tensor<32xf32> {
%0 = linalg.generic #trait1 %0 = linalg.generic #trait1
ins(%arga: tensor<32xf32, #DV>) ins(%arga: tensor<32xf32, #DV>)
outs(%argx: tensor<32xf32>) { outs(%argx: tensor<32xf32>) {
^bb(%a: f32, %x: f32): ^bb(%a: f32, %x: f32):
%0 = arith.mulf %a, %argb : f32 %0 = arith.mulf %a, %argb : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32xf32> } -> tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// CHECK-LABEL: func @add_s( // CHECK-LABEL: func @add_s(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: f32, // CHECK-SAME: %[[VAL_1:.*]]: f32,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant true // CHECK-DAG: %[[VAL_5:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]]
// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_11]] : memref<32xf32>) // CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_11]] : memref<32xf32>)
// CHECK: %[[VAL_14:.*]]:2 = scf.while (%[[VAL_15:.*]] = %[[VAL_12]], %[[VAL_16:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_14:.*]]:2 = scf.while (%[[VAL_15:.*]] = %[[VAL_12]], %[[VAL_16:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_17:.*]] = arith.cmpi ult, %[[VAL_15]], %[[VAL_13]] : index // CHECK: %[[VAL_17:.*]] = arith.cmpi ult, %[[VAL_15]], %[[VAL_13]] : index
// CHECK: scf.condition(%[[VAL_17]]) %[[VAL_15]], %[[VAL_16]] : index, index // CHECK: scf.condition(%[[VAL_17]]) %[[VAL_15]], %[[VAL_16]] : index, index
// CHECK: } do { // CHECK: } do {
Show All 29 Lines outs(%argx: tensor<32xf32>) {
^bb(%a: f32, %x: f32): ^bb(%a: f32, %x: f32):
%0 = arith.addf %a, %argb : f32 %0 = arith.addf %a, %argb : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32xf32> } -> tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// CHECK-LABEL: func @repeated_add_s( // CHECK-LABEL: func @repeated_add_s(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>) -> tensor<32xf32> {
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_1]] // CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_1]]
// CHECK-DAG: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_8]] : memref<32xf32>) // CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_8]] : memref<32xf32>)
// CHECK: scf.for %[[VAL_11:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_3]] { // CHECK: scf.for %[[VAL_11:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_3]] {
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xindex> // CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xindex>
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32> // CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32>
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32>
Show All 16 Lines outs(%argx: tensor<32xf32>) {
%1 = arith.addf %a, %a : f32 // should yield %1 = arith.addf %a, %a : f32 // should yield
%2 = arith.addf %0, %1 : f32 // one guard %2 = arith.addf %0, %1 : f32 // one guard
linalg.yield %2 : f32 linalg.yield %2 : f32
} -> tensor<32xf32> } -> tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// CHECK-LABEL: func @mul_s( // CHECK-LABEL: func @mul_s(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: f32, // CHECK-SAME: %[[VAL_1:.*]]: f32,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_2]] // CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_2]]
// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_9]] : memref<32xf32>) // CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_9]] : memref<32xf32>)
// CHECK-DAG: %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_4]] { // CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_4]] {
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex> // CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex>
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_12]]] : memref<?xf32> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_12]]] : memref<?xf32>
// CHECK: %[[VAL_15:.*]] = arith.mulf %[[VAL_14]], %[[VAL_1]] : f32 // CHECK: %[[VAL_15:.*]] = arith.mulf %[[VAL_14]], %[[VAL_1]] : f32
Show All 19 Lines indexing_maps = [
affine_map<(i) -> (i)>, // b affine_map<(i) -> (i)>, // b
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "x(i) = a(i) OP b(i)" doc = "x(i) = a(i) OP b(i)"
} }
// CHECK-LABEL: func @add_dd( // CHECK-LABEL: func @add_dd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32xf32> // CHECK-DAG: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32xf32>
// CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_2]] // CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_2]]
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_9]] : memref<32xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_9]] : memref<32xf32>)
// CHECK: scf.for %[[VAL_10:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_10:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<?xf32> // CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<?xf32>
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_10]]] : memref<32xf32> // CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_10]]] : memref<32xf32>
// CHECK: %[[VAL_13:.*]] = arith.addf %[[VAL_11]], %[[VAL_12]] : f32 // CHECK: %[[VAL_13:.*]] = arith.addf %[[VAL_11]], %[[VAL_12]] : f32
// CHECK: memref.store %[[VAL_13]], %[[VAL_9]]{{\[}}%[[VAL_10]]] : memref<32xf32> // CHECK: memref.store %[[VAL_13]], %[[VAL_9]]{{\[}}%[[VAL_10]]] : memref<32xf32>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_14:.*]] = bufferization.to_tensor %[[VAL_9]] : memref<32xf32> // CHECK: %[[VAL_14:.*]] = bufferization.to_tensor %[[VAL_9]] : memref<32xf32>
// CHECK: return %[[VAL_14]] : tensor<32xf32> // CHECK: return %[[VAL_14]] : tensor<32xf32>
// CHECK: } // CHECK: }
func.func @add_dd(%arga: tensor<32xf32, #DV>, %argb: tensor<32xf32>, %argx: tensor<32xf32>) -> tensor<32xf32> { func.func @add_dd(%arga: tensor<32xf32, #DV>, %argb: tensor<32xf32>, %argx: tensor<32xf32>) -> tensor<32xf32> {
%0 = linalg.generic #trait2 %0 = linalg.generic #trait2
ins(%arga, %argb: tensor<32xf32, #DV>, tensor<32xf32>) ins(%arga, %argb: tensor<32xf32, #DV>, tensor<32xf32>)
outs(%argx: tensor<32xf32>) { outs(%argx: tensor<32xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32xf32> } -> tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// CHECK-LABEL: func @mul_dd( // CHECK-LABEL: func @mul_dd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32xf32> // CHECK-DAG: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32xf32>
// CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_2]] // CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_2]]
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_9]] : memref<32xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_9]] : memref<32xf32>)
// CHECK: scf.for %[[VAL_10:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_10:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<?xf32> // CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<?xf32>
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_10]]] : memref<32xf32> // CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_10]]] : memref<32xf32>
// CHECK: %[[VAL_13:.*]] = arith.mulf %[[VAL_11]], %[[VAL_12]] : f32 // CHECK: %[[VAL_13:.*]] = arith.mulf %[[VAL_11]], %[[VAL_12]] : f32
// CHECK: memref.store %[[VAL_13]], %[[VAL_9]]{{\[}}%[[VAL_10]]] : memref<32xf32> // CHECK: memref.store %[[VAL_13]], %[[VAL_9]]{{\[}}%[[VAL_10]]] : memref<32xf32>
Show All 9 Lines outs(%argx: tensor<32xf32>) {
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32xf32> } -> tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// CHECK-LABEL: func @add_ds( // CHECK-LABEL: func @add_ds(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant true // CHECK-DAG: %[[VAL_5:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_0]] : memref<32xf32> // CHECK-DAG: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_0]] : memref<32xf32>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]]
// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32xf32>) // CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32xf32>)
// CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_6]]] : memref<?xindex> // CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_6]]] : memref<?xindex>
// CHECK: %[[VAL_15:.*]]:2 = scf.while (%[[VAL_16:.*]] = %[[VAL_13]], %[[VAL_17:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_15:.*]]:2 = scf.while (%[[VAL_16:.*]] = %[[VAL_13]], %[[VAL_17:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_18:.*]] = arith.cmpi ult, %[[VAL_16]], %[[VAL_14]] : index // CHECK: %[[VAL_18:.*]] = arith.cmpi ult, %[[VAL_16]], %[[VAL_14]] : index
// CHECK: scf.condition(%[[VAL_18]]) %[[VAL_16]], %[[VAL_17]] : index, index // CHECK: scf.condition(%[[VAL_18]]) %[[VAL_16]], %[[VAL_17]] : index, index
// CHECK: } do { // CHECK: } do {
Show All 33 Lines outs(%argx: tensor<32xf32>) {
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32xf32> } -> tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// CHECK-LABEL: func @mul_ds( // CHECK-LABEL: func @mul_ds(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = bufferization.to_memref %[[VAL_0]] : memref<32xf32> // CHECK-DAG: %[[VAL_5:.*]] = bufferization.to_memref %[[VAL_0]] : memref<32xf32>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_2]] // CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_2]]
// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_10]] : memref<32xf32>) // CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_10]] : memref<32xf32>)
// CHECK-DAG: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_12:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_4]] { // CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_4]] {
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xindex> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xindex>
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_14]]] : memref<32xf32> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_14]]] : memref<32xf32>
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_13]]] : memref<?xf32> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_13]]] : memref<?xf32>
Show All 10 Lines outs(%argx: tensor<32xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32xf32> } -> tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// CHECK-LABEL: func @add_sd( // CHECK-LABEL: func @add_sd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant true // CHECK-DAG: %[[VAL_5:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32xf32> // CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32xf32>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]]
// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32xf32>) // CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32xf32>)
// CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex> // CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex>
// CHECK: %[[VAL_15:.*]]:2 = scf.while (%[[VAL_16:.*]] = %[[VAL_13]], %[[VAL_17:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_15:.*]]:2 = scf.while (%[[VAL_16:.*]] = %[[VAL_13]], %[[VAL_17:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_18:.*]] = arith.cmpi ult, %[[VAL_16]], %[[VAL_14]] : index // CHECK: %[[VAL_18:.*]] = arith.cmpi ult, %[[VAL_16]], %[[VAL_14]] : index
// CHECK: scf.condition(%[[VAL_18]]) %[[VAL_16]], %[[VAL_17]] : index, index // CHECK: scf.condition(%[[VAL_18]]) %[[VAL_16]], %[[VAL_17]] : index, index
Show All 33 Lines outs(%argx: tensor<32xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32xf32> } -> tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// CHECK-LABEL: func @mul_sd( // CHECK-LABEL: func @mul_sd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32xf32> // CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32xf32>
// CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_2]] // CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_2]]
// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_10]] : memref<32xf32>) // CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_10]] : memref<32xf32>)
// CHECK-DAG: %[[VAL_11:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_12:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_4]] { // CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_4]] {
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex>
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xf32> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xf32>
Show All 11 Lines outs(%argx: tensor<32xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32xf32> } -> tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// CHECK-LABEL: func @add_ss( // CHECK-LABEL: func @add_ss(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*2]]: tensor<32xf32>) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_2:.*2]]: tensor<32xf32>) -> tensor<32xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]]
// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32xf32>) // CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32xf32>)
// CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_20:.*]] = arith.cmpi ult, %[[VAL_18]], %[[VAL_14]] : index // CHECK: %[[VAL_20:.*]] = arith.cmpi ult, %[[VAL_18]], %[[VAL_14]] : index
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines outs(%argx: tensor<32xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32xf32> } -> tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// CHECK-LABEL: func @mul_ss( // CHECK-LABEL: func @mul_ss(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*2]]: tensor<32xf32>) -> tensor<32xf32> { // CHECK-SAME: %[[VAL_2:.*2]]: tensor<32xf32>) -> tensor<32xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]]
// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32xf32>) // CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32xf32>)
// CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_20:.*]] = arith.cmpi ult, %[[VAL_18]], %[[VAL_14]] : index // CHECK: %[[VAL_20:.*]] = arith.cmpi ult, %[[VAL_18]], %[[VAL_14]] : index
Show All 34 Lines outs(%argx: tensor<32xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32xf32> } -> tensor<32xf32>
return %0 : tensor<32xf32> return %0 : tensor<32xf32>
} }
// CHECK-LABEL: func @two_way_inv( // CHECK-LABEL: func @two_way_inv(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*2]]: f32, // CHECK-SAME: %[[VAL_2:.*2]]: f32,
// CHECK-SAME: %[[VAL_3:.*3]]: tensor<16xf32>) -> tensor<16xf32> { // CHECK-SAME: %[[VAL_3:.*3]]: tensor<16xf32>) -> tensor<16xf32> {
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_3]] // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_3]]
// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_13]] : memref<16xf32>) // CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_13]] : memref<16xf32>)
// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_14]], %[[VAL_20:.*]] = %[[VAL_16]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_14]], %[[VAL_20:.*]] = %[[VAL_16]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_15]] : index // CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_15]] : index
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines outs(%argx: tensor<16xf32>) {
%1 = arith.mulf %b, %argc : f32 %1 = arith.mulf %b, %argc : f32
%2 = arith.addf %0, %1 : f32 %2 = arith.addf %0, %1 : f32
linalg.yield %2 : f32 linalg.yield %2 : f32
} -> tensor<16xf32> } -> tensor<16xf32>
return %0 : tensor<16xf32> return %0 : tensor<16xf32>
} }
// CHECK-LABEL: func @two_way_inv_alt( // CHECK-LABEL: func @two_way_inv_alt(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*2]]: f32, // CHECK-SAME: %[[VAL_2:.*2]]: f32,
// CHECK-SAME: %[[VAL_3:.*3]]: tensor<16xf32>) -> tensor<16xf32> { // CHECK-SAME: %[[VAL_3:.*3]]: tensor<16xf32>) -> tensor<16xf32> {
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_3]] // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_3]]
// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_13]] : memref<16xf32>) // CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_13]] : memref<16xf32>)
// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_14]], %[[VAL_20:.*]] = %[[VAL_16]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_14]], %[[VAL_20:.*]] = %[[VAL_16]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_15]] : index // CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_15]] : index
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> ()> // x (scalar out) affine_map<(i) -> ()> // x (scalar out)
], ],
iterator_types = ["reduction"], iterator_types = ["reduction"],
doc = "x += SUM_i a(i)" doc = "x += SUM_i a(i)"
} }
// CHECK-LABEL: func @sum_reduction( // CHECK-LABEL: func @sum_reduction(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<f32>) -> tensor<f32> { // CHECK-SAME: %[[VAL_1:.*]]: tensor<f32>) -> tensor<f32> {
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_1]] : memref<f32> // CHECK-DAG: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_1]] : memref<f32>
// CHECK-DAG: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = memref.load %[[VAL_6]][] : memref<f32> // CHECK-DAG: %[[VAL_10:.*]] = memref.load %[[VAL_6]][] : memref<f32>
// CHECK: %[[VAL_11:.*]] = scf.for %[[VAL_12:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_13:.*]] = %[[VAL_10]]) -> (f32) { // CHECK: %[[VAL_11:.*]] = scf.for %[[VAL_12:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_13:.*]] = %[[VAL_10]]) -> (f32) {
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xf32> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xf32>
// CHECK: %[[VAL_15:.*]] = arith.addf %[[VAL_13]], %[[VAL_14]] : f32 // CHECK: %[[VAL_15:.*]] = arith.addf %[[VAL_13]], %[[VAL_14]] : f32
// CHECK: scf.yield %[[VAL_15]] : f32 // CHECK: scf.yield %[[VAL_15]] : f32
Show All 19 Lines indexing_maps = [
affine_map<(i) -> (i)>, // b affine_map<(i) -> (i)>, // b
affine_map<(i)-> ()> // x (scalar out) affine_map<(i)-> ()> // x (scalar out)
], ],
iterator_types = ["reduction"], iterator_types = ["reduction"],
doc = "x += SUM_i a(i) + b(i)" doc = "x += SUM_i a(i) + b(i)"
} }
// CHECK-LABEL: func @sum_reduction_ss( // CHECK-LABEL: func @sum_reduction_ss(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*2]]: tensor<f32>) -> tensor<f32> { // CHECK-SAME: %[[VAL_2:.*2]]: tensor<f32>) -> tensor<f32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<f32> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<f32>
// CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_11]][] : memref<f32> // CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_11]][] : memref<f32>
// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]]:3 = scf.while (%[[VAL_19:.*]] = %[[VAL_14]], %[[VAL_20:.*]] = %[[VAL_16]], %[[VAL_21:.*]] = %[[VAL_13]]) : (index, index, f32) -> (index, index, f32) { // CHECK: %[[VAL_18:.*]]:3 = scf.while (%[[VAL_19:.*]] = %[[VAL_14]], %[[VAL_20:.*]] = %[[VAL_16]], %[[VAL_21:.*]] = %[[VAL_13]]) : (index, index, f32) -> (index, index, f32) {
// CHECK: %[[VAL_22:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_15]] : index // CHECK: %[[VAL_22:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_15]] : index
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines indexing_maps = [
affine_map<(i) -> (i)>, // c affine_map<(i) -> (i)>, // c
affine_map<(i) -> ()> // x (out) affine_map<(i) -> ()> // x (out)
], ],
iterator_types = ["reduction"], iterator_types = ["reduction"],
doc = "x += SUM_i a(i) * b + c(i)" doc = "x += SUM_i a(i) * b + c(i)"
} }
// CHECK-LABEL: func @sum_reduction_inv( // CHECK-LABEL: func @sum_reduction_inv(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<f32>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<f32>,
// CHECK-SAME: %[[VAL_2:.*2]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_2:.*2]]: tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_3:.*3]]: tensor<f32>) -> tensor<f32> { // CHECK-SAME: %[[VAL_3:.*3]]: tensor<f32>) -> tensor<f32> {
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<f32> // CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<f32>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_2]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_2]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_2]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_2]] {level = 0 : index} : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_2]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_2]] : tensor<16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_3]] : memref<f32> // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_3]] : memref<f32>
// CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_13]][] : memref<f32> // CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_13]][] : memref<f32>
// CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_9]][] : memref<f32> // CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_9]][] : memref<f32>
// CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_18:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-DAG: %[[VAL_18:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-DAG: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_21:.*]]:3 = scf.while (%[[VAL_22:.*]] = %[[VAL_17]], %[[VAL_23:.*]] = %[[VAL_19]], %[[VAL_24:.*]] = %[[VAL_15]]) : (index, index, f32) -> (index, index, f32) { // CHECK: %[[VAL_21:.*]]:3 = scf.while (%[[VAL_22:.*]] = %[[VAL_17]], %[[VAL_23:.*]] = %[[VAL_19]], %[[VAL_24:.*]] = %[[VAL_15]]) : (index, index, f32) -> (index, index, f32) {
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines indexing_maps = [
affine_map<(i) -> (i)> // X (out) affine_map<(i) -> (i)> // X (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "X(i) = A(i) + B(i) + C(i) + D(i)" doc = "X(i) = A(i) + B(i) + C(i) + D(i)"
} }
// CHECK-LABEL: func @four_tensors_op( // CHECK-LABEL: func @four_tensors_op(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<?xf64>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<?xf64>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*2]]: tensor<?xf64>, // CHECK-SAME: %[[VAL_2:.*2]]: tensor<?xf64>,
// CHECK-SAME: %[[VAL_3:.*3]]: tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_3:.*3]]: tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_4:.*]]: tensor<?xf64>) -> tensor<?xf64> { // CHECK-SAME: %[[VAL_4:.*]]: tensor<?xf64>) -> tensor<?xf64> {
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant true // CHECK-DAG: %[[VAL_6:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<?xf64> // CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<?xf64>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf64> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf64>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<?xf64> // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<?xf64>
// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.positions %[[VAL_3]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.positions %[[VAL_3]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.coordinates %[[VAL_3]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.coordinates %[[VAL_3]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.values %[[VAL_3]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf64> // CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.values %[[VAL_3]] : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf64>
// CHECK-DAG: %[[VAL_16:.*]] = tensor.dim %[[VAL_0]], %[[VAL_5]] : tensor<?xf64> // CHECK-DAG: %[[VAL_16:.*]] = tensor.dim %[[VAL_0]], %[[VAL_5]] : tensor<?xf64>
// CHECK-DAG: %[[VAL_18:.*]] = bufferization.to_memref %[[VAL_4]] // CHECK-DAG: %[[VAL_18:.*]] = bufferization.to_memref %[[VAL_4]]
// CHECK-DAG: linalg.fill ins(%{{.*}} : f64) outs(%[[VAL_18]] : memref<?xf64>) // CHECK-DAG: linalg.fill ins(%{{.*}} : f64) outs(%[[VAL_18]] : memref<?xf64>)
// CHECK-DAG: %[[VAL_19:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-DAG: %[[VAL_19:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_20:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex> // CHECK-DAG: %[[VAL_20:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_21:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-DAG: %[[VAL_21:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_22:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_7]]] : memref<?xindex> // CHECK-DAG: %[[VAL_22:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_7]]] : memref<?xindex>
// CHECK: %[[VAL_23:.*]]:3 = scf.while (%[[VAL_24:.*]] = %[[VAL_19]], %[[VAL_25:.*]] = %[[VAL_21]], %[[VAL_26:.*]] = %[[VAL_5]]) : (index, index, index) -> (index, index, index) { // CHECK: %[[VAL_23:.*]]:3 = scf.while (%[[VAL_24:.*]] = %[[VAL_19]], %[[VAL_25:.*]] = %[[VAL_21]], %[[VAL_26:.*]] = %[[VAL_5]]) : (index, index, index) -> (index, index, index) {
▲ Show 20 Lines • Show All 146 Lines • ▼ Show 20 Lines indexing_maps = [
affine_map<(i) -> (i)>, affine_map<(i) -> (i)>,
affine_map<(i) -> ()> affine_map<(i) -> ()>
], ],
iterator_types = ["reduction"], iterator_types = ["reduction"],
doc = "x += a(i) + b(i) + c(i)" doc = "x += a(i) + b(i) + c(i)"
} }
// CHECK-LABEL: func @red3s( // CHECK-LABEL: func @red3s(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*2]]: tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_2:.*2]]: tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_3:.*3]]: tensor<f64>) -> tensor<f64> { // CHECK-SAME: %[[VAL_3:.*3]]: tensor<f64>) -> tensor<f64> {
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf64> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf64>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf64> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf64>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_2]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_2]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_2]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_2]] {level = 0 : index} : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_2]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf64> // CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_2]] : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf64>
// CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_3]] : memref<f64> // CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_3]] : memref<f64>
// CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_15]][] : memref<f64> // CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_15]][] : memref<f64>
// CHECK-DAG: %[[VAL_18:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_18:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_19:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-DAG: %[[VAL_19:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_20:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_20:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_21:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-DAG: %[[VAL_21:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_22:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-DAG: %[[VAL_22:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_23:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-DAG: %[[VAL_23:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_5]]] : memref<?xindex>
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_2d.mlir

// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#Tdd = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense" ] }> #Tdd = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ] }>
#Tds = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }> #Tds = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>
#Tsd = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }> #Tsd = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>
#Tss = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #Tss = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
#trait2 = { #trait2 = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (i,j)>, // B affine_map<(i,j) -> (i,j)>, // B
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
doc = "X(i,j) = A(i,j) OP B(i,j)" doc = "X(i,j) = A(i,j) OP B(i,j)"
} }
// CHECK-LABEL: func @add_dd( // CHECK-LABEL: func @add_dd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32>
// CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32>
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_10]] : memref<32x16xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_10]] : memref<32x16xf32>)
// CHECK: scf.for %[[VAL_11:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_11:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] {
// CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] {
// CHECK: %[[VAL_13:.*]] = arith.muli %[[VAL_11]], %[[VAL_4]] : index // CHECK: %[[VAL_13:.*]] = arith.muli %[[VAL_11]], %[[VAL_4]] : index
// CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_13]], %[[VAL_12]] : index // CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_13]], %[[VAL_12]] : index
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_14]]] : memref<?xf32> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_14]]] : memref<?xf32>
Show All 12 Lines outs(%argx: tensor<32x16xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16xf32> } -> tensor<32x16xf32>
return %0 : tensor<32x16xf32> return %0 : tensor<32x16xf32>
} }
// CHECK-LABEL: func @mul_dd( // CHECK-LABEL: func @mul_dd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32>
// CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32>
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_10]] : memref<32x16xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_10]] : memref<32x16xf32>)
// CHECK: scf.for %[[VAL_11:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_11:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] {
// CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] {
// CHECK: %[[VAL_13:.*]] = arith.muli %[[VAL_11]], %[[VAL_4]] : index // CHECK: %[[VAL_13:.*]] = arith.muli %[[VAL_11]], %[[VAL_4]] : index
// CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_13]], %[[VAL_12]] : index // CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_13]], %[[VAL_12]] : index
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_14]]] : memref<?xf32> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_14]]] : memref<?xf32>
Show All 12 Lines outs(%argx: tensor<32x16xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16xf32> } -> tensor<32x16xf32>
return %0 : tensor<32x16xf32> return %0 : tensor<32x16xf32>
} }
// CHECK-LABEL: func @add_ds( // CHECK-LABEL: func @add_ds(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant true // CHECK-DAG: %[[VAL_6:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32>
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32>
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_13]] : memref<32x16xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_13]] : memref<32x16xf32>)
// CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_7]] { // CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_7]] {
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_14]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_14]]] : memref<?xindex>
// CHECK: %[[VAL_16:.*]] = arith.addi %[[VAL_14]], %[[VAL_7]] : index // CHECK: %[[VAL_16:.*]] = arith.addi %[[VAL_14]], %[[VAL_7]] : index
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_15]], %[[VAL_20:.*]] = %[[VAL_5]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_15]], %[[VAL_20:.*]] = %[[VAL_5]]) : (index, index) -> (index, index) {
Show All 36 Lines outs(%argx: tensor<32x16xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16xf32> } -> tensor<32x16xf32>
return %0 : tensor<32x16xf32> return %0 : tensor<32x16xf32>
} }
// CHECK-LABEL: func @mul_ds( // CHECK-LABEL: func @mul_ds(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32>
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_11]] : memref<32x16xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_11]] : memref<32x16xf32>)
// CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex> // CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex>
// CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_12]], %[[VAL_5]] : index // CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_12]], %[[VAL_5]] : index
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_14]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_14]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_15]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_15]] step %[[VAL_5]] {
Show All 14 Lines outs(%argx: tensor<32x16xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16xf32> } -> tensor<32x16xf32>
return %0 : tensor<32x16xf32> return %0 : tensor<32x16xf32>
} }
// CHECK-LABEL: func @add_sd( // CHECK-LABEL: func @add_sd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant true // CHECK-DAG: %[[VAL_5:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32>
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32>
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_13]] : memref<32x16xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_13]] : memref<32x16xf32>)
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_6]]] : memref<?xindex> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_6]]] : memref<?xindex>
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_7]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_7]]] : memref<?xindex>
// CHECK: %[[VAL_16:.*]]:2 = scf.while (%[[VAL_17:.*]] = %[[VAL_14]], %[[VAL_18:.*]] = %[[VAL_6]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_16:.*]]:2 = scf.while (%[[VAL_17:.*]] = %[[VAL_14]], %[[VAL_18:.*]] = %[[VAL_6]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_19:.*]] = arith.cmpi ult, %[[VAL_17]], %[[VAL_15]] : index // CHECK: %[[VAL_19:.*]] = arith.cmpi ult, %[[VAL_17]], %[[VAL_15]] : index
// CHECK: scf.condition(%[[VAL_19]]) %[[VAL_17]], %[[VAL_18]] : index, index // CHECK: scf.condition(%[[VAL_19]]) %[[VAL_17]], %[[VAL_18]] : index, index
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines outs(%argx: tensor<32x16xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16xf32> } -> tensor<32x16xf32>
return %0 : tensor<32x16xf32> return %0 : tensor<32x16xf32>
} }
// CHECK-LABEL: func @mul_sd( // CHECK-LABEL: func @mul_sd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32>
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_11]] : memref<32x16xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_11]] : memref<32x16xf32>)
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_12]] to %[[VAL_13]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_12]] to %[[VAL_13]] step %[[VAL_5]] {
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_14]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_14]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
Show All 15 Lines outs(%argx: tensor<32x16xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16xf32> } -> tensor<32x16xf32>
return %0 : tensor<32x16xf32> return %0 : tensor<32x16xf32>
} }
// CHECK-LABEL: func @add_ss( // CHECK-LABEL: func @add_ss(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant true // CHECK-DAG: %[[VAL_5:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32>
// CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32>
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_15]] : memref<32x16xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_15]] : memref<32x16xf32>)
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_6]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_6]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_7]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_7]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_16]], %[[VAL_20:.*]] = %[[VAL_6]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_16]], %[[VAL_20:.*]] = %[[VAL_6]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_17]] : index // CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_17]] : index
// CHECK: scf.condition(%[[VAL_21]]) %[[VAL_19]], %[[VAL_20]] : index, index // CHECK: scf.condition(%[[VAL_21]]) %[[VAL_19]], %[[VAL_20]] : index, index
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines outs(%argx: tensor<32x16xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16xf32> } -> tensor<32x16xf32>
return %0 : tensor<32x16xf32> return %0 : tensor<32x16xf32>
} }
// CHECK-LABEL: func @mul_ss( // CHECK-LABEL: func @mul_ss(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16xf32>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32>
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32x16xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32x16xf32>)
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_4]] { // CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_4]] {
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_15]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_15]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex>
Show All 17 Lines outs(%argx: tensor<32x16xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16xf32> } -> tensor<32x16xf32>
return %0 : tensor<32x16xf32> return %0 : tensor<32x16xf32>
} }
// CHECK-LABEL: func @add_ss_ss( // CHECK-LABEL: func @add_ss_ss(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*2]]: tensor<32x16xf32>) -> tensor<32x16xf32> { // CHECK-SAME: %[[VAL_2:.*2]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_16:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_16:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32>
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_16]] : memref<32x16xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_16]] : memref<32x16xf32>)
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_21:.*]]:2 = scf.while (%[[VAL_22:.*]] = %[[VAL_17]], %[[VAL_23:.*]] = %[[VAL_19]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_21:.*]]:2 = scf.while (%[[VAL_22:.*]] = %[[VAL_17]], %[[VAL_23:.*]] = %[[VAL_19]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_24:.*]] = arith.cmpi ult, %[[VAL_22]], %[[VAL_18]] : index // CHECK: %[[VAL_24:.*]] = arith.cmpi ult, %[[VAL_22]], %[[VAL_18]] : index
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Lines outs(%argx: tensor<32x16xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16xf32> } -> tensor<32x16xf32>
return %0 : tensor<32x16xf32> return %0 : tensor<32x16xf32>
} }
#BatchedVector = #sparse_tensor.encoding<{ #BatchedVector = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed-hi" ], lvlTypes = [ "dense", "compressed-hi" ],
}> }>
// CHECK-LABEL: func.func @sub_ss_batched( // CHECK-LABEL: func.func @sub_ss_batched(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<2x3xf64, #{{.*}}>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<2x3xf64, #{{.*}}>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<2x3xf64, #{{.*}}>>) -> tensor<2x3xf64, #{{.*}}>> { // CHECK-SAME: %[[VAL_1:.*]]: tensor<2x3xf64, #{{.*}}>>) -> tensor<2x3xf64, #{{.*}}>> {
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 2 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 2 : index
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = bufferization.alloc_tensor() : tensor<2x3xf64, #{{.*}}>> // CHECK-DAG: %[[VAL_5:.*]] = bufferization.alloc_tensor() : tensor<2x3xf64, #{{.*}}>>
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines %3 = linalg.generic #trait2
^bb0(%in: f64, %in_0: f64, %out: f64): ^bb0(%in: f64, %in_0: f64, %out: f64):
%7 = arith.subf %in, %in_0 : f64 %7 = arith.subf %in, %in_0 : f64
linalg.yield %7 : f64 linalg.yield %7 : f64
} -> tensor<2x3xf64, #BatchedVector> } -> tensor<2x3xf64, #BatchedVector>
return %3 : tensor<2x3xf64, #BatchedVector> return %3 : tensor<2x3xf64, #BatchedVector>
} }
// CHECK-LABEL: func @mul_ss_ss( // CHECK-LABEL: func @mul_ss_ss(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*2]]: tensor<32x16xf32>) -> tensor<32x16xf32> { // CHECK-SAME: %[[VAL_2:.*2]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_16:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_16:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32>
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_16]] : memref<32x16xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_16]] : memref<32x16xf32>)
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_21:.*]]:2 = scf.while (%[[VAL_22:.*]] = %[[VAL_17]], %[[VAL_23:.*]] = %[[VAL_19]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_21:.*]]:2 = scf.while (%[[VAL_22:.*]] = %[[VAL_17]], %[[VAL_23:.*]] = %[[VAL_19]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_24:.*]] = arith.cmpi ult, %[[VAL_22]], %[[VAL_18]] : index // CHECK: %[[VAL_24:.*]] = arith.cmpi ult, %[[VAL_22]], %[[VAL_18]] : index
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines outs(%argx: tensor<32x16xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16xf32> } -> tensor<32x16xf32>
return %0 : tensor<32x16xf32> return %0 : tensor<32x16xf32>
} }
// CHECK-LABEL: func @add_sd_ds( // CHECK-LABEL: func @add_sd_ds(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant true // CHECK-DAG: %[[VAL_6:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32>
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_15]] : memref<32x16xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_15]] : memref<32x16xf32>)
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_7]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_7]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_16]], %[[VAL_20:.*]] = %[[VAL_5]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_16]], %[[VAL_20:.*]] = %[[VAL_5]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_17]] : index // CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_17]] : index
// CHECK: scf.condition(%[[VAL_21]]) %[[VAL_19]], %[[VAL_20]] : index, index // CHECK: scf.condition(%[[VAL_21]]) %[[VAL_19]], %[[VAL_20]] : index, index
// CHECK: } do { // CHECK: } do {
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines outs(%argx: tensor<32x16xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16xf32> } -> tensor<32x16xf32>
return %0 : tensor<32x16xf32> return %0 : tensor<32x16xf32>
} }
// CHECK-LABEL: func @mul_sd_ds( // CHECK-LABEL: func @mul_sd_ds(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32> // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16xf32>
// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_13]] : memref<32x16xf32>) // CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_13]] : memref<32x16xf32>)
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_5]] {
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_16]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_16]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_17]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_17]]] : memref<?xindex>
// CHECK: %[[VAL_19:.*]] = arith.addi %[[VAL_17]], %[[VAL_5]] : index // CHECK: %[[VAL_19:.*]] = arith.addi %[[VAL_17]], %[[VAL_5]] : index
Show All 28 Lines indexing_maps = [
affine_map<(i,j) -> (j)>, // b affine_map<(i,j) -> (j)>, // b
affine_map<(i,j) -> (i)> // x (out) affine_map<(i,j) -> (i)> // x (out)
], ],
iterator_types = ["parallel", "reduction"], iterator_types = ["parallel", "reduction"],
doc = "x(i) += SUM_j A(i,j) * b(j)" doc = "x(i) += SUM_j A(i,j) * b(j)"
} }
// CHECK-LABEL: func @matvec( // CHECK-LABEL: func @matvec(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<16x32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<16x32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<16xf32>) -> tensor<16xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<16xf32>) -> tensor<16xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<16x32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<16x32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<16x32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<16x32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16x32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16x32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32xf32> // CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32xf32>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<16xf32> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<16xf32>
// CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
// CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = arith.addi %[[VAL_12]], %[[VAL_5]] : index // CHECK-DAG: %[[VAL_14:.*]] = arith.addi %[[VAL_12]], %[[VAL_5]] : index
// CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_14]]] : memref<?xindex> // CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_14]]] : memref<?xindex>
// CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_12]]] : memref<16xf32> // CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_12]]] : memref<16xf32>
// CHECK: %[[VAL_17:.*]] = scf.for %[[VAL_18:.*]] = %[[VAL_13]] to %[[VAL_15]] step %[[VAL_5]] iter_args(%[[VAL_19:.*]] = %[[VAL_16]]) -> (f32) { // CHECK: %[[VAL_17:.*]] = scf.for %[[VAL_18:.*]] = %[[VAL_13]] to %[[VAL_15]] step %[[VAL_5]] iter_args(%[[VAL_19:.*]] = %[[VAL_16]]) -> (f32) {
Show All 26 Lines indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> ()> // x (scalar out) affine_map<(i,j) -> ()> // x (scalar out)
], ],
iterator_types = ["reduction", "reduction"], iterator_types = ["reduction", "reduction"],
doc = "x += SUM_ij A(i,j)" doc = "x += SUM_ij A(i,j)"
} }
// CHECK-LABEL: func @sum_reduction( // CHECK-LABEL: func @sum_reduction(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<f32>) -> tensor<f32> { // CHECK-SAME: %[[VAL_1:.*]]: tensor<f32>) -> tensor<f32> {
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 10 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 10 : index
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_1]] : memref<f32> // CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_1]] : memref<f32>
// CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<f32> // CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<f32>
// CHECK: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_4]] to %[[VAL_2]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_9]]) -> (f32) { // CHECK: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_4]] to %[[VAL_2]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_9]]) -> (f32) {
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xindex> // CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xindex>
// CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_11]], %[[VAL_3]] : index // CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_11]], %[[VAL_3]] : index
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_14]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_14]]] : memref<?xindex>
// CHECK: %[[VAL_16:.*]] = scf.for %[[VAL_17:.*]] = %[[VAL_13]] to %[[VAL_15]] step %[[VAL_3]] iter_args(%[[VAL_18:.*]] = %[[VAL_12]]) -> (f32) { // CHECK: %[[VAL_16:.*]] = scf.for %[[VAL_17:.*]] = %[[VAL_13]] to %[[VAL_15]] step %[[VAL_3]] iter_args(%[[VAL_18:.*]] = %[[VAL_12]]) -> (f32) {
// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_17]]] : memref<?xf32> // CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_17]]] : memref<?xf32>
Show All 22 Lines indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
doc = "X(i,j) = A(i,j) * SCALE" doc = "X(i,j) = A(i,j) * SCALE"
} }
// CHECK-LABEL: func @scale( // CHECK-LABEL: func @scale(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<?x?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<?x?xf64>) -> tensor<?x?xf64> { // CHECK-SAME: %[[VAL_1:.*]]: tensor<?x?xf64>) -> tensor<?x?xf64> {
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 2.000000e+00 : f64 // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 2.000000e+00 : f64
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<?x?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<?x?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?x?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf64> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf64>
// CHECK-DAG: %[[VAL_8:.*]] = tensor.dim %[[VAL_0]], %[[VAL_3]] : tensor<?x?xf64, #sparse_tensor.encoding<{{{.*}}}>> // CHECK-DAG: %[[VAL_8:.*]] = tensor.dim %[[VAL_0]], %[[VAL_3]] : tensor<?x?xf64, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<?x?xf64> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<?x?xf64>
// CHECK: linalg.fill ins(%{{.*}} : f64) outs(%[[VAL_11]] : memref<?x?xf64>) // CHECK: linalg.fill ins(%{{.*}} : f64) outs(%[[VAL_11]] : memref<?x?xf64>)
// CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_3]] to %[[VAL_8]] step %[[VAL_4]] { // CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_3]] to %[[VAL_8]] step %[[VAL_4]] {
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xindex> // CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xindex>
// CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_12]], %[[VAL_4]] : index // CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_12]], %[[VAL_4]] : index
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_14]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_14]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_15]] step %[[VAL_4]] { // CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_15]] step %[[VAL_4]] {
Show All 25 Lines indexing_maps = [
affine_map<(i,j,k) -> (k,j)>, // B affine_map<(i,j,k) -> (k,j)>, // B
affine_map<(i,j,k) -> (i,j)> // X (out) affine_map<(i,j,k) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel", "reduction"], iterator_types = ["parallel", "parallel", "reduction"],
doc = "X(i,j) += S(i,j) SUM_k A(i,k) B(k,j)" doc = "X(i,j) += S(i,j) SUM_k A(i,k) B(k,j)"
} }
// CHECK-LABEL: func.func @sampled_dense_dense( // CHECK-LABEL: func.func @sampled_dense_dense(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<?x?xf32>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<?x?xf32>,
// CHECK-SAME: %[[VAL_2:.*2]]: tensor<?x?xf32>, // CHECK-SAME: %[[VAL_2:.*2]]: tensor<?x?xf32>,
// CHECK-SAME: %[[VAL_3:.*3]]: tensor<?x?xf32>) -> tensor<?x?xf32> { // CHECK-SAME: %[[VAL_3:.*3]]: tensor<?x?xf32>) -> tensor<?x?xf32> {
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_11:.*]] = tensor.dim %[[VAL_1]], %[[VAL_4]] : tensor<?x?xf32> // CHECK-DAG: %[[VAL_11:.*]] = tensor.dim %[[VAL_1]], %[[VAL_4]] : tensor<?x?xf32>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_1]] : memref<?x?xf32> // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_1]] : memref<?x?xf32>
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<?x?xf32> // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<?x?xf32>
// CHECK-DAG: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_3]] : memref<?x?xf32> // CHECK-DAG: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_3]] : memref<?x?xf32>
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_4]] { // CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_4]] {
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_17]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_17]]] : memref<?xindex>
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines indexing_maps = [
affine_map<(i,j) -> ()>, // e affine_map<(i,j) -> ()>, // e
affine_map<(i,j) -> (i)> // x (out) affine_map<(i,j) -> (i)> // x (out)
], ],
iterator_types = ["parallel", "reduction"], iterator_types = ["parallel", "reduction"],
doc = "x(i) = SUM_j A(i,j) * B(i,j) * d(i) * e + C(i,j)" doc = "x(i) = SUM_j A(i,j) * B(i,j) * d(i) * e + C(i,j)"
} }
// CHECK-LABEL: func @sum_kernel_with_inv( // CHECK-LABEL: func @sum_kernel_with_inv(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*2]]: tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_2:.*2]]: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_3:.*3]]: tensor<?xf32>, // CHECK-SAME: %[[VAL_3:.*3]]: tensor<?xf32>,
// CHECK-SAME: %[[VAL_4:.*4]]: tensor<f32>, // CHECK-SAME: %[[VAL_4:.*4]]: tensor<f32>,
// CHECK-SAME: %[[VAL_5:.*5]]: tensor<?xf32>) -> tensor<?xf32> { // CHECK-SAME: %[[VAL_5:.*5]]: tensor<?xf32>) -> tensor<?xf32> {
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_8:.*]] = arith.constant true // CHECK-DAG: %[[VAL_8:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_16:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf32> // CHECK: %[[VAL_16:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_17:.*]] = sparse_tensor.positions %[[VAL_2]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_17:.*]] = sparse_tensor.positions %[[VAL_2]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_18:.*]] = sparse_tensor.coordinates %[[VAL_2]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_18:.*]] = sparse_tensor.coordinates %[[VAL_2]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_19:.*]] = sparse_tensor.values %[[VAL_2]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_19:.*]] = sparse_tensor.values %[[VAL_2]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_20:.*]] = bufferization.to_memref %[[VAL_3]] : memref<?xf32> // CHECK-DAG: %[[VAL_20:.*]] = bufferization.to_memref %[[VAL_3]] : memref<?xf32>
// CHECK-DAG: %[[VAL_21:.*]] = bufferization.to_memref %[[VAL_4]] : memref<f32> // CHECK-DAG: %[[VAL_21:.*]] = bufferization.to_memref %[[VAL_4]] : memref<f32>
// CHECK-DAG: %[[VAL_22:.*]] = tensor.dim %[[VAL_2]], %[[VAL_6]] : tensor<?x?xf32, // CHECK-DAG: %[[VAL_22:.*]] = tensor.dim %[[VAL_2]], %[[VAL_6]] : tensor<?x?xf32,
// CHECK-DAG: %[[VAL_24:.*]] = bufferization.to_memref %[[VAL_5]] : memref<?xf32> // CHECK-DAG: %[[VAL_24:.*]] = bufferization.to_memref %[[VAL_5]] : memref<?xf32>
// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_21]][] : memref<f32> // CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_21]][] : memref<f32>
// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_6]]] : memref<?xindex> // CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_6]]] : memref<?xindex>
// CHECK: %[[VAL_27:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex> // CHECK: %[[VAL_27:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex>
// CHECK: %[[VAL_28:.*]]:2 = scf.while (%[[VAL_29:.*]] = %[[VAL_26]], %[[VAL_30:.*]] = %[[VAL_6]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_28:.*]]:2 = scf.while (%[[VAL_29:.*]] = %[[VAL_26]], %[[VAL_30:.*]] = %[[VAL_6]]) : (index, index) -> (index, index) {
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_3d.mlir

// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#Td = #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }> #Td = #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>
#Tddd = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense" ] }> #Tddd = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "dense" ] }>
#Tdds = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }> #Tdds = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>
#Tdsd = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ] }> #Tdsd = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "dense" ] }>
#Tdss = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }> #Tdss = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "compressed" ] }>
#Tsdd = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ] }> #Tsdd = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "dense" ] }>
#Tsds = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }> #Tsds = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "compressed" ] }>
#Tssd = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }> #Tssd = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense" ] }>
#Tsss = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }> #Tsss = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>
#trait3 = { #trait3 = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j,k) -> (i,j,k)>, // A affine_map<(i,j,k) -> (i,j,k)>, // A
affine_map<(i,j,k) -> (i,j,k)>, // B affine_map<(i,j,k) -> (i,j,k)>, // B
affine_map<(i,j,k) -> (i,j,k)> // X (out) affine_map<(i,j,k) -> (i,j,k)> // X (out)
], ],
iterator_types = ["parallel", "parallel", "parallel"], iterator_types = ["parallel", "parallel", "parallel"],
doc = "X(i,j,k) = A(i,j,k) OP B(i,j,k)" doc = "X(i,j,k) = A(i,j,k) OP B(i,j,k)"
} }
// CHECK-LABEL: func @add_ddd( // CHECK-LABEL: func @add_ddd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_11]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_11]] : memref<32x16x8xf32>)
// CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_6]] to %[[VAL_3]] step %[[VAL_7]] { // CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_6]] to %[[VAL_3]] step %[[VAL_7]] {
// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_7]] { // CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_7]] {
// CHECK: %[[VAL_14:.*]] = arith.muli %[[VAL_12]], %[[VAL_4]] : index // CHECK: %[[VAL_14:.*]] = arith.muli %[[VAL_12]], %[[VAL_4]] : index
// CHECK: %[[VAL_15:.*]] = arith.addi %[[VAL_14]], %[[VAL_13]] : index // CHECK: %[[VAL_15:.*]] = arith.addi %[[VAL_14]], %[[VAL_13]] : index
// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] { // CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] {
Show All 16 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @mul_ddd( // CHECK-LABEL: func @mul_ddd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_11]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_11]] : memref<32x16x8xf32>)
// CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_6]] to %[[VAL_3]] step %[[VAL_7]] { // CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_6]] to %[[VAL_3]] step %[[VAL_7]] {
// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_7]] { // CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_7]] {
// CHECK: %[[VAL_14:.*]] = arith.muli %[[VAL_12]], %[[VAL_4]] : index // CHECK: %[[VAL_14:.*]] = arith.muli %[[VAL_12]], %[[VAL_4]] : index
// CHECK: %[[VAL_15:.*]] = arith.addi %[[VAL_14]], %[[VAL_13]] : index // CHECK: %[[VAL_15:.*]] = arith.addi %[[VAL_14]], %[[VAL_13]] : index
// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] { // CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] {
Show All 16 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @add_dds( // CHECK-LABEL: func @add_dds(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_8:.*]] = arith.constant true // CHECK-DAG: %[[VAL_8:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_9:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_15]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_15]] : memref<32x16x8xf32>)
// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_9]] { // CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_9]] {
// CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_9]] { // CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_9]] {
// CHECK: %[[VAL_18:.*]] = arith.muli %[[VAL_16]], %[[VAL_5]] : index // CHECK: %[[VAL_18:.*]] = arith.muli %[[VAL_16]], %[[VAL_5]] : index
// CHECK: %[[VAL_19:.*]] = arith.addi %[[VAL_18]], %[[VAL_17]] : index // CHECK: %[[VAL_19:.*]] = arith.addi %[[VAL_18]], %[[VAL_17]] : index
// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_19]]] : memref<?xindex> // CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_19]]] : memref<?xindex>
Show All 40 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @mul_dds( // CHECK-LABEL: func @mul_dds(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_13]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_13]] : memref<32x16x8xf32>)
// CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_7]] { // CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_7]] {
// CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] { // CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] {
// CHECK: %[[VAL_16:.*]] = arith.muli %[[VAL_14]], %[[VAL_5]] : index // CHECK: %[[VAL_16:.*]] = arith.muli %[[VAL_14]], %[[VAL_5]] : index
// CHECK: %[[VAL_17:.*]] = arith.addi %[[VAL_16]], %[[VAL_15]] : index // CHECK: %[[VAL_17:.*]] = arith.addi %[[VAL_16]], %[[VAL_15]] : index
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_17]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_17]]] : memref<?xindex>
Show All 18 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @add_dsd( // CHECK-LABEL: func @add_dsd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant true // CHECK-DAG: %[[VAL_6:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_8:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_14]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_14]] : memref<32x16x8xf32>)
// CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_7]] to %[[VAL_3]] step %[[VAL_8]] { // CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_7]] to %[[VAL_3]] step %[[VAL_8]] {
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_15]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_15]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]] = arith.addi %[[VAL_15]], %[[VAL_8]] : index // CHECK: %[[VAL_17:.*]] = arith.addi %[[VAL_15]], %[[VAL_8]] : index
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_17]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_17]]] : memref<?xindex>
// CHECK: %[[VAL_19:.*]]:2 = scf.while (%[[VAL_20:.*]] = %[[VAL_16]], %[[VAL_21:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_19:.*]]:2 = scf.while (%[[VAL_20:.*]] = %[[VAL_16]], %[[VAL_21:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @mul_dsd( // CHECK-LABEL: func @mul_dsd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_12]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_12]] : memref<32x16x8xf32>)
// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] {
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xindex> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xindex>
// CHECK: %[[VAL_15:.*]] = arith.addi %[[VAL_13]], %[[VAL_6]] : index // CHECK: %[[VAL_15:.*]] = arith.addi %[[VAL_13]], %[[VAL_6]] : index
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_16]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_16]] step %[[VAL_6]] {
Show All 18 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @add_dss( // CHECK-LABEL: func @add_dss(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant true // CHECK-DAG: %[[VAL_7:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_8:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_9:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_17:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_17:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_17]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_17]] : memref<32x16x8xf32>)
// CHECK: scf.for %[[VAL_18:.*]] = %[[VAL_8]] to %[[VAL_4]] step %[[VAL_9]] { // CHECK: scf.for %[[VAL_18:.*]] = %[[VAL_8]] to %[[VAL_4]] step %[[VAL_9]] {
// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_18]]] : memref<?xindex> // CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_18]]] : memref<?xindex>
// CHECK: %[[VAL_20:.*]] = arith.addi %[[VAL_18]], %[[VAL_9]] : index // CHECK: %[[VAL_20:.*]] = arith.addi %[[VAL_18]], %[[VAL_9]] : index
// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_20]]] : memref<?xindex> // CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_20]]] : memref<?xindex>
// CHECK: %[[VAL_22:.*]]:2 = scf.while (%[[VAL_23:.*]] = %[[VAL_19]], %[[VAL_24:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_22:.*]]:2 = scf.while (%[[VAL_23:.*]] = %[[VAL_19]], %[[VAL_24:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) {
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @mul_dss( // CHECK-LABEL: func @mul_dss(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_14]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_14]] : memref<32x16x8xf32>)
// CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] {
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]] = arith.addi %[[VAL_15]], %[[VAL_6]] : index // CHECK: %[[VAL_17:.*]] = arith.addi %[[VAL_15]], %[[VAL_6]] : index
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_17]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_17]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_18]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_18]] step %[[VAL_6]] {
Show All 20 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @add_sdd( // CHECK-LABEL: func @add_sdd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant true // CHECK-DAG: %[[VAL_6:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_8:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_14]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_14]] : memref<32x16x8xf32>)
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex>
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_8]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_8]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_15]], %[[VAL_19:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_15]], %[[VAL_19:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_20:.*]] = arith.cmpi ult, %[[VAL_18]], %[[VAL_16]] : index // CHECK: %[[VAL_20:.*]] = arith.cmpi ult, %[[VAL_18]], %[[VAL_16]] : index
// CHECK: scf.condition(%[[VAL_20]]) %[[VAL_18]], %[[VAL_19]] : index, index // CHECK: scf.condition(%[[VAL_20]]) %[[VAL_18]], %[[VAL_19]] : index, index
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @mul_sdd( // CHECK-LABEL: func @mul_sdd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_12]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_12]] : memref<32x16x8xf32>)
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_6]] {
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_15]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_15]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] {
Show All 19 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @add_sds( // CHECK-LABEL: func @add_sds(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant true // CHECK-DAG: %[[VAL_7:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_8:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_9:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_17:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_17:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_17]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_17]] : memref<32x16x8xf32>)
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_8]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_8]]] : memref<?xindex>
// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_9]]] : memref<?xindex> // CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_9]]] : memref<?xindex>
// CHECK: %[[VAL_20:.*]]:2 = scf.while (%[[VAL_21:.*]] = %[[VAL_18]], %[[VAL_22:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_20:.*]]:2 = scf.while (%[[VAL_21:.*]] = %[[VAL_18]], %[[VAL_22:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_23:.*]] = arith.cmpi ult, %[[VAL_21]], %[[VAL_19]] : index // CHECK: %[[VAL_23:.*]] = arith.cmpi ult, %[[VAL_21]], %[[VAL_19]] : index
// CHECK: scf.condition(%[[VAL_23]]) %[[VAL_21]], %[[VAL_22]] : index, index // CHECK: scf.condition(%[[VAL_23]]) %[[VAL_21]], %[[VAL_22]] : index, index
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @mul_sds( // CHECK-LABEL: func @mul_sds(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_14]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_14]] : memref<32x16x8xf32>)
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_6]] {
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_17]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_17]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_19:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_19:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] {
Show All 21 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @add_ssd( // CHECK-LABEL: func @add_ssd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant true // CHECK-DAG: %[[VAL_6:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_8:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_16:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_16:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_16]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_16]] : memref<32x16x8xf32>)
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_8]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_8]]] : memref<?xindex>
// CHECK: %[[VAL_19:.*]]:2 = scf.while (%[[VAL_20:.*]] = %[[VAL_17]], %[[VAL_21:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_19:.*]]:2 = scf.while (%[[VAL_20:.*]] = %[[VAL_17]], %[[VAL_21:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_22:.*]] = arith.cmpi ult, %[[VAL_20]], %[[VAL_18]] : index // CHECK: %[[VAL_22:.*]] = arith.cmpi ult, %[[VAL_20]], %[[VAL_18]] : index
// CHECK: scf.condition(%[[VAL_22]]) %[[VAL_20]], %[[VAL_21]] : index, index // CHECK: scf.condition(%[[VAL_22]]) %[[VAL_20]], %[[VAL_21]] : index, index
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @mul_ssd( // CHECK-LABEL: func @mul_ssd(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_13]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_13]] : memref<32x16x8xf32>)
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_5]] {
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_16]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_16]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xindex>
Show All 21 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @add_sss( // CHECK-LABEL: func @add_sss(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 32 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 32 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 16 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant true // CHECK-DAG: %[[VAL_7:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_8:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_9:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_16:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_16:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_17:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_17:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_19:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_19:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_19]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_19]] : memref<32x16x8xf32>)
// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_8]]] : memref<?xindex> // CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_8]]] : memref<?xindex>
// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_9]]] : memref<?xindex> // CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_9]]] : memref<?xindex>
// CHECK: %[[VAL_22:.*]]:2 = scf.while (%[[VAL_23:.*]] = %[[VAL_20]], %[[VAL_24:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_22:.*]]:2 = scf.while (%[[VAL_23:.*]] = %[[VAL_20]], %[[VAL_24:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_25:.*]] = arith.cmpi ult, %[[VAL_23]], %[[VAL_21]] : index // CHECK: %[[VAL_25:.*]] = arith.cmpi ult, %[[VAL_23]], %[[VAL_21]] : index
// CHECK: scf.condition(%[[VAL_25]]) %[[VAL_23]], %[[VAL_24]] : index, index // CHECK: scf.condition(%[[VAL_25]]) %[[VAL_23]], %[[VAL_24]] : index, index
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines outs(%argx: tensor<32x16x8xf32>) {
^bb(%a: f32, %b: f32, %x: f32): ^bb(%a: f32, %b: f32, %x: f32):
%0 = arith.addf %a, %b : f32 %0 = arith.addf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<32x16x8xf32> } -> tensor<32x16x8xf32>
return %0 : tensor<32x16x8xf32> return %0 : tensor<32x16x8xf32>
} }
// CHECK-LABEL: func @mul_sss( // CHECK-LABEL: func @mul_sss(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_1]] : memref<32x16x8xf32>
// CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32> // CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32x16x8xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_15]] : memref<32x16x8xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_15]] : memref<32x16x8xf32>)
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_18:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_18:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_5]] {
// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_18]]] : memref<?xindex> // CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_18]]] : memref<?xindex>
// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_18]]] : memref<?xindex> // CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_18]]] : memref<?xindex>
Show All 35 Lines indexing_maps = [
affine_map<(i,j,k,l) -> (i,j)> // A (out) affine_map<(i,j,k,l) -> (i,j)> // A (out)
], ],
iterator_types = ["parallel", "parallel", "reduction", "reduction"], iterator_types = ["parallel", "parallel", "reduction", "reduction"],
doc = "A(i,j) += SUM_k,l B(i,k,l) * C(k,j) * D(l,j)" doc = "A(i,j) += SUM_k,l B(i,k,l) * C(k,j) * D(l,j)"
} }
// CHECK-LABEL: func @kernel_3d( // CHECK-LABEL: func @kernel_3d(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<?x?xf32>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<?x?xf32>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<?x?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<?x?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*2]]: tensor<?x?xf32>, // CHECK-SAME: %[[VAL_2:.*2]]: tensor<?x?xf32>,
// CHECK-SAME: %[[VAL_3:.*3]]: tensor<?x?xf32>) -> tensor<?x?xf32> { // CHECK-SAME: %[[VAL_3:.*3]]: tensor<?x?xf32>) -> tensor<?x?xf32> {
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 2 : index} : tensor<?x?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 2 : index} : tensor<?x?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 2 : index} : tensor<?x?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 2 : index} : tensor<?x?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_10:.*]] = tensor.dim %[[VAL_1]], %[[VAL_6]] : tensor<?x?x?xf32, #sparse_tensor.encoding<{{{.*}}}>> // CHECK-DAG: %[[VAL_10:.*]] = tensor.dim %[[VAL_1]], %[[VAL_6]] : tensor<?x?x?xf32, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<?x?xf32> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<?x?xf32>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_3]] : memref<?x?xf32> // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_3]] : memref<?x?xf32>
// CHECK-DAG: %[[VAL_13:.*]] = tensor.dim %[[VAL_1]], %[[VAL_5]] : tensor<?x?x?xf32, #sparse_tensor.encoding<{{{.*}}}>> // CHECK-DAG: %[[VAL_13:.*]] = tensor.dim %[[VAL_1]], %[[VAL_5]] : tensor<?x?x?xf32, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK-DAG: %[[VAL_14:.*]] = tensor.dim %[[VAL_2]], %[[VAL_6]] : tensor<?x?xf32> // CHECK-DAG: %[[VAL_14:.*]] = tensor.dim %[[VAL_2]], %[[VAL_6]] : tensor<?x?xf32>
// CHECK-DAG: %[[VAL_16:.*]] = bufferization.to_memref %[[VAL_0]] : memref<?x?xf32> // CHECK-DAG: %[[VAL_16:.*]] = bufferization.to_memref %[[VAL_0]] : memref<?x?xf32>
// CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_5]] to %[[VAL_13]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_5]] to %[[VAL_13]] step %[[VAL_6]] {
// CHECK: scf.for %[[VAL_18:.*]] = %[[VAL_5]] to %[[VAL_10]] step %[[VAL_6]] { // CHECK: scf.for %[[VAL_18:.*]] = %[[VAL_5]] to %[[VAL_10]] step %[[VAL_6]] {
▲ Show 20 Lines • Show All 152 Lines • ▼ Show 20 Lines indexing_maps = [
affine_map<(i,j,k) -> (k)>, // c affine_map<(i,j,k) -> (k)>, // c
affine_map<(i,j,k) -> (i,j,k)> // X (out) affine_map<(i,j,k) -> (i,j,k)> // X (out)
], ],
iterator_types = ["parallel", "parallel", "parallel"], iterator_types = ["parallel", "parallel", "parallel"],
doc = "X(i,j,k) = a(i) * b(j) * c(k)" doc = "X(i,j,k) = a(i) * b(j) * c(k)"
} }
// CHECK-LABEL: func @invariants( // CHECK-LABEL: func @invariants(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<10xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<10xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<20xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<20xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<30xf32>, // CHECK-SAME: %[[VAL_2:.*]]: tensor<30xf32>,
// CHECK-SAME: %[[VAL_3:.*]]: tensor<10x20x30xf32>) -> tensor<10x20x30xf32> { // CHECK-SAME: %[[VAL_3:.*]]: tensor<10x20x30xf32>) -> tensor<10x20x30xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 10 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 10 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 20 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 20 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 30 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 30 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_8:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_1]] : memref<20xf32> // CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_1]] : memref<20xf32>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<30xf32> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<30xf32>
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_3]] : memref<10x20x30xf32> // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_3]] : memref<10x20x30xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_13]] : memref<10x20x30xf32>) // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_13]] : memref<10x20x30xf32>)
// CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_8]] { // CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_8]] {
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_14]]] : memref<?xf32> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_14]]] : memref<?xf32>
// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] { // CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] {
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_16]]] : memref<20xf32> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_16]]] : memref<20xf32>
Show All 25 Lines

mlir/test/Dialect/SparseTensor/sparse_affine.mlir

// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#SpVec = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SpVec = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#CSR = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }> #CSR = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>
#Row = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense" ] }> #Row = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "dense" ] }>
#EncDenseVec = #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }> #EncDenseVec = #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>
#trait1 = { #trait1 = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (3)>, // b affine_map<(i) -> (3)>, // b
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
▲ Show 20 Lines • Show All 483 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_broadcast.mlir

// RUN: mlir-opt %s --sparsification --canonicalize --cse | FileCheck %s // RUN: mlir-opt %s --sparsification --canonicalize --cse | FileCheck %s
#DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
#SparseTensor = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }> #SparseTensor = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(d0, d1, d2) -> (d0, d2)>, affine_map<(d0, d1, d2) -> (d0, d2)>,
affine_map<(d0, d1, d2) -> (d0, d1, d2)> affine_map<(d0, d1, d2) -> (d0, d1, d2)>
], ],
iterator_types = ["parallel", "parallel", "parallel"] iterator_types = ["parallel", "parallel", "parallel"]
} }
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_concat.mlir

// RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s // RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s
#SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #SparseMatrix = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
#SparseMatrix_P = #sparse_tensor.encoding<{ #SparseMatrix_P = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#SparseMatrix_D_P = #sparse_tensor.encoding<{ #SparseMatrix_D_P = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense" ], lvlTypes = [ "dense", "dense" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
// CHECK-LABEL: func.func @concat_mix_dense( // CHECK-LABEL: func.func @concat_mix_dense(
// CHECK-SAME: %[[TMP_arg0:.*]]: tensor<2x4xf64>, // CHECK-SAME: %[[TMP_arg0:.*]]: tensor<2x4xf64>,
// CHECK-SAME: %[[TMP_arg1:.*]]: !llvm.ptr<i8>) // CHECK-SAME: %[[TMP_arg1:.*]]: !llvm.ptr<i8>)
// CHECK-DAG: %[[TMP_c2:.*]] = arith.constant 2 : index // CHECK-DAG: %[[TMP_c2:.*]] = arith.constant 2 : index
// CHECK-DAG: %[[TMP_c6_i32:.*]] = arith.constant 6 : i32 // CHECK-DAG: %[[TMP_c6_i32:.*]] = arith.constant 6 : i32
▲ Show 20 Lines • Show All 443 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_concat_codegen.mlir

// RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-convert=false" \ // RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-convert=false" \
// RUN: | FileCheck %s // RUN: | FileCheck %s
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
#DENSE = #sparse_tensor.encoding<{dimLevelType = ["dense", "dense"]}> #DENSE = #sparse_tensor.encoding<{lvlTypes = ["dense", "dense"]}>
#DENSE_P = #sparse_tensor.encoding<{ #DENSE_P = #sparse_tensor.encoding<{
dimLevelType = ["dense", "dense"], lvlTypes = ["dense", "dense"],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
// CHECK-LABEL: @concat_sparse_sparse( // CHECK-LABEL: @concat_sparse_sparse(
// CHECK-SAME: %[[TMP_arg0:.*]]: tensor<2x4xf64, #sparse_tensor // CHECK-SAME: %[[TMP_arg0:.*]]: tensor<2x4xf64, #sparse_tensor
// CHECK-SAME: %[[TMP_arg1:.*]]: tensor<3x4xf64, #sparse_tensor // CHECK-SAME: %[[TMP_arg1:.*]]: tensor<3x4xf64, #sparse_tensor
// CHECK-SAME: %[[TMP_arg2:.*]]: tensor<4x4xf64, #sparse_tensor // CHECK-SAME: %[[TMP_arg2:.*]]: tensor<4x4xf64, #sparse_tensor
// CHECK: %[[TMP_c0:.*]] = arith.constant 0 : index // CHECK: %[[TMP_c0:.*]] = arith.constant 0 : index
// CHECK: %[[TMP_c1:.*]] = arith.constant 1 : index // CHECK: %[[TMP_c1:.*]] = arith.constant 1 : index
▲ Show 20 Lines • Show All 249 Lines • ▼ Show 20 Lines
// CHECK-SAME: %[[TMP_arg2:.*]]: tensor<4x4xf64, #sparse_tensor // CHECK-SAME: %[[TMP_arg2:.*]]: tensor<4x4xf64, #sparse_tensor
// CHECK-DAG: %[[TMP_c0:.*]] = arith.constant 0 : index // CHECK-DAG: %[[TMP_c0:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[TMP_c1:.*]] = arith.constant 1 : index // CHECK-DAG: %[[TMP_c1:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[TMP_c5:.*]] = arith.constant 5 : index // CHECK-DAG: %[[TMP_c5:.*]] = arith.constant 5 : index
// CHECK-DAG: %[[TMP_c2:.*]] = arith.constant 2 : index // CHECK-DAG: %[[TMP_c2:.*]] = arith.constant 2 : index
// CHECK-DAG: %[[TMP_c9:.*]] = arith.constant 9 : index // CHECK-DAG: %[[TMP_c9:.*]] = arith.constant 9 : index
// CHECK-DAG: %[[TMP_c4:.*]] = arith.constant 4 : index // CHECK-DAG: %[[TMP_c4:.*]] = arith.constant 4 : index
// CHECK: %[[TMP_0:.*]] = bufferization.alloc_tensor(%[[TMP_c9]], %[[TMP_c4]]) : tensor<?x?xf64, #sparse_tensor // CHECK: %[[TMP_0:.*]] = bufferization.alloc_tensor(%[[TMP_c9]], %[[TMP_c4]]) : tensor<?x?xf64, #sparse_tensor
// CHECK: %[[VAL_0:.*]] = sparse_tensor.values %[[TMP_0]] : tensor<?x?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense" ] }>> to memref<?xf64> // CHECK: %[[VAL_0:.*]] = sparse_tensor.values %[[TMP_0]] : tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ] }>> to memref<?xf64>
// CHECK: %[[DIM_0:.*]] = memref.alloca() : memref<2xindex> // CHECK: %[[DIM_0:.*]] = memref.alloca() : memref<2xindex>
// CHECK: memref.store %[[TMP_c9]], %[[DIM_0]][%[[TMP_c0]]] : memref<2xindex> // CHECK: memref.store %[[TMP_c9]], %[[DIM_0]][%[[TMP_c0]]] : memref<2xindex>
// CHECK: memref.store %[[TMP_c4]], %[[DIM_0]][%[[TMP_c1]]] : memref<2xindex> // CHECK: memref.store %[[TMP_c4]], %[[DIM_0]][%[[TMP_c1]]] : memref<2xindex>
// CHECK: %[[VAL_1:.*]] = memref.reshape %[[VAL_0]](%[[DIM_0]]) : (memref<?xf64>, memref<2xindex>) -> memref<?x?xf64> // CHECK: %[[VAL_1:.*]] = memref.reshape %[[VAL_0]](%[[DIM_0]]) : (memref<?xf64>, memref<2xindex>) -> memref<?x?xf64>
// CHECK: %[[TMP_1:.*]] = sparse_tensor.positions %[[TMP_arg0]] {level = 0 : index} : tensor<2x4xf64, #sparse_tensor // CHECK: %[[TMP_1:.*]] = sparse_tensor.positions %[[TMP_arg0]] {level = 0 : index} : tensor<2x4xf64, #sparse_tensor
// CHECK: %[[TMP_2:.*]] = sparse_tensor.coordinates %[[TMP_arg0]] {level = 0 : index} : tensor<2x4xf64, #sparse_tensor // CHECK: %[[TMP_2:.*]] = sparse_tensor.coordinates %[[TMP_arg0]] {level = 0 : index} : tensor<2x4xf64, #sparse_tensor
// CHECK: %[[TMP_3:.*]] = sparse_tensor.positions %[[TMP_arg0]] {level = 1 : index} : tensor<2x4xf64, #sparse_tensor // CHECK: %[[TMP_3:.*]] = sparse_tensor.positions %[[TMP_arg0]] {level = 1 : index} : tensor<2x4xf64, #sparse_tensor
// CHECK: %[[TMP_4:.*]] = sparse_tensor.coordinates %[[TMP_arg0]] {level = 1 : index} : tensor<2x4xf64, #sparse_tensor // CHECK: %[[TMP_4:.*]] = sparse_tensor.coordinates %[[TMP_arg0]] {level = 1 : index} : tensor<2x4xf64, #sparse_tensor
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
// CHECK: scf.for %[[TMP_arg4:.*]] = %[[TMP_25]] to %[[TMP_26]] step %[[TMP_c1]] // CHECK: scf.for %[[TMP_arg4:.*]] = %[[TMP_25]] to %[[TMP_26]] step %[[TMP_c1]]
// CHECK: %[[TMP_27:.*]] = memref.load %[[TMP_18]][%[[TMP_arg4]]] : memref<?xindex> // CHECK: %[[TMP_27:.*]] = memref.load %[[TMP_18]][%[[TMP_arg4]]] : memref<?xindex>
// CHECK: %[[TMP_28:.*]] = memref.load %[[TMP_19]][%[[TMP_arg4]]] : memref<?xf64> // CHECK: %[[TMP_28:.*]] = memref.load %[[TMP_19]][%[[TMP_arg4]]] : memref<?xf64>
// CHECK: %[[TMP_29:.*]] = arith.addi %[[TMP_23]], %[[TMP_c5]] : index // CHECK: %[[TMP_29:.*]] = arith.addi %[[TMP_23]], %[[TMP_c5]] : index
// CHECK: memref.store %[[TMP_28]], %[[VAL_1]][%[[TMP_29]], %[[TMP_27]]] : memref<?x?xf64> // CHECK: memref.store %[[TMP_28]], %[[VAL_1]][%[[TMP_29]], %[[TMP_27]]] : memref<?x?xf64>
// CHECK: } // CHECK: }
// CHECK: } // CHECK: }
// CHECK: %[[R:.*]] = sparse_tensor.convert %[[TMP_0]] // CHECK: %[[R:.*]] = sparse_tensor.convert %[[TMP_0]]
// CHECK: return %[[R]] : tensor<?x?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense" ] }>> // CHECK: return %[[R]] : tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ] }>>
func.func @concat_sparse_sparse_annotated_dense(%arg0: tensor<2x4xf64, #DCSR>, func.func @concat_sparse_sparse_annotated_dense(%arg0: tensor<2x4xf64, #DCSR>,
%arg1: tensor<3x4xf64, #DCSR>, %arg1: tensor<3x4xf64, #DCSR>,
%arg2: tensor<4x4xf64, #DCSR>) %arg2: tensor<4x4xf64, #DCSR>)
-> tensor<?x?xf64, #DENSE> { -> tensor<?x?xf64, #DENSE> {
%0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index} %0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index}
: tensor<2x4xf64, #DCSR>, : tensor<2x4xf64, #DCSR>,
tensor<3x4xf64, #DCSR>, tensor<3x4xf64, #DCSR>,
tensor<4x4xf64, #DCSR> to tensor<?x?xf64, #DENSE> tensor<4x4xf64, #DCSR> to tensor<?x?xf64, #DENSE>
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
// CHECK: scf.for %[[TMP_arg4:.*]] = %[[TMP_25]] to %[[TMP_26]] step %[[TMP_c1]] // CHECK: scf.for %[[TMP_arg4:.*]] = %[[TMP_25]] to %[[TMP_26]] step %[[TMP_c1]]
// CHECK: %[[TMP_27:.*]] = memref.load %[[TMP_18]][%[[TMP_arg4]]] : memref<?xindex> // CHECK: %[[TMP_27:.*]] = memref.load %[[TMP_18]][%[[TMP_arg4]]] : memref<?xindex>
// CHECK: %[[TMP_28:.*]] = memref.load %[[TMP_19]][%[[TMP_arg4]]] : memref<?xf64> // CHECK: %[[TMP_28:.*]] = memref.load %[[TMP_19]][%[[TMP_arg4]]] : memref<?xf64>
// CHECK: %[[TMP_29:.*]] = arith.addi %[[TMP_23]], %[[TMP_c5]] : index // CHECK: %[[TMP_29:.*]] = arith.addi %[[TMP_23]], %[[TMP_c5]] : index
// CHECK: memref.store %[[TMP_28]], %[[VAL_1]][%[[TMP_27]], %[[TMP_29]]] : memref<?x?xf64> // CHECK: memref.store %[[TMP_28]], %[[VAL_1]][%[[TMP_27]], %[[TMP_29]]] : memref<?x?xf64>
// CHECK: } // CHECK: }
// CHECK: } // CHECK: }
// CHECK: %[[R:.*]] = sparse_tensor.convert %[[TMP_0]] // CHECK: %[[R:.*]] = sparse_tensor.convert %[[TMP_0]]
// CHECK: return %[[R]] : tensor<?x?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> // CHECK: return %[[R]] : tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>
func.func @concat_sparse_sparse_annotated_dense_permute(%arg0: tensor<2x4xf64, #DCSR>, func.func @concat_sparse_sparse_annotated_dense_permute(%arg0: tensor<2x4xf64, #DCSR>,
%arg1: tensor<3x4xf64, #DCSR>, %arg1: tensor<3x4xf64, #DCSR>,
%arg2: tensor<4x4xf64, #DCSR>) %arg2: tensor<4x4xf64, #DCSR>)
-> tensor<?x?xf64, #DENSE_P> { -> tensor<?x?xf64, #DENSE_P> {
%0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index} %0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index}
: tensor<2x4xf64, #DCSR>, : tensor<2x4xf64, #DCSR>,
tensor<3x4xf64, #DCSR>, tensor<3x4xf64, #DCSR>,
tensor<4x4xf64, #DCSR> to tensor<?x?xf64, #DENSE_P> tensor<4x4xf64, #DCSR> to tensor<?x?xf64, #DENSE_P>
return %0 : tensor<?x?xf64, #DENSE_P> return %0 : tensor<?x?xf64, #DENSE_P>
} }

mlir/test/Dialect/SparseTensor/sparse_conv_2d_slice_based.mlir

// RUN: mlir-opt %s --sparsification="enable-index-reduction=true" --cse | FileCheck %s // RUN: mlir-opt %s --sparsification="enable-index-reduction=true" --cse | FileCheck %s
#map = affine_map<(d0, d1, d2, d3) -> (d0 + d2, d1 + d3)> #map = affine_map<(d0, d1, d2, d3) -> (d0 + d2, d1 + d3)>
#map1 = affine_map<(d0, d1, d2, d3) -> (d2, d3)> #map1 = affine_map<(d0, d1, d2, d3) -> (d2, d3)>
#map2 = affine_map<(d0, d1, d2, d3) -> (d0, d1)> #map2 = affine_map<(d0, d1, d2, d3) -> (d0, d1)>
#DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
// CHECK-LABEL: func.func @conv2d_all_sparse_CSR( // CHECK-LABEL: func.func @conv2d_all_sparse_CSR(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<8x8xi32, #{{.*}}>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<8x8xi32, #{{.*}}>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<3x3xi32>) -> tensor<6x6xi32, #{{.*}}> { // CHECK-SAME: %[[VAL_1:.*]]: tensor<3x3xi32>) -> tensor<6x6xi32, #{{.*}}> {
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 3 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 3 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
▲ Show 20 Lines • Show All 269 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_expand.mlir

// RUN: mlir-opt %s --linalg-generalize-named-ops \ // RUN: mlir-opt %s --linalg-generalize-named-ops \
// RUN: --linalg-fuse-elementwise-ops \ // RUN: --linalg-fuse-elementwise-ops \
// RUN: --sparsification | \ // RUN: --sparsification | \
// RUN: FileCheck %s --check-prefix=CHECK-SPARSE // RUN: FileCheck %s --check-prefix=CHECK-SPARSE
// RUN: mlir-opt %s --linalg-generalize-named-ops \ // RUN: mlir-opt %s --linalg-generalize-named-ops \
// RUN: --linalg-fuse-elementwise-ops \ // RUN: --linalg-fuse-elementwise-ops \
// RUN: --sparsification --sparse-tensor-conversion --cse | \ // RUN: --sparsification --sparse-tensor-conversion --cse | \
// RUN: FileCheck %s --check-prefix=CHECK-CONVERT // RUN: FileCheck %s --check-prefix=CHECK-CONVERT
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#DCSC = #sparse_tensor.encoding<{ #DCSC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#SV = #sparse_tensor.encoding<{ #SV = #sparse_tensor.encoding<{
dimLevelType = [ "compressed" ] lvlTypes = [ "compressed" ]
}> }>
#rowsum = { #rowsum = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (i)> // x (out) affine_map<(i,j) -> (i)> // x (out)
], ],
iterator_types = ["parallel", "reduction"], iterator_types = ["parallel", "reduction"],
▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_extract_slice.mlir

// RUN: mlir-opt %s --sparse-tensor-codegen --cse | FileCheck %s // RUN: mlir-opt %s --sparse-tensor-codegen --cse | FileCheck %s
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
#CSR_SLICE = #sparse_tensor.encoding<{ #CSR_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (0, 4, 1), (0, 8, 1) ] slice = [ (0, 4, 1), (0, 8, 1) ]
}> }>
// CHECK-LABEL: func.func @sparse_slice( // CHECK-LABEL: func.func @sparse_slice(
// CHECK-SAME: %[[VAL_0:.*0]]: memref<?xindex>, // CHECK-SAME: %[[VAL_0:.*0]]: memref<?xindex>,
// CHECK-SAME: %[[VAL_1:.*1]]: memref<?xindex>, // CHECK-SAME: %[[VAL_1:.*1]]: memref<?xindex>,
// CHECK-SAME: %[[VAL_2:.*2]]: memref<?xf64>, // CHECK-SAME: %[[VAL_2:.*2]]: memref<?xf64>,
// CHECK-SAME: %[[VAL_3:.*3]]: !sparse_tensor.storage_specifier<#sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>) // CHECK-SAME: %[[VAL_3:.*3]]: !sparse_tensor.storage_specifier<#sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>)
// CHECK: %[[VAL_4:.*]] = sparse_tensor.storage_specifier.init with %[[VAL_3]] // CHECK: %[[VAL_4:.*]] = sparse_tensor.storage_specifier.init with %[[VAL_3]]
// CHECK: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK: %[[VAL_6:.*]] = arith.constant 4 : index // CHECK: %[[VAL_6:.*]] = arith.constant 4 : index
// CHECK: %[[VAL_7:.*]] = arith.constant 1 : index // CHECK: %[[VAL_7:.*]] = arith.constant 1 : index
// CHECK: %[[VAL_8:.*]] = sparse_tensor.storage_specifier.set %[[VAL_4]] dim_offset at 0 with %[[VAL_5]] // CHECK: %[[VAL_8:.*]] = sparse_tensor.storage_specifier.set %[[VAL_4]] dim_offset at 0 with %[[VAL_5]]
// CHECK: %[[VAL_9:.*]] = sparse_tensor.storage_specifier.set %[[VAL_8]] lvl_sz at 0 with %[[VAL_6]] // CHECK: %[[VAL_9:.*]] = sparse_tensor.storage_specifier.set %[[VAL_8]] lvl_sz at 0 with %[[VAL_6]]
// CHECK: %[[VAL_10:.*]] = sparse_tensor.storage_specifier.set %[[VAL_9]] dim_stride at 0 with %[[VAL_7]] // CHECK: %[[VAL_10:.*]] = sparse_tensor.storage_specifier.set %[[VAL_9]] dim_stride at 0 with %[[VAL_7]]
// CHECK: %[[VAL_11:.*]] = arith.constant 8 : index // CHECK: %[[VAL_11:.*]] = arith.constant 8 : index
Show All 9 Lines

mlir/test/Dialect/SparseTensor/sparse_fill_zero.mlir

// RUN: mlir-opt %s --linalg-generalize-named-ops --pre-sparsification-rewrite --sparsification --sparse-tensor-conversion --canonicalize --cse | FileCheck %s // RUN: mlir-opt %s --linalg-generalize-named-ops --pre-sparsification-rewrite --sparsification --sparse-tensor-conversion --canonicalize --cse | FileCheck %s
#DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
// CHECK-LABEL: func.func @fill_zero_after_alloc( // CHECK-LABEL: func.func @fill_zero_after_alloc(
// CHECK-SAME: %[[Arg0:.*]]: !llvm.ptr<i8>, // CHECK-SAME: %[[Arg0:.*]]: !llvm.ptr<i8>,
// CHECK-SAME: %[[Arg1:.*]]: !llvm.ptr<i8>) -> !llvm.ptr<i8> { // CHECK-SAME: %[[Arg1:.*]]: !llvm.ptr<i8>) -> !llvm.ptr<i8> {
// CHECK-DAG: %[[F0:.*]] = arith.constant 0.000000e+00 : f64 // CHECK-DAG: %[[F0:.*]] = arith.constant 0.000000e+00 : f64
// CHECK-DAG: %[[C1:.*]] = arith.constant 1 : i32 // CHECK-DAG: %[[C1:.*]] = arith.constant 1 : i32
// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : i32 // CHECK-DAG: %[[C0:.*]] = arith.constant 0 : i32
// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index // CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_foreach.mlir

Show All 23 Linesfunc.func @sparse_foreach_constant() -> () {
sparse_tensor.foreach in %cst : tensor<8x7xf32> do { sparse_tensor.foreach in %cst : tensor<8x7xf32> do {
^bb0(%arg0: index, %arg1: index, %arg2: f32): ^bb0(%arg0: index, %arg1: index, %arg2: f32):
"test.use" (%arg0, %arg1, %arg2): (index,index,f32)->() "test.use" (%arg0, %arg1, %arg2): (index,index,f32)->()
} }
return return
} }
#CSR_SLICE = #sparse_tensor.encoding<{ #CSR_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
slice = [ (0, 4, 1), (2, 4, 1) ] slice = [ (0, 4, 1), (2, 4, 1) ]
}> }>
#CSR_SLICE_DYN = #sparse_tensor.encoding<{ #CSR_SLICE_DYN = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
slice = [ (?, ?, ?), (?, ?, ?) ] slice = [ (?, ?, ?), (?, ?, ?) ]
}> }>
// CHECK-LABEL: func.func @foreach_print_slice_dyn( // CHECK-LABEL: func.func @foreach_print_slice_dyn(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<?x?xf64, // CHECK-SAME: %[[VAL_0:.*]]: tensor<?x?xf64,
// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : index
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Linesfunc.func @foreach_print_slice(%A: tensor<4x4xf64, #CSR_SLICE>) {
sparse_tensor.foreach in %A : tensor<4x4xf64, #CSR_SLICE> do { sparse_tensor.foreach in %A : tensor<4x4xf64, #CSR_SLICE> do {
^bb0(%1: index, %2: index, %v: f64) : ^bb0(%1: index, %2: index, %v: f64) :
"test.use" (%v) : (f64) -> () "test.use" (%v) : (f64) -> ()
} }
return return
} }
#BCOO = #sparse_tensor.encoding<{ #BCOO = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed-hi-nu", "singleton" ], lvlTypes = [ "dense", "compressed-hi-nu", "singleton" ],
}> }>
// CHECK-LABEL: func.func @foreach_bcoo( // CHECK-LABEL: func.func @foreach_bcoo(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<4x4x4xf64, #{{.*}}>>) { // CHECK-SAME: %[[VAL_0:.*]]: tensor<4x4x4xf64, #{{.*}}>>) {
// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 4 : index // CHECK-DAG: %[[VAL_1:.*]] = arith.constant 4 : index
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 2 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 2 : index
Show All 21 Lines

mlir/test/Dialect/SparseTensor/sparse_fp_ops.mlir

// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait1 = { #trait1 = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "x(i) = OP a(i)" doc = "x(i) = OP a(i)"
▲ Show 20 Lines • Show All 334 Lines • ▼ Show 20 Lines outs(%argx: tensor<32xf64>) {
^bb(%a: f64, %x: f64): ^bb(%a: f64, %x: f64):
%0 = arith.divf %a, %c : f64 %0 = arith.divf %a, %c : f64
linalg.yield %0 : f64 linalg.yield %0 : f64
} -> tensor<32xf64> } -> tensor<32xf64>
return %0 : tensor<32xf64> return %0 : tensor<32xf64>
} }
// CHECK-LABEL: func.func @zero_preserving_math( // CHECK-LABEL: func.func @zero_preserving_math(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> { // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> {
// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : index
// CHECK: %[[VAL_3:.*]] = bufferization.alloc_tensor() : tensor<32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> // CHECK: %[[VAL_3:.*]] = bufferization.alloc_tensor() : tensor<32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>
// CHECK: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_5:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_5:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf64> // CHECK: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf64>
// CHECK: %[[VAL_7:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_1]]] : memref<?xindex> // CHECK: %[[VAL_7:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_1]]] : memref<?xindex>
// CHECK: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK: %[[T:.*]] = scf.for %[[VAL_9:.*]] = %[[VAL_7]] to %[[VAL_8]] step %[[VAL_2]] {{.*}} { // CHECK: %[[T:.*]] = scf.for %[[VAL_9:.*]] = %[[VAL_7]] to %[[VAL_8]] step %[[VAL_2]] {{.*}} {
// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_9]]] : memref<?xindex> // CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_9]]] : memref<?xindex>
// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_9]]] : memref<?xf64> // CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_9]]] : memref<?xf64>
// CHECK: %[[VAL_12:.*]] = math.absf %[[VAL_11]] : f64 // CHECK: %[[VAL_12:.*]] = math.absf %[[VAL_11]] : f64
// CHECK: %[[VAL_13:.*]] = math.ceil %[[VAL_12]] : f64 // CHECK: %[[VAL_13:.*]] = math.ceil %[[VAL_12]] : f64
// CHECK: %[[VAL_14:.*]] = math.floor %[[VAL_13]] : f64 // CHECK: %[[VAL_14:.*]] = math.floor %[[VAL_13]] : f64
// CHECK: %[[VAL_15:.*]] = math.sqrt %[[VAL_14]] : f64 // CHECK: %[[VAL_15:.*]] = math.sqrt %[[VAL_14]] : f64
// CHECK: %[[VAL_16:.*]] = math.expm1 %[[VAL_15]] : f64 // CHECK: %[[VAL_16:.*]] = math.expm1 %[[VAL_15]] : f64
// CHECK: %[[VAL_17:.*]] = math.log1p %[[VAL_16]] : f64 // CHECK: %[[VAL_17:.*]] = math.log1p %[[VAL_16]] : f64
// CHECK: %[[VAL_18:.*]] = math.sin %[[VAL_17]] : f64 // CHECK: %[[VAL_18:.*]] = math.sin %[[VAL_17]] : f64
// CHECK: %[[VAL_19:.*]] = math.tanh %[[VAL_18]] : f64 // CHECK: %[[VAL_19:.*]] = math.tanh %[[VAL_18]] : f64
// CHECK: %[[Y:.*]] = sparse_tensor.insert %[[VAL_19]] into %{{.*}}[%[[VAL_10]]] : tensor<32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> // CHECK: %[[Y:.*]] = sparse_tensor.insert %[[VAL_19]] into %{{.*}}[%[[VAL_10]]] : tensor<32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>
// CHECK: scf.yield %[[Y]] // CHECK: scf.yield %[[Y]]
// CHECK: } // CHECK: }
// CHECK: %[[VAL_20:.*]] = sparse_tensor.load %[[T]] hasInserts : tensor<32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> // CHECK: %[[VAL_20:.*]] = sparse_tensor.load %[[T]] hasInserts : tensor<32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>
// CHECK: return %[[VAL_20]] : tensor<32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> // CHECK: return %[[VAL_20]] : tensor<32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>
// CHECK: } // CHECK: }
func.func @zero_preserving_math(%arga: tensor<32xf64, #SV>) -> tensor<32xf64, #SV> { func.func @zero_preserving_math(%arga: tensor<32xf64, #SV>) -> tensor<32xf64, #SV> {
%c32 = arith.constant 32 : index %c32 = arith.constant 32 : index
%xinp = bufferization.alloc_tensor() : tensor<32xf64, #SV> %xinp = bufferization.alloc_tensor() : tensor<32xf64, #SV>
%0 = linalg.generic #trait1 %0 = linalg.generic #trait1
ins(%arga: tensor<32xf64, #SV>) ins(%arga: tensor<32xf64, #SV>)
outs(%xinp: tensor<32xf64, #SV>) { outs(%xinp: tensor<32xf64, #SV>) {
^bb(%a: f64, %x: f64): ^bb(%a: f64, %x: f64):
%0 = math.absf %a : f64 %0 = math.absf %a : f64
%1 = math.ceil %0 : f64 %1 = math.ceil %0 : f64
%2 = math.floor %1 : f64 %2 = math.floor %1 : f64
%3 = math.sqrt %2 : f64 %3 = math.sqrt %2 : f64
%4 = math.expm1 %3 : f64 %4 = math.expm1 %3 : f64
%5 = math.log1p %4 : f64 %5 = math.log1p %4 : f64
%6 = math.sin %5 : f64 %6 = math.sin %5 : f64
%7 = math.tanh %6 : f64 %7 = math.tanh %6 : f64
linalg.yield %7 : f64 linalg.yield %7 : f64
} -> tensor<32xf64, #SV> } -> tensor<32xf64, #SV>
return %0 : tensor<32xf64, #SV> return %0 : tensor<32xf64, #SV>
} }
// CHECK-LABEL: func.func @complex_divbyc( // CHECK-LABEL: func.func @complex_divbyc(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> { // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> {
// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : index
// CHECK: %[[VAL_3:.*]] = complex.constant [0.000000e+00, 1.000000e+00] : complex<f64> // CHECK: %[[VAL_3:.*]] = complex.constant [0.000000e+00, 1.000000e+00] : complex<f64>
// CHECK: %[[VAL_4:.*]] = bufferization.alloc_tensor() : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> // CHECK: %[[VAL_4:.*]] = bufferization.alloc_tensor() : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>
// CHECK: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xcomplex<f64>> // CHECK: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xcomplex<f64>>
// CHECK: %[[VAL_8:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_1]]] : memref<?xindex> // CHECK: %[[VAL_8:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_1]]] : memref<?xindex>
// CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK: %[[T:.*]] = scf.for %[[VAL_10:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_2]] {{.*}} { // CHECK: %[[T:.*]] = scf.for %[[VAL_10:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_2]] {{.*}} {
// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<?xindex> // CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<?xindex>
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_10]]] : memref<?xcomplex<f64>> // CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_10]]] : memref<?xcomplex<f64>>
// CHECK: %[[VAL_13:.*]] = complex.div %[[VAL_12]], %[[VAL_3]] : complex<f64> // CHECK: %[[VAL_13:.*]] = complex.div %[[VAL_12]], %[[VAL_3]] : complex<f64>
// CHECK: %[[Y:.*]] = sparse_tensor.insert %[[VAL_13]] into %{{.*}}[%[[VAL_11]]] : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> // CHECK: %[[Y:.*]] = sparse_tensor.insert %[[VAL_13]] into %{{.*}}[%[[VAL_11]]] : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>
// CHECK: scf.yield %[[Y]] // CHECK: scf.yield %[[Y]]
// CHECK: } // CHECK: }
// CHECK: %[[VAL_14:.*]] = sparse_tensor.load %[[T]] hasInserts : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> // CHECK: %[[VAL_14:.*]] = sparse_tensor.load %[[T]] hasInserts : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>
// CHECK: return %[[VAL_14]] : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> // CHECK: return %[[VAL_14]] : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>
// CHECK: } // CHECK: }
func.func @complex_divbyc(%arg0: tensor<32xcomplex<f64>, #SV>) -> tensor<32xcomplex<f64>, #SV> { func.func @complex_divbyc(%arg0: tensor<32xcomplex<f64>, #SV>) -> tensor<32xcomplex<f64>, #SV> {
%c = complex.constant [0.0, 1.0] : complex<f64> %c = complex.constant [0.0, 1.0] : complex<f64>
%init = bufferization.alloc_tensor() : tensor<32xcomplex<f64>, #SV> %init = bufferization.alloc_tensor() : tensor<32xcomplex<f64>, #SV>
%0 = linalg.generic #traitc %0 = linalg.generic #traitc
ins(%arg0: tensor<32xcomplex<f64>, #SV>) ins(%arg0: tensor<32xcomplex<f64>, #SV>)
outs(%init: tensor<32xcomplex<f64>, #SV>) { outs(%init: tensor<32xcomplex<f64>, #SV>) {
^bb(%a: complex<f64>, %x: complex<f64>): ^bb(%a: complex<f64>, %x: complex<f64>):
%0 = complex.div %a, %c : complex<f64> %0 = complex.div %a, %c : complex<f64>
linalg.yield %0 : complex<f64> linalg.yield %0 : complex<f64>
} -> tensor<32xcomplex<f64>, #SV> } -> tensor<32xcomplex<f64>, #SV>
return %0 : tensor<32xcomplex<f64>, #SV> return %0 : tensor<32xcomplex<f64>, #SV>
} }

mlir/test/Dialect/SparseTensor/sparse_index.mlir

// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#DenseMatrix = #sparse_tensor.encoding<{ #DenseMatrix = #sparse_tensor.encoding<{
dimLevelType = ["dense", "dense"] lvlTypes = ["dense", "dense"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = ["compressed", "compressed"] lvlTypes = ["compressed", "compressed"]
}> }>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_int_ops.mlir

// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait2 = { #trait2 = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)>, // b affine_map<(i) -> (i)>, // b
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
▲ Show 20 Lines • Show All 497 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_kernels.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --linalg-generalize-named-ops --linalg-fuse-elementwise-ops \ // RUN: --linalg-generalize-named-ops --linalg-fuse-elementwise-ops \
// RUN: --sparsification | FileCheck %s // RUN: --sparsification | FileCheck %s
#SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
// CHECK-LABEL: func.func @matmul1( // CHECK-LABEL: func.func @matmul1(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<20x30xf32>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<20x30xf32>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<10x30xf32>) -> tensor<10x30xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<10x30xf32>) -> tensor<10x30xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 30 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 30 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<20x30xf32> // CHECK: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<20x30xf32>
// CHECK: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<10x30xf32> // CHECK: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<10x30xf32>
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_5]] {
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_15]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_15]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]] = arith.addi %[[VAL_15]], %[[VAL_5]] : index // CHECK: %[[VAL_18:.*]] = arith.addi %[[VAL_15]], %[[VAL_5]] : index
Show All 19 Linesfunc.func @matmul1(%a: tensor<10x20xf32, #DCSR>,
%0 = linalg.matmul %0 = linalg.matmul
ins(%a, %b: tensor<10x20xf32, #DCSR>, tensor<20x30xf32>) ins(%a, %b: tensor<10x20xf32, #DCSR>, tensor<20x30xf32>)
outs(%c: tensor<10x30xf32>) -> tensor<10x30xf32> outs(%c: tensor<10x30xf32>) -> tensor<10x30xf32>
return %0 : tensor<10x30xf32> return %0 : tensor<10x30xf32>
} }
// CHECK-LABEL: func.func @matmul_sparse_rhs( // CHECK-LABEL: func.func @matmul_sparse_rhs(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<10x20xf32>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<10x20xf32>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<20x30xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<20x30xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<10x30xf32>) -> tensor<10x30xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<10x30xf32>) -> tensor<10x30xf32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 10 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 10 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<10x20xf32> // CHECK-DAG: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<10x20xf32>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index}
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index}
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index}
Show All 32 Linesfunc.func @matmul_sparse_rhs(%a: tensor<10x20xf32>,
return %0 : tensor<10x30xf32> return %0 : tensor<10x30xf32>
} }
// //
// Computes C = A x B with all matrices sparse (SpMSpM) in DCSR. // Computes C = A x B with all matrices sparse (SpMSpM) in DCSR.
// //
// CHECK-LABEL: func.func @matmul2( // CHECK-LABEL: func.func @matmul2(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<4x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<4x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<8x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) -> tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> { // CHECK-SAME: %[[VAL_1:.*]]: tensor<8x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) -> tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> {
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant false // CHECK-DAG: %[[VAL_4:.*]] = arith.constant false
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant true // CHECK-DAG: %[[VAL_5:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_6:.*]] = bufferization.alloc_tensor() : tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK-DAG: %[[VAL_6:.*]] = bufferization.alloc_tensor() : tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<4x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<4x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<4x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<4x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<4x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<4x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<4x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<4x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<4x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf64> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<4x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf64>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<8x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<8x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<8x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<8x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<8x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<8x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<8x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<8x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_16:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<8x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf64> // CHECK-DAG: %[[VAL_16:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<8x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf64>
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_19:.*]] = scf.for %[[VAL_20:.*]] = %[[VAL_17]] to %[[VAL_18]] step %[[VAL_3]] iter_args(%[[VAL_21:.*]] = %[[VAL_6]]) -> (tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_19:.*]] = scf.for %[[VAL_20:.*]] = %[[VAL_17]] to %[[VAL_18]] step %[[VAL_3]] iter_args(%[[VAL_21:.*]] = %[[VAL_6]]) -> (tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_20]]] : memref<?xindex> // CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_20]]] : memref<?xindex>
// CHECK: %[[VAL_23:.*]], %[[VAL_24:.*]], %[[VAL_25:.*]], %[[VAL_26:.*]] = sparse_tensor.expand %[[VAL_6]] : tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf64>, memref<?xi1>, memref<?xindex> // CHECK: %[[VAL_23:.*]], %[[VAL_24:.*]], %[[VAL_25:.*]], %[[VAL_26:.*]] = sparse_tensor.expand %[[VAL_6]] : tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf64>, memref<?xi1>, memref<?xindex>
// CHECK: %[[VAL_27:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_20]]] : memref<?xindex> // CHECK: %[[VAL_27:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_20]]] : memref<?xindex>
// CHECK: %[[VAL_28:.*]] = arith.addi %[[VAL_20]], %[[VAL_3]] : index // CHECK: %[[VAL_28:.*]] = arith.addi %[[VAL_20]], %[[VAL_3]] : index
// CHECK: %[[VAL_29:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_28]]] : memref<?xindex> // CHECK: %[[VAL_29:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_28]]] : memref<?xindex>
// CHECK: %[[VAL_30:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK: %[[VAL_30:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK: %[[VAL_31:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK: %[[VAL_31:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_32:.*]]:4 = scf.while (%[[VAL_33:.*]] = %[[VAL_27]], %[[VAL_34:.*]] = %[[VAL_30]], %[[VAL_35:.*]] = %[[VAL_26]], %[[VAL_36:.*]] = %[[VAL_21]]) : (index, index, index, tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) -> (index, index, index, tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_32:.*]]:4 = scf.while (%[[VAL_33:.*]] = %[[VAL_27]], %[[VAL_34:.*]] = %[[VAL_30]], %[[VAL_35:.*]] = %[[VAL_26]], %[[VAL_36:.*]] = %[[VAL_21]]) : (index, index, index, tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) -> (index, index, index, tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_37:.*]] = arith.cmpi ult, %[[VAL_33]], %[[VAL_29]] : index // CHECK: %[[VAL_37:.*]] = arith.cmpi ult, %[[VAL_33]], %[[VAL_29]] : index
// CHECK: %[[VAL_38:.*]] = arith.cmpi ult, %[[VAL_34]], %[[VAL_31]] : index // CHECK: %[[VAL_38:.*]] = arith.cmpi ult, %[[VAL_34]], %[[VAL_31]] : index
// CHECK: %[[VAL_39:.*]] = arith.andi %[[VAL_37]], %[[VAL_38]] : i1 // CHECK: %[[VAL_39:.*]] = arith.andi %[[VAL_37]], %[[VAL_38]] : i1
// CHECK: scf.condition(%[[VAL_39]]) %[[VAL_33]], %[[VAL_34]], %[[VAL_35]], %[[VAL_36]] : index, index, index, tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.condition(%[[VAL_39]]) %[[VAL_33]], %[[VAL_34]], %[[VAL_35]], %[[VAL_36]] : index, index, index, tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } do { // CHECK: } do {
// CHECK: ^bb0(%[[VAL_40:.*]]: index, %[[VAL_41:.*]]: index, %[[VAL_42:.*]]: index, %[[VAL_43:.*]]: tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>): // CHECK: ^bb0(%[[VAL_40:.*]]: index, %[[VAL_41:.*]]: index, %[[VAL_42:.*]]: index, %[[VAL_43:.*]]: tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>):
// CHECK: %[[VAL_44:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_40]]] : memref<?xindex> // CHECK: %[[VAL_44:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_40]]] : memref<?xindex>
// CHECK: %[[VAL_45:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_41]]] : memref<?xindex> // CHECK: %[[VAL_45:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_41]]] : memref<?xindex>
// CHECK: %[[VAL_46:.*]] = arith.cmpi ult, %[[VAL_45]], %[[VAL_44]] : index // CHECK: %[[VAL_46:.*]] = arith.cmpi ult, %[[VAL_45]], %[[VAL_44]] : index
// CHECK: %[[VAL_47:.*]] = arith.select %[[VAL_46]], %[[VAL_45]], %[[VAL_44]] : index // CHECK: %[[VAL_47:.*]] = arith.select %[[VAL_46]], %[[VAL_45]], %[[VAL_44]] : index
// CHECK: %[[VAL_48:.*]] = arith.cmpi eq, %[[VAL_44]], %[[VAL_47]] : index // CHECK: %[[VAL_48:.*]] = arith.cmpi eq, %[[VAL_44]], %[[VAL_47]] : index
// CHECK: %[[VAL_49:.*]] = arith.cmpi eq, %[[VAL_45]], %[[VAL_47]] : index // CHECK: %[[VAL_49:.*]] = arith.cmpi eq, %[[VAL_45]], %[[VAL_47]] : index
// CHECK: %[[VAL_50:.*]] = arith.andi %[[VAL_48]], %[[VAL_49]] : i1 // CHECK: %[[VAL_50:.*]] = arith.andi %[[VAL_48]], %[[VAL_49]] : i1
// CHECK: %[[VAL_51:.*]]:2 = scf.if %[[VAL_50]] -> (index, tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_51:.*]]:2 = scf.if %[[VAL_50]] -> (index, tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_40]]] : memref<?xf64> // CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_40]]] : memref<?xf64>
// CHECK: %[[VAL_53:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_41]]] : memref<?xindex> // CHECK: %[[VAL_53:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_41]]] : memref<?xindex>
// CHECK: %[[VAL_54:.*]] = arith.addi %[[VAL_41]], %[[VAL_3]] : index // CHECK: %[[VAL_54:.*]] = arith.addi %[[VAL_41]], %[[VAL_3]] : index
// CHECK: %[[VAL_55:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_54]]] : memref<?xindex> // CHECK: %[[VAL_55:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_54]]] : memref<?xindex>
// CHECK: %[[VAL_56:.*]] = scf.for %[[VAL_57:.*]] = %[[VAL_53]] to %[[VAL_55]] step %[[VAL_3]] iter_args(%[[VAL_58:.*]] = %[[VAL_42]]) -> (index) { // CHECK: %[[VAL_56:.*]] = scf.for %[[VAL_57:.*]] = %[[VAL_53]] to %[[VAL_55]] step %[[VAL_3]] iter_args(%[[VAL_58:.*]] = %[[VAL_42]]) -> (index) {
// CHECK: %[[VAL_59:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_57]]] : memref<?xindex> // CHECK: %[[VAL_59:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_57]]] : memref<?xindex>
// CHECK: %[[VAL_60:.*]] = memref.load %[[VAL_23]]{{\[}}%[[VAL_59]]] : memref<?xf64> // CHECK: %[[VAL_60:.*]] = memref.load %[[VAL_23]]{{\[}}%[[VAL_59]]] : memref<?xf64>
// CHECK: %[[VAL_61:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_57]]] : memref<?xf64> // CHECK: %[[VAL_61:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_57]]] : memref<?xf64>
// CHECK: %[[VAL_62:.*]] = arith.mulf %[[VAL_52]], %[[VAL_61]] : f64 // CHECK: %[[VAL_62:.*]] = arith.mulf %[[VAL_52]], %[[VAL_61]] : f64
// CHECK: %[[VAL_63:.*]] = arith.addf %[[VAL_60]], %[[VAL_62]] : f64 // CHECK: %[[VAL_63:.*]] = arith.addf %[[VAL_60]], %[[VAL_62]] : f64
// CHECK: %[[VAL_64:.*]] = memref.load %[[VAL_24]]{{\[}}%[[VAL_59]]] : memref<?xi1> // CHECK: %[[VAL_64:.*]] = memref.load %[[VAL_24]]{{\[}}%[[VAL_59]]] : memref<?xi1>
// CHECK: %[[VAL_65:.*]] = arith.cmpi eq, %[[VAL_64]], %[[VAL_4]] : i1 // CHECK: %[[VAL_65:.*]] = arith.cmpi eq, %[[VAL_64]], %[[VAL_4]] : i1
// CHECK: %[[VAL_66:.*]] = scf.if %[[VAL_65]] -> (index) { // CHECK: %[[VAL_66:.*]] = scf.if %[[VAL_65]] -> (index) {
// CHECK: memref.store %[[VAL_5]], %[[VAL_24]]{{\[}}%[[VAL_59]]] : memref<?xi1> // CHECK: memref.store %[[VAL_5]], %[[VAL_24]]{{\[}}%[[VAL_59]]] : memref<?xi1>
// CHECK: memref.store %[[VAL_59]], %[[VAL_25]]{{\[}}%[[VAL_58]]] : memref<?xindex> // CHECK: memref.store %[[VAL_59]], %[[VAL_25]]{{\[}}%[[VAL_58]]] : memref<?xindex>
// CHECK: %[[VAL_67:.*]] = arith.addi %[[VAL_58]], %[[VAL_3]] : index // CHECK: %[[VAL_67:.*]] = arith.addi %[[VAL_58]], %[[VAL_3]] : index
// CHECK: scf.yield %[[VAL_67]] : index // CHECK: scf.yield %[[VAL_67]] : index
// CHECK: } else { // CHECK: } else {
// CHECK: scf.yield %[[VAL_58]] : index // CHECK: scf.yield %[[VAL_58]] : index
// CHECK: } // CHECK: }
// CHECK: memref.store %[[VAL_63]], %[[VAL_23]]{{\[}}%[[VAL_59]]] : memref<?xf64> // CHECK: memref.store %[[VAL_63]], %[[VAL_23]]{{\[}}%[[VAL_59]]] : memref<?xf64>
// CHECK: scf.yield %[[VAL_68:.*]] : index // CHECK: scf.yield %[[VAL_68:.*]] : index
// CHECK: } // CHECK: }
// CHECK: scf.yield %[[VAL_69:.*]], %[[VAL_43]] : index, tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_69:.*]], %[[VAL_43]] : index, tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } else { // CHECK: } else {
// CHECK: scf.yield %[[VAL_42]], %[[VAL_43]] : index, tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_42]], %[[VAL_43]] : index, tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_70:.*]] = arith.cmpi eq, %[[VAL_44]], %[[VAL_47]] : index // CHECK: %[[VAL_70:.*]] = arith.cmpi eq, %[[VAL_44]], %[[VAL_47]] : index
// CHECK: %[[VAL_71:.*]] = arith.addi %[[VAL_40]], %[[VAL_3]] : index // CHECK: %[[VAL_71:.*]] = arith.addi %[[VAL_40]], %[[VAL_3]] : index
// CHECK: %[[VAL_72:.*]] = arith.select %[[VAL_70]], %[[VAL_71]], %[[VAL_40]] : index // CHECK: %[[VAL_72:.*]] = arith.select %[[VAL_70]], %[[VAL_71]], %[[VAL_40]] : index
// CHECK: %[[VAL_73:.*]] = arith.cmpi eq, %[[VAL_45]], %[[VAL_47]] : index // CHECK: %[[VAL_73:.*]] = arith.cmpi eq, %[[VAL_45]], %[[VAL_47]] : index
// CHECK: %[[VAL_74:.*]] = arith.addi %[[VAL_41]], %[[VAL_3]] : index // CHECK: %[[VAL_74:.*]] = arith.addi %[[VAL_41]], %[[VAL_3]] : index
// CHECK: %[[VAL_75:.*]] = arith.select %[[VAL_73]], %[[VAL_74]], %[[VAL_41]] : index // CHECK: %[[VAL_75:.*]] = arith.select %[[VAL_73]], %[[VAL_74]], %[[VAL_41]] : index
// CHECK: scf.yield %[[VAL_72]], %[[VAL_75]], %[[VAL_76:.*]]#0, %[[VAL_76]]#1 : index, index, index, tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_72]], %[[VAL_75]], %[[VAL_76:.*]]#0, %[[VAL_76]]#1 : index, index, index, tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_77:.*]] = sparse_tensor.compress %[[VAL_23]], %[[VAL_24]], %[[VAL_25]], %[[VAL_78:.*]]#2 into %[[VAL_78]]#3{{\[}}%[[VAL_22]]] : memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_77:.*]] = sparse_tensor.compress %[[VAL_23]], %[[VAL_24]], %[[VAL_25]], %[[VAL_78:.*]]#2 into %[[VAL_78]]#3{{\[}}%[[VAL_22]]] : memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: scf.yield %[[VAL_77]] : tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_77]] : tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_79:.*]] = sparse_tensor.load %[[VAL_80:.*]] hasInserts : tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_79:.*]] = sparse_tensor.load %[[VAL_80:.*]] hasInserts : tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: return %[[VAL_79]] : tensor<4x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: return %[[VAL_79]] : tensor<4x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
func.func @matmul2(%A: tensor<4x8xf64, #DCSR>, func.func @matmul2(%A: tensor<4x8xf64, #DCSR>,
%B: tensor<8x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR> { %B: tensor<8x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR> {
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%C = bufferization.alloc_tensor() : tensor<4x4xf64, #DCSR> %C = bufferization.alloc_tensor() : tensor<4x4xf64, #DCSR>
%D = linalg.matmul %D = linalg.matmul
ins(%A, %B: tensor<4x8xf64, #DCSR>, tensor<8x4xf64, #DCSR>) ins(%A, %B: tensor<4x8xf64, #DCSR>, tensor<8x4xf64, #DCSR>)
outs(%C: tensor<4x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR> outs(%C: tensor<4x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR>
return %D: tensor<4x4xf64, #DCSR> return %D: tensor<4x4xf64, #DCSR>
} }
// CHECK-LABEL: func.func @conv2d( // CHECK-LABEL: func.func @conv2d(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<8x8xi32>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<8x8xi32>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<3x3xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<3x3xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<6x6xi32>) -> tensor<6x6xi32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<6x6xi32>) -> tensor<6x6xi32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 6 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 6 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<8x8xi32> // CHECK-DAG: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<8x8xi32>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<3x3xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<3x3xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<3x3xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<3x3xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<3x3xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<3x3xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<3x3xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<3x3xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<3x3xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xi32> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<3x3xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xi32>
// CHECK: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<6x6xi32> // CHECK: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<6x6xi32>
// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_5]] {
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_18:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_18:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_13]], %[[VAL_18]]] : memref<6x6xi32> // CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_13]], %[[VAL_18]]] : memref<6x6xi32>
Show All 23 Linesfunc.func @conv2d(%input: tensor<8x8xi32>,
%0 = linalg.conv_2d %0 = linalg.conv_2d
ins (%input, %filter: tensor<8x8xi32>, tensor<3x3xi32, #DCSR>) ins (%input, %filter: tensor<8x8xi32>, tensor<3x3xi32, #DCSR>)
outs (%output: tensor<6x6xi32>) -> tensor<6x6xi32> outs (%output: tensor<6x6xi32>) -> tensor<6x6xi32>
return %0 : tensor<6x6xi32> return %0 : tensor<6x6xi32>
} }
// CHECK-LABEL: func.func @quantized_matmul( // CHECK-LABEL: func.func @quantized_matmul(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<5x3xi8>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<5x3xi8>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<3x6xi8, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<3x6xi8, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<5x6xi64>) -> tensor<5x6xi64> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<5x6xi64>) -> tensor<5x6xi64> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 5 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 5 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 2 : i64 // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 2 : i64
// CHECK-DAG: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_0]] : memref<5x3xi8> // CHECK-DAG: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_0]] : memref<5x3xi8>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<3x6xi8, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<3x6xi8, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<3x6xi8, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<3x6xi8, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<3x6xi8, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<3x6xi8, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<3x6xi8, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<3x6xi8, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<3x6xi8, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xi8> // CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<3x6xi8, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xi8>
// CHECK: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<5x6xi64> // CHECK: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_2]] : memref<5x6xi64>
// CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_5]] { // CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_5]] {
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_17]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_17]]] : memref<?xindex>
// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_14]], %[[VAL_18]]] : memref<5x3xi8> // CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_14]], %[[VAL_18]]] : memref<5x3xi8>
// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_17]]] : memref<?xindex> // CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_17]]] : memref<?xindex>
Show All 22 Linesfunc.func @quantized_matmul(%input1: tensor<5x3xi8>,
%c2 = arith.constant 2 : i32 %c2 = arith.constant 2 : i32
%0 = linalg.quantized_matmul %0 = linalg.quantized_matmul
ins(%input1, %input2, %c2, %c0 : tensor<5x3xi8>, tensor<3x6xi8, #DCSR>, i32, i32) ins(%input1, %input2, %c2, %c0 : tensor<5x3xi8>, tensor<3x6xi8, #DCSR>, i32, i32)
outs(%output : tensor<5x6xi64>) -> tensor<5x6xi64> outs(%output : tensor<5x6xi64>) -> tensor<5x6xi64>
return %0: tensor<5x6xi64> return %0: tensor<5x6xi64>
} }
// CHECK-LABEL: func.func @sparse_dot( // CHECK-LABEL: func.func @sparse_dot(
// CHECK-SAME: %[[VAL_0:.*0]]: tensor<1024xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*0]]: tensor<1024xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*1]]: tensor<1024xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*1]]: tensor<1024xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*2]]: tensor<f32>) -> tensor<f32> { // CHECK-SAME: %[[VAL_2:.*2]]: tensor<f32>) -> tensor<f32> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<1024xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<1024xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<1024xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<1024xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<1024xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<1024xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<1024xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<1024xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<1024xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<1024xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<1024xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<1024xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<f32> // CHECK: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<f32>
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_11]][] : memref<f32> // CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_11]][] : memref<f32>
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]]:3 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]], %[[VAL_20:.*]] = %[[VAL_12]]) : (index, index, f32) -> (index, index, f32) { // CHECK: %[[VAL_17:.*]]:3 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]], %[[VAL_20:.*]] = %[[VAL_12]]) : (index, index, f32) -> (index, index, f32) {
// CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_18]], %[[VAL_14]] : index // CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_18]], %[[VAL_14]] : index
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_lower.mlir

// RUN: mlir-opt %s -sparsification | FileCheck %s --check-prefix=CHECK-HIR // RUN: mlir-opt %s -sparsification | FileCheck %s --check-prefix=CHECK-HIR
// //
// RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse | \ // RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse | \
// RUN: FileCheck %s --check-prefix=CHECK-MIR // RUN: FileCheck %s --check-prefix=CHECK-MIR
// //
// RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse \ // RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse \
// RUN: --func-bufferize --arith-bufferize \ // RUN: --func-bufferize --arith-bufferize \
// RUN: --tensor-bufferize --finalizing-bufferize | \ // RUN: --tensor-bufferize --finalizing-bufferize | \
// RUN: FileCheck %s --check-prefix=CHECK-LIR // RUN: FileCheck %s --check-prefix=CHECK-LIR
#CSR = #sparse_tensor.encoding<{dimLevelType = [ "dense", "compressed" ]}> #CSR = #sparse_tensor.encoding<{lvlTypes = [ "dense", "compressed" ]}>
#trait_matvec = { #trait_matvec = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (j)>, // b affine_map<(i,j) -> (j)>, // b
affine_map<(i,j) -> (i)> // x (out) affine_map<(i,j) -> (i)> // x (out)
], ],
iterator_types = ["parallel","reduction"], iterator_types = ["parallel","reduction"],
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_lower_col.mlir

// RUN: mlir-opt %s -sparsification | FileCheck %s --check-prefix=CHECK-HIR // RUN: mlir-opt %s -sparsification | FileCheck %s --check-prefix=CHECK-HIR
// //
// RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse | \ // RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse | \
// RUN: FileCheck %s --check-prefix=CHECK-MIR // RUN: FileCheck %s --check-prefix=CHECK-MIR
// //
// RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse \ // RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse \
// RUN: --func-bufferize --arith-bufferize \ // RUN: --func-bufferize --arith-bufferize \
// RUN: --tensor-bufferize --finalizing-bufferize | \ // RUN: --tensor-bufferize --finalizing-bufferize | \
// RUN: FileCheck %s --check-prefix=CHECK-LIR // RUN: FileCheck %s --check-prefix=CHECK-LIR
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#trait_matvec = { #trait_matvec = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (j)>, // b affine_map<(i,j) -> (j)>, // b
affine_map<(i,j) -> (i)> // x (out) affine_map<(i,j) -> (i)> // x (out)
], ],
iterator_types = ["parallel","reduction"], iterator_types = ["parallel","reduction"],
doc = "x(i) += A(i,j) * b(j)" doc = "x(i) += A(i,j) * b(j)"
} }
// CHECK-HIR-LABEL: func @matvec( // CHECK-HIR-LABEL: func @matvec(
// CHECK-HIR-SAME: %[[VAL_0:.*]]: tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>, // CHECK-HIR-SAME: %[[VAL_0:.*]]: tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>,
// CHECK-HIR-SAME: %[[VAL_1:.*]]: tensor<64xf64>, // CHECK-HIR-SAME: %[[VAL_1:.*]]: tensor<64xf64>,
// CHECK-HIR-SAME: %[[VAL_2:.*]]: tensor<32xf64>) -> tensor<32xf64> { // CHECK-HIR-SAME: %[[VAL_2:.*]]: tensor<32xf64>) -> tensor<32xf64> {
// CHECK-HIR-DAG: %[[VAL_3:.*]] = arith.constant 64 : index // CHECK-HIR-DAG: %[[VAL_3:.*]] = arith.constant 64 : index
// CHECK-HIR-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-HIR-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-HIR-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-HIR-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-HIR-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex> // CHECK-HIR-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
// CHECK-HIR-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex> // CHECK-HIR-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
// CHECK-HIR-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x64xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xf64> // CHECK-HIR-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xf64>
// CHECK-HIR-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<64xf64> // CHECK-HIR-DAG: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<64xf64>
// CHECK-HIR-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32xf64> // CHECK-HIR-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32xf64>
// CHECK-HIR: scf.for %[[VAL_12:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { // CHECK-HIR: scf.for %[[VAL_12:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
// CHECK-HIR-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_12]]] : memref<64xf64> // CHECK-HIR-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_12]]] : memref<64xf64>
// CHECK-HIR-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex> // CHECK-HIR-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex>
// CHECK-HIR-DAG: %[[VAL_15:.*]] = arith.addi %[[VAL_12]], %[[VAL_5]] : index // CHECK-HIR-DAG: %[[VAL_15:.*]] = arith.addi %[[VAL_12]], %[[VAL_5]] : index
// CHECK-HIR-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_15]]] : memref<?xindex> // CHECK-HIR-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_15]]] : memref<?xindex>
// CHECK-HIR: scf.for %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_16]] step %[[VAL_5]] { // CHECK-HIR: scf.for %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_16]] step %[[VAL_5]] {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_lower_inplace.mlir

// RUN: mlir-opt %s -sparsification | FileCheck %s --check-prefix=CHECK-HIR // RUN: mlir-opt %s -sparsification | FileCheck %s --check-prefix=CHECK-HIR
// //
// RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse | \ // RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse | \
// RUN: FileCheck %s --check-prefix=CHECK-MIR // RUN: FileCheck %s --check-prefix=CHECK-MIR
// //
// RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse \ // RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse \
// RUN: --func-bufferize --arith-bufferize \ // RUN: --func-bufferize --arith-bufferize \
// RUN: --tensor-bufferize --finalizing-bufferize | \ // RUN: --tensor-bufferize --finalizing-bufferize | \
// RUN: FileCheck %s --check-prefix=CHECK-LIR // RUN: FileCheck %s --check-prefix=CHECK-LIR
#CSR = #sparse_tensor.encoding<{dimLevelType = [ "dense", "compressed" ]}> #CSR = #sparse_tensor.encoding<{lvlTypes = [ "dense", "compressed" ]}>
#trait_matvec = { #trait_matvec = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (j)>, // b affine_map<(i,j) -> (j)>, // b
affine_map<(i,j) -> (i)> // x (out) affine_map<(i,j) -> (i)> // x (out)
], ],
iterator_types = ["parallel","reduction"], iterator_types = ["parallel","reduction"],
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_matmul_codegen.mlir

// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
// RUN: mlir-opt %s --linalg-generalize-named-ops \ // RUN: mlir-opt %s --linalg-generalize-named-ops \
// RUN: --sparsification --sparse-tensor-codegen \ // RUN: --sparsification --sparse-tensor-codegen \
// RUN: --canonicalize --cse | FileCheck %s // RUN: --canonicalize --cse | FileCheck %s
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (i,j)> dimOrdering = affine_map<(i,j) -> (i,j)>
}> }>
// //
// Computes C = A x B with all matrices sparse (SpMSpM) in CSR. // Computes C = A x B with all matrices sparse (SpMSpM) in CSR.
// //
// CHECK-LABEL: func.func private @_insert_dense_compressed_4_4_f64_0_0( // CHECK-LABEL: func.func private @_insert_dense_compressed_4_4_f64_0_0(
// CHECK-SAME: %[[VAL_0:.*0]]: memref<?xindex>, // CHECK-SAME: %[[VAL_0:.*0]]: memref<?xindex>,
▲ Show 20 Lines • Show All 137 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_nd.mlir

// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
// Example with cyclic iteration graph with sparse and dense constraints, // Example with cyclic iteration graph with sparse and dense constraints,
// but an acyclic iteration graph using sparse constraints only. // but an acyclic iteration graph using sparse constraints only.
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense", "dense", "compressed", lvlTypes = [ "dense", "dense", "dense", "compressed",
"compressed", "dense", "dense", "dense" ] "compressed", "dense", "dense", "dense" ]
}> }>
#trait_mul = { #trait_mul = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j,k,l,m,n,o,p) -> (i,j,k,l,m,n,o,p)>, // A affine_map<(i,j,k,l,m,n,o,p) -> (i,j,k,l,m,n,o,p)>, // A
affine_map<(i,j,k,l,m,n,o,p) -> (p,o,n,m,l,k,j,i)>, // B affine_map<(i,j,k,l,m,n,o,p) -> (p,o,n,m,l,k,j,i)>, // B
affine_map<(i,j,k,l,m,n,o,p) -> (i,j,k,l,m,n,o,p)> // X affine_map<(i,j,k,l,m,n,o,p) -> (i,j,k,l,m,n,o,p)> // X
], ],
iterator_types = ["parallel", "parallel", "parallel", "parallel", iterator_types = ["parallel", "parallel", "parallel", "parallel",
"parallel", "parallel", "parallel", "parallel"], "parallel", "parallel", "parallel", "parallel"],
doc = "X(i,j,k,l,m,n,o,p) = A(i,j,k,l,m,n,o,p) * B(p,o,n,m,l,k,j,i)" doc = "X(i,j,k,l,m,n,o,p) = A(i,j,k,l,m,n,o,p) * B(p,o,n,m,l,k,j,i)"
} }
// CHECK-LABEL: func @mul( // CHECK-LABEL: func @mul(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<10x20x30x40x50x60x70x80xf32>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<10x20x30x40x50x60x70x80xf32>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<80x70x60x50x40x30x20x10xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense", "compressed", "compressed", "dense", "dense", "dense" ] }>>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<80x70x60x50x40x30x20x10xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "dense", "compressed", "compressed", "dense", "dense", "dense" ] }>>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<10x20x30x40x50x60x70x80xf32>) -> tensor<10x20x30x40x50x60x70x80xf32> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<10x20x30x40x50x60x70x80xf32>) -> tensor<10x20x30x40x50x60x70x80xf32> {
// CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-DAG: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 10 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 10 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 20 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 20 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 30 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 30 : index
// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 60 : index // CHECK-DAG: %[[VAL_8:.*]] = arith.constant 60 : index
// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 70 : index // CHECK-DAG: %[[VAL_9:.*]] = arith.constant 70 : index
// CHECK-DAG: %[[VAL_10:.*]] = arith.constant 80 : index // CHECK-DAG: %[[VAL_10:.*]] = arith.constant 80 : index
// CHECK-DAG: %[[VAL_11:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_11:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_12:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_12:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_0]] : memref<10x20x30x40x50x60x70x80xf32> // CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_memref %[[VAL_0]] : memref<10x20x30x40x50x60x70x80xf32>
// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 3 : index} : tensor<80x70x60x50x40x30x20x10xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense", "compressed", "compressed", "dense", "dense", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 3 : index} : tensor<80x70x60x50x40x30x20x10xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "dense", "compressed", "compressed", "dense", "dense", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 3 : index} : tensor<80x70x60x50x40x30x20x10xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense", "compressed", "compressed", "dense", "dense", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 3 : index} : tensor<80x70x60x50x40x30x20x10xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "dense", "compressed", "compressed", "dense", "dense", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_16:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 4 : index} : tensor<80x70x60x50x40x30x20x10xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense", "compressed", "compressed", "dense", "dense", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_16:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 4 : index} : tensor<80x70x60x50x40x30x20x10xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "dense", "compressed", "compressed", "dense", "dense", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_17:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 4 : index} : tensor<80x70x60x50x40x30x20x10xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense", "compressed", "compressed", "dense", "dense", "dense" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_17:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 4 : index} : tensor<80x70x60x50x40x30x20x10xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "dense", "compressed", "compressed", "dense", "dense", "dense" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_18:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<80x70x60x50x40x30x20x10xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense", "compressed", "compressed", "dense", "dense", "dense" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_18:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<80x70x60x50x40x30x20x10xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "dense", "compressed", "compressed", "dense", "dense", "dense" ] }>> to memref<?xf32>
// CHECK-DAG: %[[VAL_20:.*]] = bufferization.to_memref %[[VAL_2]] : memref<10x20x30x40x50x60x70x80xf32> // CHECK-DAG: %[[VAL_20:.*]] = bufferization.to_memref %[[VAL_2]] : memref<10x20x30x40x50x60x70x80xf32>
// CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_20]] : memref<10x20x30x40x50x60x70x80xf32> // CHECK: linalg.fill ins(%[[ZERO]] : f32) outs(%[[VAL_20]] : memref<10x20x30x40x50x60x70x80xf32>
// CHECK: scf.for %[[VAL_21:.*]] = %[[VAL_11]] to %[[VAL_10]] step %[[VAL_12]] { // CHECK: scf.for %[[VAL_21:.*]] = %[[VAL_11]] to %[[VAL_10]] step %[[VAL_12]] {
// CHECK: scf.for %[[VAL_22:.*]] = %[[VAL_11]] to %[[VAL_9]] step %[[VAL_12]] { // CHECK: scf.for %[[VAL_22:.*]] = %[[VAL_11]] to %[[VAL_9]] step %[[VAL_12]] {
// CHECK: %[[VAL_23:.*]] = arith.muli %[[VAL_21]], %[[VAL_9]] : index // CHECK: %[[VAL_23:.*]] = arith.muli %[[VAL_21]], %[[VAL_9]] : index
// CHECK: %[[VAL_24:.*]] = arith.addi %[[VAL_23]], %[[VAL_22]] : index // CHECK: %[[VAL_24:.*]] = arith.addi %[[VAL_23]], %[[VAL_22]] : index
// CHECK: scf.for %[[VAL_25:.*]] = %[[VAL_11]] to %[[VAL_8]] step %[[VAL_12]] { // CHECK: scf.for %[[VAL_25:.*]] = %[[VAL_11]] to %[[VAL_8]] step %[[VAL_12]] {
// CHECK: %[[VAL_26:.*]] = arith.muli %[[VAL_24]], %[[VAL_8]] : index // CHECK: %[[VAL_26:.*]] = arith.muli %[[VAL_24]], %[[VAL_8]] : index
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_out.mlir

// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (i,j)> dimOrdering = affine_map<(i,j) -> (i,j)>
}> }>
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (i,j)> dimOrdering = affine_map<(i,j) -> (i,j)>
}> }>
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed", "compressed" ]
}> }>
#trait_scale_inpl = { #trait_scale_inpl = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
doc = "X(i,j) *= 2 or X(i,j) += X(i,j)" doc = "X(i,j) *= 2 or X(i,j) += X(i,j)"
} }
// CHECK-LABEL: func.func @sparse_simply_dynamic1( // CHECK-LABEL: func.func @sparse_simply_dynamic1(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) -> tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> { // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) -> tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> {
// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 2.000000e+00 : f32 // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 2.000000e+00 : f32
// CHECK-DAG: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK: %[[VAL_7:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_1]]] : memref<?xindex> // CHECK: %[[VAL_7:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_1]]] : memref<?xindex>
// CHECK: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_9:.*]] = %[[VAL_7]] to %[[VAL_8]] step %[[VAL_2]] { // CHECK: scf.for %[[VAL_9:.*]] = %[[VAL_7]] to %[[VAL_8]] step %[[VAL_2]] {
// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_9]]] : memref<?xindex> // CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_9]]] : memref<?xindex>
// CHECK: %[[VAL_11:.*]] = arith.addi %[[VAL_9]], %[[VAL_2]] : index // CHECK: %[[VAL_11:.*]] = arith.addi %[[VAL_9]], %[[VAL_2]] : index
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xindex> // CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_12]] step %[[VAL_2]] { // CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_12]] step %[[VAL_2]] {
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xf32> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xf32>
// CHECK: %[[VAL_15:.*]] = arith.mulf %[[VAL_14]], %[[VAL_3]] : f32 // CHECK: %[[VAL_15:.*]] = arith.mulf %[[VAL_14]], %[[VAL_3]] : f32
// CHECK: memref.store %[[VAL_15]], %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xf32> // CHECK: memref.store %[[VAL_15]], %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xf32>
// CHECK: } // CHECK: }
// CHECK: } // CHECK: }
// CHECK: %[[VAL_16:.*]] = sparse_tensor.load %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_16:.*]] = sparse_tensor.load %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: return %[[VAL_16]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: return %[[VAL_16]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
func.func @sparse_simply_dynamic1(%argx: tensor<32x16xf32, #DCSR>) -> tensor<32x16xf32, #DCSR> { func.func @sparse_simply_dynamic1(%argx: tensor<32x16xf32, #DCSR>) -> tensor<32x16xf32, #DCSR> {
%c = arith.constant 2.0 : f32 %c = arith.constant 2.0 : f32
%0 = linalg.generic #trait_scale_inpl %0 = linalg.generic #trait_scale_inpl
outs(%argx: tensor<32x16xf32, #DCSR>) { outs(%argx: tensor<32x16xf32, #DCSR>) {
^bb(%x: f32): ^bb(%x: f32):
%1 = arith.mulf %x, %c : f32 %1 = arith.mulf %x, %c : f32
linalg.yield %1 : f32 linalg.yield %1 : f32
} -> tensor<32x16xf32, #DCSR> } -> tensor<32x16xf32, #DCSR>
return %0 : tensor<32x16xf32, #DCSR> return %0 : tensor<32x16xf32, #DCSR>
} }
// CHECK-LABEL: func.func @sparse_simply_dynamic2( // CHECK-LABEL: func.func @sparse_simply_dynamic2(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) -> tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> { // CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) -> tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> {
// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_3:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_3:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK: %[[VAL_6:.*]] = memref.load %[[VAL_3]]{{\[}}%[[VAL_1]]] : memref<?xindex> // CHECK: %[[VAL_6:.*]] = memref.load %[[VAL_3]]{{\[}}%[[VAL_1]]] : memref<?xindex>
// CHECK: %[[VAL_7:.*]] = memref.load %[[VAL_3]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK: %[[VAL_7:.*]] = memref.load %[[VAL_3]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_8:.*]] = %[[VAL_6]] to %[[VAL_7]] step %[[VAL_2]] { // CHECK: scf.for %[[VAL_8:.*]] = %[[VAL_6]] to %[[VAL_7]] step %[[VAL_2]] {
// CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_8]]] : memref<?xindex> // CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_8]]] : memref<?xindex>
// CHECK: %[[VAL_10:.*]] = arith.addi %[[VAL_8]], %[[VAL_2]] : index // CHECK: %[[VAL_10:.*]] = arith.addi %[[VAL_8]], %[[VAL_2]] : index
// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_10]]] : memref<?xindex> // CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_10]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_9]] to %[[VAL_11]] step %[[VAL_2]] { // CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_9]] to %[[VAL_11]] step %[[VAL_2]] {
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xf32> // CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xf32>
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xf32> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xf32>
// CHECK: %[[VAL_15:.*]] = arith.addf %[[VAL_13]], %[[VAL_14]] : f32 // CHECK: %[[VAL_15:.*]] = arith.addf %[[VAL_13]], %[[VAL_14]] : f32
// CHECK: memref.store %[[VAL_15]], %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xf32> // CHECK: memref.store %[[VAL_15]], %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xf32>
// CHECK: } // CHECK: }
// CHECK: } // CHECK: }
// CHECK: %[[VAL_16:.*]] = sparse_tensor.load %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_16:.*]] = sparse_tensor.load %[[VAL_0]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: return %[[VAL_16]] : tensor<32x16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: return %[[VAL_16]] : tensor<32x16xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
func.func @sparse_simply_dynamic2(%argx: tensor<32x16xf32, #DCSR>) -> tensor<32x16xf32, #DCSR> { func.func @sparse_simply_dynamic2(%argx: tensor<32x16xf32, #DCSR>) -> tensor<32x16xf32, #DCSR> {
%0 = linalg.generic #trait_scale_inpl %0 = linalg.generic #trait_scale_inpl
outs(%argx: tensor<32x16xf32, #DCSR>) { outs(%argx: tensor<32x16xf32, #DCSR>) {
^bb(%x: f32): ^bb(%x: f32):
%1 = arith.addf %x, %x : f32 %1 = arith.addf %x, %x : f32
linalg.yield %1 : f32 linalg.yield %1 : f32
} -> tensor<32x16xf32, #DCSR> } -> tensor<32x16xf32, #DCSR>
return %0 : tensor<32x16xf32, #DCSR> return %0 : tensor<32x16xf32, #DCSR>
} }
#trait_scale = { #trait_scale = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
doc = "X(i,j) = A(i,j) * 2.0" doc = "X(i,j) = A(i,j) * 2.0"
} }
// CHECK-LABEL: func.func @sparse_truly_dynamic( // CHECK-LABEL: func.func @sparse_truly_dynamic(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>) -> tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> { // CHECK-SAME: %[[VAL_0:.*]]: tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>) -> tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> {
// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 10 : index // CHECK-DAG: %[[VAL_1:.*]] = arith.constant 10 : index
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 2.000000e+00 : f32 // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 2.000000e+00 : f32
// CHECK-DAG: %[[VAL_5:.*]] = bufferization.alloc_tensor() : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK-DAG: %[[VAL_5:.*]] = bufferization.alloc_tensor() : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf32> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf32>
// CHECK: %[[VAL_9:.*]] = scf.for %[[VAL_10:.*]] = %[[VAL_2]] to %[[VAL_1]] step %[[VAL_3]] iter_args(%[[VAL_11:.*]] = %[[VAL_5]]) -> (tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_9:.*]] = scf.for %[[VAL_10:.*]] = %[[VAL_2]] to %[[VAL_1]] step %[[VAL_3]] iter_args(%[[VAL_11:.*]] = %[[VAL_5]]) -> (tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<?xindex> // CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<?xindex>
// CHECK: %[[VAL_13:.*]] = arith.addi %[[VAL_10]], %[[VAL_3]] : index // CHECK: %[[VAL_13:.*]] = arith.addi %[[VAL_10]], %[[VAL_3]] : index
// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex> // CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex>
// CHECK: %[[VAL_15:.*]] = scf.for %[[VAL_16:.*]] = %[[VAL_12]] to %[[VAL_14]] step %[[VAL_3]] iter_args(%[[VAL_17:.*]] = %[[VAL_11]]) -> (tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_15:.*]] = scf.for %[[VAL_16:.*]] = %[[VAL_12]] to %[[VAL_14]] step %[[VAL_3]] iter_args(%[[VAL_17:.*]] = %[[VAL_11]]) -> (tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_16]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_16]]] : memref<?xindex>
// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xf32> // CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xf32>
// CHECK: %[[VAL_20:.*]] = arith.mulf %[[VAL_19]], %[[VAL_4]] : f32 // CHECK: %[[VAL_20:.*]] = arith.mulf %[[VAL_19]], %[[VAL_4]] : f32
// CHECK: %[[VAL_21:.*]] = sparse_tensor.insert %[[VAL_20]] into %[[VAL_17]]{{\[}}%[[VAL_10]], %[[VAL_18]]] : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_21:.*]] = sparse_tensor.insert %[[VAL_20]] into %[[VAL_17]]{{\[}}%[[VAL_10]], %[[VAL_18]]] : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: scf.yield %[[VAL_21]] : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_21]] : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: scf.yield %[[VAL_22:.*]] : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_22:.*]] : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_23:.*]] = sparse_tensor.load %[[VAL_24:.*]] hasInserts : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_23:.*]] = sparse_tensor.load %[[VAL_24:.*]] hasInserts : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: return %[[VAL_23]] : tensor<10x20xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: return %[[VAL_23]] : tensor<10x20xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
func.func @sparse_truly_dynamic(%arga: tensor<10x20xf32, #CSR>) -> tensor<10x20xf32, #DCSR> { func.func @sparse_truly_dynamic(%arga: tensor<10x20xf32, #CSR>) -> tensor<10x20xf32, #DCSR> {
%s = arith.constant 2.0 : f32 %s = arith.constant 2.0 : f32
%xm = bufferization.alloc_tensor() : tensor<10x20xf32, #DCSR> %xm = bufferization.alloc_tensor() : tensor<10x20xf32, #DCSR>
%0 = linalg.generic #trait_scale %0 = linalg.generic #trait_scale
ins(%arga: tensor<10x20xf32, #CSR>) ins(%arga: tensor<10x20xf32, #CSR>)
outs(%xm: tensor<10x20xf32, #DCSR>) { outs(%xm: tensor<10x20xf32, #DCSR>) {
^bb(%a: f32, %x: f32): ^bb(%a: f32, %x: f32):
Show All 9 Lines indexing_maps = [
affine_map<(i,j,k) -> (i,j,k)>, // B affine_map<(i,j,k) -> (i,j,k)>, // B
affine_map<(i,j,k) -> (i,j)> // X (out) affine_map<(i,j,k) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel", "reduction"], iterator_types = ["parallel", "parallel", "reduction"],
doc = "X(i,j) = SUM_k A(i,j,k) * B(i,j,k)" doc = "X(i,j) = SUM_k A(i,j,k) * B(i,j,k)"
} }
// CHECK-LABEL: func.func @sumred( // CHECK-LABEL: func.func @sumred(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>>) -> tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> { // CHECK-SAME: %[[VAL_1:.*]]: tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>>) -> tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> {
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : i32 // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : i32
// CHECK-DAG: %[[VAL_FALSE:.*]] = arith.constant false // CHECK-DAG: %[[VAL_FALSE:.*]] = arith.constant false
// CHECK-DAG: %[[VAL_TRUE:.*]] = arith.constant true // CHECK-DAG: %[[VAL_TRUE:.*]] = arith.constant true
// CHECK: %[[VAL_5:.*]] = tensor.dim %[[VAL_0]], %[[VAL_2]] : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> // CHECK: %[[VAL_5:.*]] = tensor.dim %[[VAL_0]], %[[VAL_2]] : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>>
// CHECK: %[[VAL_6:.*]] = tensor.dim %[[VAL_0]], %[[VAL_3]] : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> // CHECK: %[[VAL_6:.*]] = tensor.dim %[[VAL_0]], %[[VAL_3]] : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>>
// CHECK: %[[VAL_7:.*]] = bufferization.alloc_tensor(%[[VAL_5]], %[[VAL_6]]) : tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_7:.*]] = bufferization.alloc_tensor(%[[VAL_5]], %[[VAL_6]]) : tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 2 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 2 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xi32> // CHECK: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xi32>
// CHECK: %[[VAL_15:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_15:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_16:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_16:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_17:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_17:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_18:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_18:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_19:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 2 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_19:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 2 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_20:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 2 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_20:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 2 : index} : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_21:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }>> to memref<?xi32> // CHECK: %[[VAL_21:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>> to memref<?xi32>
// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_26:.*]]:3 = scf.while (%[[VAL_27:.*]] = %[[VAL_22]], %[[VAL_28:.*]] = %[[VAL_24]], %[[VAL_29:.*]] = %[[VAL_7]]) : (index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) -> (index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_26:.*]]:3 = scf.while (%[[VAL_27:.*]] = %[[VAL_22]], %[[VAL_28:.*]] = %[[VAL_24]], %[[VAL_29:.*]] = %[[VAL_7]]) : (index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) -> (index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_30:.*]] = arith.cmpi ult, %[[VAL_27]], %[[VAL_23]] : index // CHECK: %[[VAL_30:.*]] = arith.cmpi ult, %[[VAL_27]], %[[VAL_23]] : index
// CHECK: %[[VAL_31:.*]] = arith.cmpi ult, %[[VAL_28]], %[[VAL_25]] : index // CHECK: %[[VAL_31:.*]] = arith.cmpi ult, %[[VAL_28]], %[[VAL_25]] : index
// CHECK: %[[VAL_32:.*]] = arith.andi %[[VAL_30]], %[[VAL_31]] : i1 // CHECK: %[[VAL_32:.*]] = arith.andi %[[VAL_30]], %[[VAL_31]] : i1
// CHECK: scf.condition(%[[VAL_32]]) %[[VAL_27]], %[[VAL_28]], %[[VAL_29]] : index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.condition(%[[VAL_32]]) %[[VAL_27]], %[[VAL_28]], %[[VAL_29]] : index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } do { // CHECK: } do {
// CHECK: ^bb0(%[[VAL_33:.*]]: index, %[[VAL_34:.*]]: index, %[[VAL_35:.*]]: tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>): // CHECK: ^bb0(%[[VAL_33:.*]]: index, %[[VAL_34:.*]]: index, %[[VAL_35:.*]]: tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>):
// CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_33]]] : memref<?xindex> // CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_33]]] : memref<?xindex>
// CHECK: %[[VAL_37:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_34]]] : memref<?xindex> // CHECK: %[[VAL_37:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_34]]] : memref<?xindex>
// CHECK: %[[VAL_38:.*]] = arith.cmpi ult, %[[VAL_37]], %[[VAL_36]] : index // CHECK: %[[VAL_38:.*]] = arith.cmpi ult, %[[VAL_37]], %[[VAL_36]] : index
// CHECK: %[[VAL_39:.*]] = arith.select %[[VAL_38]], %[[VAL_37]], %[[VAL_36]] : index // CHECK: %[[VAL_39:.*]] = arith.select %[[VAL_38]], %[[VAL_37]], %[[VAL_36]] : index
// CHECK: %[[VAL_40:.*]] = arith.cmpi eq, %[[VAL_36]], %[[VAL_39]] : index // CHECK: %[[VAL_40:.*]] = arith.cmpi eq, %[[VAL_36]], %[[VAL_39]] : index
// CHECK: %[[VAL_41:.*]] = arith.cmpi eq, %[[VAL_37]], %[[VAL_39]] : index // CHECK: %[[VAL_41:.*]] = arith.cmpi eq, %[[VAL_37]], %[[VAL_39]] : index
// CHECK: %[[VAL_42:.*]] = arith.andi %[[VAL_40]], %[[VAL_41]] : i1 // CHECK: %[[VAL_42:.*]] = arith.andi %[[VAL_40]], %[[VAL_41]] : i1
// CHECK: %[[VAL_43:.*]] = scf.if %[[VAL_42]] -> (tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_43:.*]] = scf.if %[[VAL_42]] -> (tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_44:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_33]]] : memref<?xindex> // CHECK: %[[VAL_44:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_33]]] : memref<?xindex>
// CHECK: %[[VAL_45:.*]] = arith.addi %[[VAL_33]], %[[VAL_3]] : index // CHECK: %[[VAL_45:.*]] = arith.addi %[[VAL_33]], %[[VAL_3]] : index
// CHECK: %[[VAL_46:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_45]]] : memref<?xindex> // CHECK: %[[VAL_46:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_45]]] : memref<?xindex>
// CHECK: %[[VAL_47:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_34]]] : memref<?xindex> // CHECK: %[[VAL_47:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_34]]] : memref<?xindex>
// CHECK: %[[VAL_48:.*]] = arith.addi %[[VAL_34]], %[[VAL_3]] : index // CHECK: %[[VAL_48:.*]] = arith.addi %[[VAL_34]], %[[VAL_3]] : index
// CHECK: %[[VAL_49:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_48]]] : memref<?xindex> // CHECK: %[[VAL_49:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_48]]] : memref<?xindex>
// CHECK: %[[VAL_50:.*]]:3 = scf.while (%[[VAL_51:.*]] = %[[VAL_44]], %[[VAL_52:.*]] = %[[VAL_47]], %[[VAL_53:.*]] = %[[VAL_35]]) : (index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) -> (index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_50:.*]]:3 = scf.while (%[[VAL_51:.*]] = %[[VAL_44]], %[[VAL_52:.*]] = %[[VAL_47]], %[[VAL_53:.*]] = %[[VAL_35]]) : (index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) -> (index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_54:.*]] = arith.cmpi ult, %[[VAL_51]], %[[VAL_46]] : index // CHECK: %[[VAL_54:.*]] = arith.cmpi ult, %[[VAL_51]], %[[VAL_46]] : index
// CHECK: %[[VAL_55:.*]] = arith.cmpi ult, %[[VAL_52]], %[[VAL_49]] : index // CHECK: %[[VAL_55:.*]] = arith.cmpi ult, %[[VAL_52]], %[[VAL_49]] : index
// CHECK: %[[VAL_56:.*]] = arith.andi %[[VAL_54]], %[[VAL_55]] : i1 // CHECK: %[[VAL_56:.*]] = arith.andi %[[VAL_54]], %[[VAL_55]] : i1
// CHECK: scf.condition(%[[VAL_56]]) %[[VAL_51]], %[[VAL_52]], %[[VAL_53]] : index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.condition(%[[VAL_56]]) %[[VAL_51]], %[[VAL_52]], %[[VAL_53]] : index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } do { // CHECK: } do {
// CHECK: ^bb0(%[[VAL_57:.*]]: index, %[[VAL_58:.*]]: index, %[[VAL_59:.*]]: tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>): // CHECK: ^bb0(%[[VAL_57:.*]]: index, %[[VAL_58:.*]]: index, %[[VAL_59:.*]]: tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>):
// CHECK: %[[VAL_60:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_57]]] : memref<?xindex> // CHECK: %[[VAL_60:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_57]]] : memref<?xindex>
// CHECK: %[[VAL_61:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_58]]] : memref<?xindex> // CHECK: %[[VAL_61:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_58]]] : memref<?xindex>
// CHECK: %[[VAL_62:.*]] = arith.cmpi ult, %[[VAL_61]], %[[VAL_60]] : index // CHECK: %[[VAL_62:.*]] = arith.cmpi ult, %[[VAL_61]], %[[VAL_60]] : index
// CHECK: %[[VAL_63:.*]] = arith.select %[[VAL_62]], %[[VAL_61]], %[[VAL_60]] : index // CHECK: %[[VAL_63:.*]] = arith.select %[[VAL_62]], %[[VAL_61]], %[[VAL_60]] : index
// CHECK: %[[VAL_64:.*]] = arith.cmpi eq, %[[VAL_60]], %[[VAL_63]] : index // CHECK: %[[VAL_64:.*]] = arith.cmpi eq, %[[VAL_60]], %[[VAL_63]] : index
// CHECK: %[[VAL_65:.*]] = arith.cmpi eq, %[[VAL_61]], %[[VAL_63]] : index // CHECK: %[[VAL_65:.*]] = arith.cmpi eq, %[[VAL_61]], %[[VAL_63]] : index
// CHECK: %[[VAL_66:.*]] = arith.andi %[[VAL_64]], %[[VAL_65]] : i1 // CHECK: %[[VAL_66:.*]] = arith.andi %[[VAL_64]], %[[VAL_65]] : i1
// CHECK: %[[VAL_67:.*]] = scf.if %[[VAL_66]] -> (tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_67:.*]] = scf.if %[[VAL_66]] -> (tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_68:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_57]]] : memref<?xindex> // CHECK: %[[VAL_68:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_57]]] : memref<?xindex>
// CHECK: %[[VAL_69:.*]] = arith.addi %[[VAL_57]], %[[VAL_3]] : index // CHECK: %[[VAL_69:.*]] = arith.addi %[[VAL_57]], %[[VAL_3]] : index
// CHECK: %[[VAL_70:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_69]]] : memref<?xindex> // CHECK: %[[VAL_70:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_69]]] : memref<?xindex>
// CHECK: %[[VAL_71:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_58]]] : memref<?xindex> // CHECK: %[[VAL_71:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_58]]] : memref<?xindex>
// CHECK: %[[VAL_72:.*]] = arith.addi %[[VAL_58]], %[[VAL_3]] : index // CHECK: %[[VAL_72:.*]] = arith.addi %[[VAL_58]], %[[VAL_3]] : index
// CHECK: %[[VAL_73:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_72]]] : memref<?xindex> // CHECK: %[[VAL_73:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_72]]] : memref<?xindex>
// CHECK: %[[VAL_74:.*]]:5 = scf.while (%[[VAL_75:.*]] = %[[VAL_68]], %[[VAL_76:.*]] = %[[VAL_71]], %[[VAL_77:.*]] = %[[VAL_4]], %[[VAL_200:.*]] = %[[VAL_FALSE]], %[[VAL_78:.*]] = %[[VAL_59]]) : (index, index, i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) -> (index, index, i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_74:.*]]:5 = scf.while (%[[VAL_75:.*]] = %[[VAL_68]], %[[VAL_76:.*]] = %[[VAL_71]], %[[VAL_77:.*]] = %[[VAL_4]], %[[VAL_200:.*]] = %[[VAL_FALSE]], %[[VAL_78:.*]] = %[[VAL_59]]) : (index, index, i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) -> (index, index, i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_79:.*]] = arith.cmpi ult, %[[VAL_75]], %[[VAL_70]] : index // CHECK: %[[VAL_79:.*]] = arith.cmpi ult, %[[VAL_75]], %[[VAL_70]] : index
// CHECK: %[[VAL_80:.*]] = arith.cmpi ult, %[[VAL_76]], %[[VAL_73]] : index // CHECK: %[[VAL_80:.*]] = arith.cmpi ult, %[[VAL_76]], %[[VAL_73]] : index
// CHECK: %[[VAL_81:.*]] = arith.andi %[[VAL_79]], %[[VAL_80]] : i1 // CHECK: %[[VAL_81:.*]] = arith.andi %[[VAL_79]], %[[VAL_80]] : i1
// CHECK: scf.condition(%[[VAL_81]]) %[[VAL_75]], %[[VAL_76]], %[[VAL_77]], %[[VAL_200]], %[[VAL_78]] : index, index, i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.condition(%[[VAL_81]]) %[[VAL_75]], %[[VAL_76]], %[[VAL_77]], %[[VAL_200]], %[[VAL_78]] : index, index, i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } do { // CHECK: } do {
// CHECK: ^bb0(%[[VAL_82:.*]]: index, %[[VAL_83:.*]]: index, %[[VAL_84:.*]]: i32, %[[VAL_201:.*]]: i1, %[[VAL_85:.*]]: tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>): // CHECK: ^bb0(%[[VAL_82:.*]]: index, %[[VAL_83:.*]]: index, %[[VAL_84:.*]]: i32, %[[VAL_201:.*]]: i1, %[[VAL_85:.*]]: tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>):
// CHECK: %[[VAL_86:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_82]]] : memref<?xindex> // CHECK: %[[VAL_86:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_82]]] : memref<?xindex>
// CHECK: %[[VAL_87:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_83]]] : memref<?xindex> // CHECK: %[[VAL_87:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_83]]] : memref<?xindex>
// CHECK: %[[VAL_88:.*]] = arith.cmpi ult, %[[VAL_87]], %[[VAL_86]] : index // CHECK: %[[VAL_88:.*]] = arith.cmpi ult, %[[VAL_87]], %[[VAL_86]] : index
// CHECK: %[[VAL_89:.*]] = arith.select %[[VAL_88]], %[[VAL_87]], %[[VAL_86]] : index // CHECK: %[[VAL_89:.*]] = arith.select %[[VAL_88]], %[[VAL_87]], %[[VAL_86]] : index
// CHECK: %[[VAL_90:.*]] = arith.cmpi eq, %[[VAL_86]], %[[VAL_89]] : index // CHECK: %[[VAL_90:.*]] = arith.cmpi eq, %[[VAL_86]], %[[VAL_89]] : index
// CHECK: %[[VAL_91:.*]] = arith.cmpi eq, %[[VAL_87]], %[[VAL_89]] : index // CHECK: %[[VAL_91:.*]] = arith.cmpi eq, %[[VAL_87]], %[[VAL_89]] : index
// CHECK: %[[VAL_92:.*]] = arith.andi %[[VAL_90]], %[[VAL_91]] : i1 // CHECK: %[[VAL_92:.*]] = arith.andi %[[VAL_90]], %[[VAL_91]] : i1
// CHECK: %[[VAL_93:.*]]:3 = scf.if %[[VAL_92]] -> (i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_93:.*]]:3 = scf.if %[[VAL_92]] -> (i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_94:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_82]]] : memref<?xi32> // CHECK: %[[VAL_94:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_82]]] : memref<?xi32>
// CHECK: %[[VAL_95:.*]] = memref.load %[[VAL_21]]{{\[}}%[[VAL_83]]] : memref<?xi32> // CHECK: %[[VAL_95:.*]] = memref.load %[[VAL_21]]{{\[}}%[[VAL_83]]] : memref<?xi32>
// CHECK: %[[VAL_96:.*]] = arith.muli %[[VAL_94]], %[[VAL_95]] : i32 // CHECK: %[[VAL_96:.*]] = arith.muli %[[VAL_94]], %[[VAL_95]] : i32
// CHECK: %[[VAL_97:.*]] = arith.addi %[[VAL_84]], %[[VAL_96]] : i32 // CHECK: %[[VAL_97:.*]] = arith.addi %[[VAL_84]], %[[VAL_96]] : i32
// CHECK: scf.yield %[[VAL_97]], %[[VAL_TRUE]], %[[VAL_85]] : i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_97]], %[[VAL_TRUE]], %[[VAL_85]] : i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } else { // CHECK: } else {
// CHECK: scf.yield %[[VAL_84]], %[[VAL_201]], %[[VAL_85]] : i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_84]], %[[VAL_201]], %[[VAL_85]] : i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_98:.*]] = arith.cmpi eq, %[[VAL_86]], %[[VAL_89]] : index // CHECK: %[[VAL_98:.*]] = arith.cmpi eq, %[[VAL_86]], %[[VAL_89]] : index
// CHECK: %[[VAL_99:.*]] = arith.addi %[[VAL_82]], %[[VAL_3]] : index // CHECK: %[[VAL_99:.*]] = arith.addi %[[VAL_82]], %[[VAL_3]] : index
// CHECK: %[[VAL_100:.*]] = arith.select %[[VAL_98]], %[[VAL_99]], %[[VAL_82]] : index // CHECK: %[[VAL_100:.*]] = arith.select %[[VAL_98]], %[[VAL_99]], %[[VAL_82]] : index
// CHECK: %[[VAL_101:.*]] = arith.cmpi eq, %[[VAL_87]], %[[VAL_89]] : index // CHECK: %[[VAL_101:.*]] = arith.cmpi eq, %[[VAL_87]], %[[VAL_89]] : index
// CHECK: %[[VAL_102:.*]] = arith.addi %[[VAL_83]], %[[VAL_3]] : index // CHECK: %[[VAL_102:.*]] = arith.addi %[[VAL_83]], %[[VAL_3]] : index
// CHECK: %[[VAL_103:.*]] = arith.select %[[VAL_101]], %[[VAL_102]], %[[VAL_83]] : index // CHECK: %[[VAL_103:.*]] = arith.select %[[VAL_101]], %[[VAL_102]], %[[VAL_83]] : index
// CHECK: scf.yield %[[VAL_100]], %[[VAL_103]], %[[VAL_104:.*]]#0, %[[VAL_104]]#1, %[[VAL_104]]#2 : index, index, i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_100]], %[[VAL_103]], %[[VAL_104:.*]]#0, %[[VAL_104]]#1, %[[VAL_104]]#2 : index, index, i32, i1, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_202:.*]] = scf.if %[[VAL_74]]#3 -> (tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_202:.*]] = scf.if %[[VAL_74]]#3 -> (tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_105:.*]] = sparse_tensor.insert %[[VAL_74]]#2 into %[[VAL_74]]#4{{\[}}%[[VAL_39]], %[[VAL_63]]] : tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_105:.*]] = sparse_tensor.insert %[[VAL_74]]#2 into %[[VAL_74]]#4{{\[}}%[[VAL_39]], %[[VAL_63]]] : tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: scf.yield %[[VAL_105]] : tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_105]] : tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } else { // CHECK: } else {
// CHECK: scf.yield %[[VAL_74]]#4 : tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_74]]#4 : tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: scf.yield %[[VAL_202]] : tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_202]] : tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } else { // CHECK: } else {
// CHECK: scf.yield %[[VAL_59]] : tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_59]] : tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_107:.*]] = arith.cmpi eq, %[[VAL_60]], %[[VAL_63]] : index // CHECK: %[[VAL_107:.*]] = arith.cmpi eq, %[[VAL_60]], %[[VAL_63]] : index
// CHECK: %[[VAL_108:.*]] = arith.addi %[[VAL_57]], %[[VAL_3]] : index // CHECK: %[[VAL_108:.*]] = arith.addi %[[VAL_57]], %[[VAL_3]] : index
// CHECK: %[[VAL_109:.*]] = arith.select %[[VAL_107]], %[[VAL_108]], %[[VAL_57]] : index // CHECK: %[[VAL_109:.*]] = arith.select %[[VAL_107]], %[[VAL_108]], %[[VAL_57]] : index
// CHECK: %[[VAL_110:.*]] = arith.cmpi eq, %[[VAL_61]], %[[VAL_63]] : index // CHECK: %[[VAL_110:.*]] = arith.cmpi eq, %[[VAL_61]], %[[VAL_63]] : index
// CHECK: %[[VAL_111:.*]] = arith.addi %[[VAL_58]], %[[VAL_3]] : index // CHECK: %[[VAL_111:.*]] = arith.addi %[[VAL_58]], %[[VAL_3]] : index
// CHECK: %[[VAL_112:.*]] = arith.select %[[VAL_110]], %[[VAL_111]], %[[VAL_58]] : index // CHECK: %[[VAL_112:.*]] = arith.select %[[VAL_110]], %[[VAL_111]], %[[VAL_58]] : index
// CHECK: scf.yield %[[VAL_109]], %[[VAL_112]], %[[VAL_113:.*]] : index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_109]], %[[VAL_112]], %[[VAL_113:.*]] : index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: scf.yield %[[VAL_114:.*]]#2 : tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_114:.*]]#2 : tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } else { // CHECK: } else {
// CHECK: scf.yield %[[VAL_35]] : tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_35]] : tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_115:.*]] = arith.cmpi eq, %[[VAL_36]], %[[VAL_39]] : index // CHECK: %[[VAL_115:.*]] = arith.cmpi eq, %[[VAL_36]], %[[VAL_39]] : index
// CHECK: %[[VAL_116:.*]] = arith.addi %[[VAL_33]], %[[VAL_3]] : index // CHECK: %[[VAL_116:.*]] = arith.addi %[[VAL_33]], %[[VAL_3]] : index
// CHECK: %[[VAL_117:.*]] = arith.select %[[VAL_115]], %[[VAL_116]], %[[VAL_33]] : index // CHECK: %[[VAL_117:.*]] = arith.select %[[VAL_115]], %[[VAL_116]], %[[VAL_33]] : index
// CHECK: %[[VAL_118:.*]] = arith.cmpi eq, %[[VAL_37]], %[[VAL_39]] : index // CHECK: %[[VAL_118:.*]] = arith.cmpi eq, %[[VAL_37]], %[[VAL_39]] : index
// CHECK: %[[VAL_119:.*]] = arith.addi %[[VAL_34]], %[[VAL_3]] : index // CHECK: %[[VAL_119:.*]] = arith.addi %[[VAL_34]], %[[VAL_3]] : index
// CHECK: %[[VAL_120:.*]] = arith.select %[[VAL_118]], %[[VAL_119]], %[[VAL_34]] : index // CHECK: %[[VAL_120:.*]] = arith.select %[[VAL_118]], %[[VAL_119]], %[[VAL_34]] : index
// CHECK: scf.yield %[[VAL_117]], %[[VAL_120]], %[[VAL_121:.*]] : index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_117]], %[[VAL_120]], %[[VAL_121:.*]] : index, index, tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_122:.*]] = sparse_tensor.load %[[VAL_123:.*]]#2 hasInserts : tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_122:.*]] = sparse_tensor.load %[[VAL_123:.*]]#2 hasInserts : tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: return %[[VAL_122]] : tensor<?x?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: return %[[VAL_122]] : tensor<?x?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
func.func @sumred(%arga: tensor<?x?x?xi32, #SparseTensor>, func.func @sumred(%arga: tensor<?x?x?xi32, #SparseTensor>,
%argb: tensor<?x?x?xi32, #SparseTensor>) -> tensor<?x?xi32, #DCSR> { %argb: tensor<?x?x?xi32, #SparseTensor>) -> tensor<?x?xi32, #DCSR> {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%d0 = tensor.dim %arga, %c0 : tensor<?x?x?xi32, #SparseTensor> %d0 = tensor.dim %arga, %c0 : tensor<?x?x?xi32, #SparseTensor>
%d1 = tensor.dim %arga, %c1 : tensor<?x?x?xi32, #SparseTensor> %d1 = tensor.dim %arga, %c1 : tensor<?x?x?xi32, #SparseTensor>
%xinit = bufferization.alloc_tensor(%d0, %d1) : tensor<?x?xi32, #DCSR> %xinit = bufferization.alloc_tensor(%d0, %d1) : tensor<?x?xi32, #DCSR>
Show All 15 Lines indexing_maps = [
affine_map<(i,j,k) -> (k,j)>, // B affine_map<(i,j,k) -> (k,j)>, // B
affine_map<(i,j,k) -> (i,j)> // C (out) affine_map<(i,j,k) -> (i,j)> // C (out)
], ],
iterator_types = ["parallel", "parallel", "reduction"], iterator_types = ["parallel", "parallel", "reduction"],
doc = "C(i,j) = SUM_k A(i,k) * B(k,j)" doc = "C(i,j) = SUM_k A(i,k) * B(k,j)"
} }
// CHECK-LABEL: func.func @matmat( // CHECK-LABEL: func.func @matmat(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> { // CHECK-SAME: %[[VAL_1:.*]]: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> {
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant false // CHECK-DAG: %[[VAL_4:.*]] = arith.constant false
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant true // CHECK-DAG: %[[VAL_5:.*]] = arith.constant true
// CHECK: %[[VAL_6:.*]] = tensor.dim %[[VAL_0]], %[[VAL_2]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_6:.*]] = tensor.dim %[[VAL_0]], %[[VAL_2]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: %[[VAL_7:.*]] = tensor.dim %[[VAL_1]], %[[VAL_3]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_7:.*]] = tensor.dim %[[VAL_1]], %[[VAL_3]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: %[[VAL_8:.*]] = bufferization.alloc_tensor(%[[VAL_6]], %[[VAL_7]]) : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_8:.*]] = bufferization.alloc_tensor(%[[VAL_6]], %[[VAL_7]]) : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_13:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32> // CHECK: %[[VAL_13:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK: %[[VAL_14:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_14:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_15:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_15:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_16:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_16:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_17:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_17:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_18:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32> // CHECK: %[[VAL_18:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>
// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_21:.*]] = scf.for %[[VAL_22:.*]] = %[[VAL_19]] to %[[VAL_20]] step %[[VAL_3]] iter_args(%[[VAL_23:.*]] = %[[VAL_8]]) -> (tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_21:.*]] = scf.for %[[VAL_22:.*]] = %[[VAL_19]] to %[[VAL_20]] step %[[VAL_3]] iter_args(%[[VAL_23:.*]] = %[[VAL_8]]) -> (tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_22]]] : memref<?xindex> // CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_22]]] : memref<?xindex>
// CHECK: %[[VAL_25:.*]], %[[VAL_26:.*]], %[[VAL_27:.*]], %[[VAL_28:.*]] = sparse_tensor.expand %[[VAL_8]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf32>, memref<?xi1>, memref<?xindex> // CHECK: %[[VAL_25:.*]], %[[VAL_26:.*]], %[[VAL_27:.*]], %[[VAL_28:.*]] = sparse_tensor.expand %[[VAL_8]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf32>, memref<?xi1>, memref<?xindex>
// CHECK: %[[VAL_29:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_22]]] : memref<?xindex> // CHECK: %[[VAL_29:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_22]]] : memref<?xindex>
// CHECK: %[[VAL_30:.*]] = arith.addi %[[VAL_22]], %[[VAL_3]] : index // CHECK: %[[VAL_30:.*]] = arith.addi %[[VAL_22]], %[[VAL_3]] : index
// CHECK: %[[VAL_31:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_30]]] : memref<?xindex> // CHECK: %[[VAL_31:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_30]]] : memref<?xindex>
// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_34:.*]]:4 = scf.while (%[[VAL_35:.*]] = %[[VAL_29]], %[[VAL_36:.*]] = %[[VAL_32]], %[[VAL_37:.*]] = %[[VAL_28]], %[[VAL_38:.*]] = %[[VAL_23]]) : (index, index, index, tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) -> (index, index, index, tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_34:.*]]:4 = scf.while (%[[VAL_35:.*]] = %[[VAL_29]], %[[VAL_36:.*]] = %[[VAL_32]], %[[VAL_37:.*]] = %[[VAL_28]], %[[VAL_38:.*]] = %[[VAL_23]]) : (index, index, index, tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) -> (index, index, index, tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_39:.*]] = arith.cmpi ult, %[[VAL_35]], %[[VAL_31]] : index // CHECK: %[[VAL_39:.*]] = arith.cmpi ult, %[[VAL_35]], %[[VAL_31]] : index
// CHECK: %[[VAL_40:.*]] = arith.cmpi ult, %[[VAL_36]], %[[VAL_33]] : index // CHECK: %[[VAL_40:.*]] = arith.cmpi ult, %[[VAL_36]], %[[VAL_33]] : index
// CHECK: %[[VAL_41:.*]] = arith.andi %[[VAL_39]], %[[VAL_40]] : i1 // CHECK: %[[VAL_41:.*]] = arith.andi %[[VAL_39]], %[[VAL_40]] : i1
// CHECK: scf.condition(%[[VAL_41]]) %[[VAL_35]], %[[VAL_36]], %[[VAL_37]], %[[VAL_38]] : index, index, index, tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.condition(%[[VAL_41]]) %[[VAL_35]], %[[VAL_36]], %[[VAL_37]], %[[VAL_38]] : index, index, index, tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } do { // CHECK: } do {
// CHECK: ^bb0(%[[VAL_42:.*]]: index, %[[VAL_43:.*]]: index, %[[VAL_44:.*]]: index, %[[VAL_45:.*]]: tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>): // CHECK: ^bb0(%[[VAL_42:.*]]: index, %[[VAL_43:.*]]: index, %[[VAL_44:.*]]: index, %[[VAL_45:.*]]: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>):
// CHECK: %[[VAL_46:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_42]]] : memref<?xindex> // CHECK: %[[VAL_46:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_42]]] : memref<?xindex>
// CHECK: %[[VAL_47:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_43]]] : memref<?xindex> // CHECK: %[[VAL_47:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_43]]] : memref<?xindex>
// CHECK: %[[VAL_48:.*]] = arith.cmpi ult, %[[VAL_47]], %[[VAL_46]] : index // CHECK: %[[VAL_48:.*]] = arith.cmpi ult, %[[VAL_47]], %[[VAL_46]] : index
// CHECK: %[[VAL_49:.*]] = arith.select %[[VAL_48]], %[[VAL_47]], %[[VAL_46]] : index // CHECK: %[[VAL_49:.*]] = arith.select %[[VAL_48]], %[[VAL_47]], %[[VAL_46]] : index
// CHECK: %[[VAL_50:.*]] = arith.cmpi eq, %[[VAL_46]], %[[VAL_49]] : index // CHECK: %[[VAL_50:.*]] = arith.cmpi eq, %[[VAL_46]], %[[VAL_49]] : index
// CHECK: %[[VAL_51:.*]] = arith.cmpi eq, %[[VAL_47]], %[[VAL_49]] : index // CHECK: %[[VAL_51:.*]] = arith.cmpi eq, %[[VAL_47]], %[[VAL_49]] : index
// CHECK: %[[VAL_52:.*]] = arith.andi %[[VAL_50]], %[[VAL_51]] : i1 // CHECK: %[[VAL_52:.*]] = arith.andi %[[VAL_50]], %[[VAL_51]] : i1
// CHECK: %[[VAL_53:.*]]:2 = scf.if %[[VAL_52]] -> (index, tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_53:.*]]:2 = scf.if %[[VAL_52]] -> (index, tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_54:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_42]]] : memref<?xf32> // CHECK: %[[VAL_54:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_42]]] : memref<?xf32>
// CHECK: %[[VAL_55:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_43]]] : memref<?xindex> // CHECK: %[[VAL_55:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_43]]] : memref<?xindex>
// CHECK: %[[VAL_56:.*]] = arith.addi %[[VAL_43]], %[[VAL_3]] : index // CHECK: %[[VAL_56:.*]] = arith.addi %[[VAL_43]], %[[VAL_3]] : index
// CHECK: %[[VAL_57:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_56]]] : memref<?xindex> // CHECK: %[[VAL_57:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_56]]] : memref<?xindex>
// CHECK: %[[VAL_58:.*]] = scf.for %[[VAL_59:.*]] = %[[VAL_55]] to %[[VAL_57]] step %[[VAL_3]] iter_args(%[[VAL_60:.*]] = %[[VAL_44]]) -> (index) { // CHECK: %[[VAL_58:.*]] = scf.for %[[VAL_59:.*]] = %[[VAL_55]] to %[[VAL_57]] step %[[VAL_3]] iter_args(%[[VAL_60:.*]] = %[[VAL_44]]) -> (index) {
// CHECK: %[[VAL_61:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_59]]] : memref<?xindex> // CHECK: %[[VAL_61:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_59]]] : memref<?xindex>
// CHECK: %[[VAL_62:.*]] = memref.load %[[VAL_25]]{{\[}}%[[VAL_61]]] : memref<?xf32> // CHECK: %[[VAL_62:.*]] = memref.load %[[VAL_25]]{{\[}}%[[VAL_61]]] : memref<?xf32>
// CHECK: %[[VAL_63:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_59]]] : memref<?xf32> // CHECK: %[[VAL_63:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_59]]] : memref<?xf32>
// CHECK: %[[VAL_64:.*]] = arith.mulf %[[VAL_54]], %[[VAL_63]] : f32 // CHECK: %[[VAL_64:.*]] = arith.mulf %[[VAL_54]], %[[VAL_63]] : f32
// CHECK: %[[VAL_65:.*]] = arith.addf %[[VAL_62]], %[[VAL_64]] : f32 // CHECK: %[[VAL_65:.*]] = arith.addf %[[VAL_62]], %[[VAL_64]] : f32
// CHECK: %[[VAL_66:.*]] = memref.load %[[VAL_26]]{{\[}}%[[VAL_61]]] : memref<?xi1> // CHECK: %[[VAL_66:.*]] = memref.load %[[VAL_26]]{{\[}}%[[VAL_61]]] : memref<?xi1>
// CHECK: %[[VAL_67:.*]] = arith.cmpi eq, %[[VAL_66]], %[[VAL_4]] : i1 // CHECK: %[[VAL_67:.*]] = arith.cmpi eq, %[[VAL_66]], %[[VAL_4]] : i1
// CHECK: %[[VAL_68:.*]] = scf.if %[[VAL_67]] -> (index) { // CHECK: %[[VAL_68:.*]] = scf.if %[[VAL_67]] -> (index) {
// CHECK: memref.store %[[VAL_5]], %[[VAL_26]]{{\[}}%[[VAL_61]]] : memref<?xi1> // CHECK: memref.store %[[VAL_5]], %[[VAL_26]]{{\[}}%[[VAL_61]]] : memref<?xi1>
// CHECK: memref.store %[[VAL_61]], %[[VAL_27]]{{\[}}%[[VAL_60]]] : memref<?xindex> // CHECK: memref.store %[[VAL_61]], %[[VAL_27]]{{\[}}%[[VAL_60]]] : memref<?xindex>
// CHECK: %[[VAL_69:.*]] = arith.addi %[[VAL_60]], %[[VAL_3]] : index // CHECK: %[[VAL_69:.*]] = arith.addi %[[VAL_60]], %[[VAL_3]] : index
// CHECK: scf.yield %[[VAL_69]] : index // CHECK: scf.yield %[[VAL_69]] : index
// CHECK: } else { // CHECK: } else {
// CHECK: scf.yield %[[VAL_60]] : index // CHECK: scf.yield %[[VAL_60]] : index
// CHECK: } // CHECK: }
// CHECK: memref.store %[[VAL_65]], %[[VAL_25]]{{\[}}%[[VAL_61]]] : memref<?xf32> // CHECK: memref.store %[[VAL_65]], %[[VAL_25]]{{\[}}%[[VAL_61]]] : memref<?xf32>
// CHECK: scf.yield %[[VAL_70:.*]] : index // CHECK: scf.yield %[[VAL_70:.*]] : index
// CHECK: } // CHECK: }
// CHECK: scf.yield %[[VAL_71:.*]], %[[VAL_45]] : index, tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_71:.*]], %[[VAL_45]] : index, tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } else { // CHECK: } else {
// CHECK: scf.yield %[[VAL_44]], %[[VAL_45]] : index, tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_44]], %[[VAL_45]] : index, tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_72:.*]] = arith.cmpi eq, %[[VAL_46]], %[[VAL_49]] : index // CHECK: %[[VAL_72:.*]] = arith.cmpi eq, %[[VAL_46]], %[[VAL_49]] : index
// CHECK: %[[VAL_73:.*]] = arith.addi %[[VAL_42]], %[[VAL_3]] : index // CHECK: %[[VAL_73:.*]] = arith.addi %[[VAL_42]], %[[VAL_3]] : index
// CHECK: %[[VAL_74:.*]] = arith.select %[[VAL_72]], %[[VAL_73]], %[[VAL_42]] : index // CHECK: %[[VAL_74:.*]] = arith.select %[[VAL_72]], %[[VAL_73]], %[[VAL_42]] : index
// CHECK: %[[VAL_75:.*]] = arith.cmpi eq, %[[VAL_47]], %[[VAL_49]] : index // CHECK: %[[VAL_75:.*]] = arith.cmpi eq, %[[VAL_47]], %[[VAL_49]] : index
// CHECK: %[[VAL_76:.*]] = arith.addi %[[VAL_43]], %[[VAL_3]] : index // CHECK: %[[VAL_76:.*]] = arith.addi %[[VAL_43]], %[[VAL_3]] : index
// CHECK: %[[VAL_77:.*]] = arith.select %[[VAL_75]], %[[VAL_76]], %[[VAL_43]] : index // CHECK: %[[VAL_77:.*]] = arith.select %[[VAL_75]], %[[VAL_76]], %[[VAL_43]] : index
// CHECK: scf.yield %[[VAL_74]], %[[VAL_77]], %[[VAL_78:.*]]#0, %[[VAL_78]]#1 : index, index, index, tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_74]], %[[VAL_77]], %[[VAL_78:.*]]#0, %[[VAL_78]]#1 : index, index, index, tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_79:.*]] = sparse_tensor.compress %[[VAL_25]], %[[VAL_26]], %[[VAL_27]], %[[VAL_80:.*]]#2 into %[[VAL_80]]#3{{\[}}%[[VAL_24]]] : memref<?xf32>, memref<?xi1>, memref<?xindex>, tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_79:.*]] = sparse_tensor.compress %[[VAL_25]], %[[VAL_26]], %[[VAL_27]], %[[VAL_80:.*]]#2 into %[[VAL_80]]#3{{\[}}%[[VAL_24]]] : memref<?xf32>, memref<?xi1>, memref<?xindex>, tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: scf.yield %[[VAL_79]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_79]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_81:.*]] = sparse_tensor.load %[[VAL_82:.*]] hasInserts : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_81:.*]] = sparse_tensor.load %[[VAL_82:.*]] hasInserts : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: return %[[VAL_81]] : tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: return %[[VAL_81]] : tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
func.func @matmat(%arga: tensor<?x?xf32, #DCSR>, func.func @matmat(%arga: tensor<?x?xf32, #DCSR>,
%argb: tensor<?x?xf32, #DCSR>) -> tensor<?x?xf32, #DCSR> { %argb: tensor<?x?xf32, #DCSR>) -> tensor<?x?xf32, #DCSR> {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%d0 = tensor.dim %arga, %c0 : tensor<?x?xf32, #DCSR> %d0 = tensor.dim %arga, %c0 : tensor<?x?xf32, #DCSR>
%d1 = tensor.dim %argb, %c1 : tensor<?x?xf32, #DCSR> %d1 = tensor.dim %argb, %c1 : tensor<?x?xf32, #DCSR>
%cinit = bufferization.alloc_tensor(%d0, %d1) : tensor<?x?xf32, #DCSR> %cinit = bufferization.alloc_tensor(%d0, %d1) : tensor<?x?xf32, #DCSR>
Show All 11 Lines

mlir/test/Dialect/SparseTensor/sparse_outbuf.mlir

// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // A (in) affine_map<(i) -> (i)>, // A (in)
affine_map<(i) -> (i)> // X (out) affine_map<(i) -> (i)> // X (out)
], ],
iterator_types = ["parallel"] iterator_types = ["parallel"]
} }
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_pack.mlir

// RUN: mlir-opt %s --canonicalize --post-sparsification-rewrite="enable-runtime-library=false" --sparse-tensor-codegen -cse | FileCheck %s // RUN: mlir-opt %s --canonicalize --post-sparsification-rewrite="enable-runtime-library=false" --sparse-tensor-codegen -cse | FileCheck %s
#COO = #sparse_tensor.encoding<{ #COO = #sparse_tensor.encoding<{
dimLevelType = ["compressed-nu", "singleton"], lvlTypes = ["compressed-nu", "singleton"],
crdWidth=32 crdWidth=32
}> }>
// CHECK-LABEL: func.func @sparse_pack( // CHECK-LABEL: func.func @sparse_pack(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<6xf64>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<6xf64>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<6x2xi32>) // CHECK-SAME: %[[VAL_1:.*]]: tensor<6x2xi32>)
// CHECK-DAG: %[[VAL_2:.*]] = memref.alloc() : memref<2xindex> // CHECK-DAG: %[[VAL_2:.*]] = memref.alloc() : memref<2xindex>
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_parallel.mlir

// RUN: mlir-opt %s -sparsification="parallelization-strategy=none" | \ // RUN: mlir-opt %s -sparsification="parallelization-strategy=none" | \
// RUN: FileCheck %s --check-prefix=CHECK-PAR0 // RUN: FileCheck %s --check-prefix=CHECK-PAR0
// RUN: mlir-opt %s -sparsification="parallelization-strategy=dense-outer-loop" | \ // RUN: mlir-opt %s -sparsification="parallelization-strategy=dense-outer-loop" | \
// RUN: FileCheck %s --check-prefix=CHECK-PAR1 // RUN: FileCheck %s --check-prefix=CHECK-PAR1
// RUN: mlir-opt %s -sparsification="parallelization-strategy=any-storage-outer-loop" | \ // RUN: mlir-opt %s -sparsification="parallelization-strategy=any-storage-outer-loop" | \
// RUN: FileCheck %s --check-prefix=CHECK-PAR2 // RUN: FileCheck %s --check-prefix=CHECK-PAR2
// RUN: mlir-opt %s -sparsification="parallelization-strategy=dense-any-loop" | \ // RUN: mlir-opt %s -sparsification="parallelization-strategy=dense-any-loop" | \
// RUN: FileCheck %s --check-prefix=CHECK-PAR3 // RUN: FileCheck %s --check-prefix=CHECK-PAR3
// RUN: mlir-opt %s -sparsification="parallelization-strategy=any-storage-any-loop" | \ // RUN: mlir-opt %s -sparsification="parallelization-strategy=any-storage-any-loop" | \
// RUN: FileCheck %s --check-prefix=CHECK-PAR4 // RUN: FileCheck %s --check-prefix=CHECK-PAR4
#DenseMatrix = #sparse_tensor.encoding<{ #DenseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense" ] lvlTypes = [ "dense", "dense" ]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
#trait_dd = { #trait_dd = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_parallel_reduce.mlir

// RUN: mlir-opt %s -sparsification="parallelization-strategy=any-storage-any-loop" | \ // RUN: mlir-opt %s -sparsification="parallelization-strategy=any-storage-any-loop" | \
// RUN: FileCheck %s // RUN: FileCheck %s
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
#trait_matvec = { #trait_matvec = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (j)>, // b affine_map<(i,j) -> (j)>, // b
affine_map<(i,j) -> (i)> // x (out) affine_map<(i,j) -> (i)> // x (out)
], ],
iterator_types = ["parallel", "reduction"], iterator_types = ["parallel", "reduction"],
doc = "x(i) += A(i,j) * b(j)" doc = "x(i) += A(i,j) * b(j)"
} }
// CHECK-LABEL: func.func @matvec( // CHECK-LABEL: func.func @matvec(
// CHECK-SAME: %[[TMP_arg0:.*]]: tensor<16x32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>, // CHECK-SAME: %[[TMP_arg0:.*]]: tensor<16x32xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>,
// CHECK-SAME: %[[TMP_arg1:.*]]: tensor<32xf32>, // CHECK-SAME: %[[TMP_arg1:.*]]: tensor<32xf32>,
// CHECK-SAME: %[[TMP_arg2:.*]]: tensor<16xf32>) -> tensor<16xf32> { // CHECK-SAME: %[[TMP_arg2:.*]]: tensor<16xf32>) -> tensor<16xf32> {
// CHECK-DAG: %[[TMP_c16:.*]] = arith.constant 16 : index // CHECK-DAG: %[[TMP_c16:.*]] = arith.constant 16 : index
// CHECK-DAG: %[[TMP_c0:.*]] = arith.constant 0 : index // CHECK-DAG: %[[TMP_c0:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[TMP_c1:.*]] = arith.constant 1 : index // CHECK-DAG: %[[TMP_c1:.*]] = arith.constant 1 : index
// CHECK: %[[TMP_0:.*]] = sparse_tensor.positions %[[TMP_arg0]] {level = 1 : index} // CHECK: %[[TMP_0:.*]] = sparse_tensor.positions %[[TMP_arg0]] {level = 1 : index}
// CHECK: %[[TMP_1:.*]] = sparse_tensor.coordinates %[[TMP_arg0]] {level = 1 : index} // CHECK: %[[TMP_1:.*]] = sparse_tensor.coordinates %[[TMP_arg0]] {level = 1 : index}
// CHECK: %[[TMP_2:.*]] = sparse_tensor.values %[[TMP_arg0]] // CHECK: %[[TMP_2:.*]] = sparse_tensor.values %[[TMP_arg0]]
Show All 37 Lines

mlir/test/Dialect/SparseTensor/sparse_perm.mlir

// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#X = #sparse_tensor.encoding<{ #X = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense", "dense" ], lvlTypes = [ "dense", "dense", "dense" ],
dimOrdering = affine_map<(i,j,k) -> (k,i,j)> dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
}> }>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j,k) -> (k,i,j)>, // A (in) affine_map<(i,j,k) -> (k,i,j)>, // A (in)
affine_map<(i,j,k) -> (i,j,k)> // X (out) affine_map<(i,j,k) -> (i,j,k)> // X (out)
], ],
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_perm_lower.mlir

// RUN: mlir-opt %s -sparsification --canonicalize | FileCheck %s --check-prefix=CHECK-HIR // RUN: mlir-opt %s -sparsification --canonicalize | FileCheck %s --check-prefix=CHECK-HIR
// //
// RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --canonicalize | \ // RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --canonicalize | \
// RUN: FileCheck %s --check-prefix=CHECK-MIR // RUN: FileCheck %s --check-prefix=CHECK-MIR
#X = #sparse_tensor.encoding<{ #X = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense", "dense" ], lvlTypes = [ "dense", "dense", "dense" ],
dimOrdering = affine_map<(i,j,k) -> (k,i,j)> dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
}> }>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j,k) -> (k,i,j)>, // A (in) affine_map<(i,j,k) -> (k,i,j)>, // A (in)
affine_map<(i,j,k) -> ()> // X (out) affine_map<(i,j,k) -> ()> // X (out)
], ],
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_reshape.mlir

// RUN: mlir-opt %s | mlir-opt | FileCheck %s --check-prefix=CHECK-ROUND // RUN: mlir-opt %s | mlir-opt | FileCheck %s --check-prefix=CHECK-ROUND
// RUN: mlir-opt %s --sparse-tensor-conversion --cse --canonicalize | FileCheck %s --check-prefix=CHECK-CONV // RUN: mlir-opt %s --sparse-tensor-conversion --cse --canonicalize | FileCheck %s --check-prefix=CHECK-CONV
// RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-convert=false" \ // RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-convert=false" \
// RUN: --cse --canonicalize | FileCheck %s --check-prefix=CHECK-RWT // RUN: --cse --canonicalize | FileCheck %s --check-prefix=CHECK-RWT
#SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#SparseMatrix = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #SparseMatrix = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
// //
// roundtrip: // roundtrip:
// //
// CHECK-ROUND-LABEL: func.func @sparse_expand( // CHECK-ROUND-LABEL: func.func @sparse_expand(
// CHECK-ROUND-SAME: %[[A:.*]]: tensor<100xf64, #sparse_tensor.encoding<{{{.*}}}>>) -> tensor<10x10xf64, #sparse_tensor.encoding<{{{.*}}}>> // CHECK-ROUND-SAME: %[[A:.*]]: tensor<100xf64, #sparse_tensor.encoding<{{{.*}}}>>) -> tensor<10x10xf64, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK-ROUND: %[[E:.*]] = tensor.expand_shape %[[A]] {{\[\[}}0, 1]] : tensor<100xf64, #sparse_tensor.encoding<{{{.*}}}>> into tensor<10x10xf64, #sparse_tensor.encoding<{{{.*}}}>> // CHECK-ROUND: %[[E:.*]] = tensor.expand_shape %[[A]] {{\[\[}}0, 1]] : tensor<100xf64, #sparse_tensor.encoding<{{{.*}}}>> into tensor<10x10xf64, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK-ROUND: return %[[E]] : tensor<10x10xf64, #sparse_tensor.encoding<{{{.*}}}>> // CHECK-ROUND: return %[[E]] : tensor<10x10xf64, #sparse_tensor.encoding<{{{.*}}}>>
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
// CHECK-RWT: %[[SV:.*]] = memref.load %[[V]]{{\[}}%[[I]]] : memref<?xf64> // CHECK-RWT: %[[SV:.*]] = memref.load %[[V]]{{\[}}%[[I]]] : memref<?xf64>
// CHECK-RWT: %[[DI0:.*]] = arith.divui %[[SI]], %[[C10]] : index // CHECK-RWT: %[[DI0:.*]] = arith.divui %[[SI]], %[[C10]] : index
// CHECK-RWT: %[[DI1:.*]] = arith.remui %[[SI]], %[[C10]] : index // CHECK-RWT: %[[DI1:.*]] = arith.remui %[[SI]], %[[C10]] : index
// CHECK-RWT: %[[NT:.*]] = sparse_tensor.insert %[[SV]] into %[[R]]{{\[}}%[[DI0]], %[[DI1]]] // CHECK-RWT: %[[NT:.*]] = sparse_tensor.insert %[[SV]] into %[[R]]{{\[}}%[[DI0]], %[[DI1]]]
// CHECK-RWT: scf.yield %[[NT:.*]] // CHECK-RWT: scf.yield %[[NT:.*]]
// CHECK-RWT: } // CHECK-RWT: }
// CHECK-RWT: %[[NT1:.*]] = sparse_tensor.load %[[RET]] hasInserts // CHECK-RWT: %[[NT1:.*]] = sparse_tensor.load %[[RET]] hasInserts
// CHECK-RWT-NOT: sparse_tensor.convert // CHECK-RWT-NOT: sparse_tensor.convert
// CHECK-RWT: return %[[NT1]] : tensor<10x10xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK-RWT: return %[[NT1]] : tensor<10x10xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// //
func.func @sparse_expand(%arg0: tensor<100xf64, #SparseVector>) -> tensor<10x10xf64, #SparseMatrix> { func.func @sparse_expand(%arg0: tensor<100xf64, #SparseVector>) -> tensor<10x10xf64, #SparseMatrix> {
%0 = tensor.expand_shape %arg0 [[0, 1]] : %0 = tensor.expand_shape %arg0 [[0, 1]] :
tensor<100xf64, #SparseVector> into tensor<10x10xf64, #SparseMatrix> tensor<100xf64, #SparseVector> into tensor<10x10xf64, #SparseMatrix>
return %0 : tensor<10x10xf64, #SparseMatrix> return %0 : tensor<10x10xf64, #SparseMatrix>
} }
// //
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
// CHECK-RWT: %[[DI:.*]] = arith.addi %[[T]], %[[SI1]] : index // CHECK-RWT: %[[DI:.*]] = arith.addi %[[T]], %[[SI1]] : index
// CHECK-RWT: %[[R1:.*]] = sparse_tensor.insert %[[SV]] into %[[A1]]{{\[}}%[[DI]]] // CHECK-RWT: %[[R1:.*]] = sparse_tensor.insert %[[SV]] into %[[A1]]{{\[}}%[[DI]]]
// CHECK-RWT scf.yield %[[R1]] // CHECK-RWT scf.yield %[[R1]]
// CHECK-RWT } // CHECK-RWT }
// CHECK-RWT scf.yield %[[RET_1]] // CHECK-RWT scf.yield %[[RET_1]]
// CHECK-RWT: } // CHECK-RWT: }
// CHECK-RWT: %[[NT1:.*]] = sparse_tensor.load %[[RET]] hasInserts // CHECK-RWT: %[[NT1:.*]] = sparse_tensor.load %[[RET]] hasInserts
// CHECK-RWT-NOT: sparse_tensor.convert // CHECK-RWT-NOT: sparse_tensor.convert
// CHECK-RWT: return %[[NT1]] : tensor<100xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> // CHECK-RWT: return %[[NT1]] : tensor<100xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>
// //
func.func @sparse_collapse(%arg0: tensor<10x10xf64, #SparseMatrix>) -> tensor<100xf64, #SparseVector> { func.func @sparse_collapse(%arg0: tensor<10x10xf64, #SparseMatrix>) -> tensor<100xf64, #SparseVector> {
%0 = tensor.collapse_shape %arg0 [[0, 1]] : %0 = tensor.collapse_shape %arg0 [[0, 1]] :
tensor<10x10xf64, #SparseMatrix> into tensor<100xf64, #SparseVector> tensor<10x10xf64, #SparseMatrix> into tensor<100xf64, #SparseVector>
return %0 : tensor<100xf64, #SparseVector> return %0 : tensor<100xf64, #SparseVector>
} }
// //
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
// CHECK-RWT: %[[T3:.*]] = arith.remui %[[SI]], %[[T2]] : index // CHECK-RWT: %[[T3:.*]] = arith.remui %[[SI]], %[[T2]] : index
// CHECK-RWT: %[[T4:.*]] = arith.divui %[[T2]], %[[C10]] : index // CHECK-RWT: %[[T4:.*]] = arith.divui %[[T2]], %[[C10]] : index
// CHECK-RWT: %[[DI1:.*]] = arith.divui %[[T3]], %[[T4]] : index // CHECK-RWT: %[[DI1:.*]] = arith.divui %[[T3]], %[[T4]] : index
// CHECK-RWT: %[[NT:.*]] = sparse_tensor.insert %[[SV]] into %[[R]]{{\[}}%[[DI0]], %[[DI1]]] // CHECK-RWT: %[[NT:.*]] = sparse_tensor.insert %[[SV]] into %[[R]]{{\[}}%[[DI0]], %[[DI1]]]
// CHECK-RWT: scf.yield %[[NT]] // CHECK-RWT: scf.yield %[[NT]]
// CHECK-RWT: } // CHECK-RWT: }
// CHECK-RWT: %[[NT1:.*]] = sparse_tensor.load %[[RET]] hasInserts // CHECK-RWT: %[[NT1:.*]] = sparse_tensor.load %[[RET]] hasInserts
// CHECK-RWT-NOT: sparse_tensor.convert // CHECK-RWT-NOT: sparse_tensor.convert
// CHECK-RWT: return %[[NT1]] : tensor<?x10xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK-RWT: return %[[NT1]] : tensor<?x10xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// //
func.func @dynamic_sparse_expand(%arg0: tensor<?xf64, #SparseVector>) -> tensor<?x10xf64, #SparseMatrix> { func.func @dynamic_sparse_expand(%arg0: tensor<?xf64, #SparseVector>) -> tensor<?x10xf64, #SparseMatrix> {
%0 = tensor.expand_shape %arg0 [[0, 1]] : %0 = tensor.expand_shape %arg0 [[0, 1]] :
tensor<?xf64, #SparseVector> into tensor<?x10xf64, #SparseMatrix> tensor<?xf64, #SparseVector> into tensor<?x10xf64, #SparseMatrix>
return %0 : tensor<?x10xf64, #SparseMatrix> return %0 : tensor<?x10xf64, #SparseMatrix>
} }
// //
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
// CHECK-RWT: %[[DI:.*]] = arith.addi %[[T2]], %[[T4]] : index // CHECK-RWT: %[[DI:.*]] = arith.addi %[[T2]], %[[T4]] : index
// CHECK-RWT: %[[NT:.*]] = sparse_tensor.insert %[[SV]] into %[[R1]]{{\[}}%[[DI]]] // CHECK-RWT: %[[NT:.*]] = sparse_tensor.insert %[[SV]] into %[[R1]]{{\[}}%[[DI]]]
// CHECK-RWT scf.yield %[[NT]] // CHECK-RWT scf.yield %[[NT]]
// CHECK-RWT } // CHECK-RWT }
// CHECK-RWT scf.yield %[[RET_1]] // CHECK-RWT scf.yield %[[RET_1]]
// CHECK-RWT: } // CHECK-RWT: }
// CHECK-RWT: %[[NT1:.*]] = sparse_tensor.load %[[RET]] hasInserts // CHECK-RWT: %[[NT1:.*]] = sparse_tensor.load %[[RET]] hasInserts
// CHECK-RWT-NOT: sparse_tensor.convert // CHECK-RWT-NOT: sparse_tensor.convert
// CHECK-RWT: return %[[NT1]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> // CHECK-RWT: return %[[NT1]] : tensor<?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>
// //
func.func @dynamic_sparse_collapse(%arg0: tensor<10x?xf64, #SparseMatrix>) -> tensor<?xf64, #SparseVector> { func.func @dynamic_sparse_collapse(%arg0: tensor<10x?xf64, #SparseMatrix>) -> tensor<?xf64, #SparseVector> {
%0 = tensor.collapse_shape %arg0 [[0, 1]] : %0 = tensor.collapse_shape %arg0 [[0, 1]] :
tensor<10x?xf64, #SparseMatrix> into tensor<?xf64, #SparseVector> tensor<10x?xf64, #SparseMatrix> into tensor<?xf64, #SparseVector>
return %0 : tensor<?xf64, #SparseVector> return %0 : tensor<?xf64, #SparseVector>
} }

mlir/test/Dialect/SparseTensor/sparse_reshape_dot.mlir

// RUN: mlir-opt %s --linalg-generalize-named-ops --sparsification --cse --canonicalize | FileCheck %s // RUN: mlir-opt %s --linalg-generalize-named-ops --sparsification --cse --canonicalize | FileCheck %s
#COO_2D = #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ], posWidth = 32, crdWidth = 32 }> #COO_2D = #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ], posWidth = 32, crdWidth = 32 }>
#COO_3D = #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton-nu", "singleton" ], posWidth = 32, crdWidth = 32 }> #COO_3D = #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ], posWidth = 32, crdWidth = 32 }>
// CHECK-LABEL: func.func @sparse_reshape_fused( // CHECK-LABEL: func.func @sparse_reshape_fused(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<5x6xf32>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<5x6xf32>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<6x2x3xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton-nu", "singleton" ], posWidth = 32, crdWidth = 32 }>>) -> tensor<?x?x?xf32> { // CHECK-SAME: %[[VAL_1:.*]]: tensor<6x2x3xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ], posWidth = 32, crdWidth = 32 }>>) -> tensor<?x?x?xf32> {
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant false // CHECK-DAG: %[[VAL_2:.*]] = arith.constant false
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 5 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 5 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 3 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 3 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_7:.*]] = tensor.empty() : tensor<5x6xf32> // CHECK-DAG: %[[VAL_7:.*]] = tensor.empty() : tensor<5x6xf32>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index}
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index}
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_scalars.mlir

// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#SparseMatrix = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #SparseMatrix = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
// A contrived example that demonstrates the many different ways // A contrived example that demonstrates the many different ways
// in which scalar values can be involved in a sparse kernel // in which scalar values can be involved in a sparse kernel
// through the linalg generic op. // through the linalg generic op.
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A (sparse tensor) affine_map<(i,j) -> (i,j)>, // A (sparse tensor)
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_sddmm.mlir

// RUN: mlir-opt %s --test-tensor-copy-insertion --pre-sparsification-rewrite --sparsification --cse | FileCheck %s // RUN: mlir-opt %s --test-tensor-copy-insertion --pre-sparsification-rewrite --sparsification --cse | FileCheck %s
#SM = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #SM = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
#trait_matmul = { #trait_matmul = {
indexing_maps = [ indexing_maps = [
affine_map<(d0, d1, d2) -> (d1, d0)>, affine_map<(d0, d1, d2) -> (d1, d0)>,
affine_map<(d0, d1, d2) -> (d0, d2)>, affine_map<(d0, d1, d2) -> (d0, d2)>,
affine_map<(d0, d1, d2) -> (d1, d2)> affine_map<(d0, d1, d2) -> (d1, d2)>
], ],
iterator_types = ["reduction", "parallel", "parallel"] iterator_types = ["reduction", "parallel", "parallel"]
Show All 40 Lines %1 = linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>],
outs(%0 : tensor<32xf64>) { outs(%0 : tensor<32xf64>) {
^bb0(%x: f64): ^bb0(%x: f64):
linalg.yield %cst : f64 linalg.yield %cst : f64
} -> tensor<32xf64> } -> tensor<32xf64>
return %1 : tensor<32xf64> return %1 : tensor<32xf64>
} }
// CHECK-LABEL: func.func @sampled_dd_unfused( // CHECK-LABEL: func.func @sampled_dd_unfused(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<8x8xf64>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<8x8xf64>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<8x8xf64>) -> tensor<8x8xf64> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<8x8xf64>) -> tensor<8x8xf64> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant dense<0.000000e+00> : tensor<8x8xf64> // CHECK-DAG: %[[VAL_6:.*]] = arith.constant dense<0.000000e+00> : tensor<8x8xf64>
// CHECK-DAG: %[[VAL_7:.*]] = bufferization.alloc_tensor() copy(%[[VAL_6]]) {bufferization.escape = [false]} : tensor<8x8xf64> // CHECK-DAG: %[[VAL_7:.*]] = bufferization.alloc_tensor() copy(%[[VAL_6]]) {bufferization.escape = [false]} : tensor<8x8xf64>
// CHECK-DAG: %[[VAL_8:.*]] = bufferization.alloc_tensor() copy(%[[VAL_6]]) {bufferization.escape = [false], memory_space = 0 : i64} : tensor<8x8xf64> // CHECK-DAG: %[[VAL_8:.*]] = bufferization.alloc_tensor() copy(%[[VAL_6]]) {bufferization.escape = [false], memory_space = 0 : i64} : tensor<8x8xf64>
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines outs(%1 : tensor<8x8xf64>) {
^bb0(%t: f64, %s: f64, %x: f64): ^bb0(%t: f64, %s: f64, %x: f64):
%r = arith.mulf %t, %s : f64 %r = arith.mulf %t, %s : f64
linalg.yield %r : f64 linalg.yield %r : f64
} -> tensor<8x8xf64> } -> tensor<8x8xf64>
return %3 : tensor<8x8xf64> return %3 : tensor<8x8xf64>
} }
// CHECK-LABEL: func.func @sparse_sampled_dd_unfused( // CHECK-LABEL: func.func @sparse_sampled_dd_unfused(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<8x8xf64>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<8x8xf64>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<8x8xf64>) -> tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<8x8xf64>) -> tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant false // CHECK-DAG: %[[VAL_6:.*]] = arith.constant false
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant true // CHECK-DAG: %[[VAL_7:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_8:.*]] = arith.constant dense<0.000000e+00> : tensor<8x8xf64> // CHECK-DAG: %[[VAL_8:.*]] = arith.constant dense<0.000000e+00> : tensor<8x8xf64>
// CHECK-DAG: %[[VAL_9:.*]] = bufferization.alloc_tensor() copy(%[[VAL_8]]) {bufferization.escape = [false]} : tensor<8x8xf64> // CHECK-DAG: %[[VAL_9:.*]] = bufferization.alloc_tensor() copy(%[[VAL_8]]) {bufferization.escape = [false]} : tensor<8x8xf64>
// CHECK-DAG: %[[VAL_10:.*]] = bufferization.alloc_tensor() {bufferization.escape = [false]} : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK-DAG: %[[VAL_10:.*]] = bufferization.alloc_tensor() {bufferization.escape = [false]} : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<8x8xf64> // CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_1]] : memref<8x8xf64>
// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<8x8xf64> // CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_memref %[[VAL_2]] : memref<8x8xf64>
// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_16:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-DAG: %[[VAL_16:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_17:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf64> // CHECK-DAG: %[[VAL_17:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf64>
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_20:.*]] = scf.for %[[VAL_21:.*]] = %[[VAL_18]] to %[[VAL_19]] step %[[VAL_5]] iter_args(%[[VAL_22:.*]] = %[[VAL_10]]) -> (tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_20:.*]] = scf.for %[[VAL_21:.*]] = %[[VAL_18]] to %[[VAL_19]] step %[[VAL_5]] iter_args(%[[VAL_22:.*]] = %[[VAL_10]]) -> (tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_21]]] : memref<?xindex> // CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_21]]] : memref<?xindex>
// CHECK: %[[VAL_24:.*]], %[[VAL_25:.*]], %[[VAL_26:.*]], %[[VAL_27:.*]] = sparse_tensor.expand %[[VAL_10]] : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf64>, memref<?xi1>, memref<?xindex> // CHECK: %[[VAL_24:.*]], %[[VAL_25:.*]], %[[VAL_26:.*]], %[[VAL_27:.*]] = sparse_tensor.expand %[[VAL_10]] : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf64>, memref<?xi1>, memref<?xindex>
// CHECK: %[[VAL_28:.*]] = scf.for %[[VAL_29:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] iter_args(%[[VAL_30:.*]] = %[[VAL_27]]) -> (index) { // CHECK: %[[VAL_28:.*]] = scf.for %[[VAL_29:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] iter_args(%[[VAL_30:.*]] = %[[VAL_27]]) -> (index) {
// CHECK: %[[VAL_31:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_23]], %[[VAL_29]]] : memref<8x8xf64> // CHECK: %[[VAL_31:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_23]], %[[VAL_29]]] : memref<8x8xf64>
// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_21]]] : memref<?xindex> // CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_21]]] : memref<?xindex>
// CHECK: %[[VAL_33:.*]] = arith.addi %[[VAL_21]], %[[VAL_5]] : index // CHECK: %[[VAL_33:.*]] = arith.addi %[[VAL_21]], %[[VAL_5]] : index
// CHECK: %[[VAL_34:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_33]]] : memref<?xindex> // CHECK: %[[VAL_34:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_33]]] : memref<?xindex>
// CHECK: %[[VAL_35:.*]] = scf.for %[[VAL_36:.*]] = %[[VAL_32]] to %[[VAL_34]] step %[[VAL_5]] iter_args(%[[VAL_37:.*]] = %[[VAL_30]]) -> (index) { // CHECK: %[[VAL_35:.*]] = scf.for %[[VAL_36:.*]] = %[[VAL_32]] to %[[VAL_34]] step %[[VAL_5]] iter_args(%[[VAL_37:.*]] = %[[VAL_30]]) -> (index) {
// CHECK: %[[VAL_38:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_36]]] : memref<?xindex> // CHECK: %[[VAL_38:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_36]]] : memref<?xindex>
// CHECK: %[[VAL_39:.*]] = memref.load %[[VAL_24]]{{\[}}%[[VAL_38]]] : memref<?xf64> // CHECK: %[[VAL_39:.*]] = memref.load %[[VAL_24]]{{\[}}%[[VAL_38]]] : memref<?xf64>
Show All 12 Lines
// CHECK: } else { // CHECK: } else {
// CHECK: scf.yield %[[VAL_37]] : index // CHECK: scf.yield %[[VAL_37]] : index
// CHECK: } // CHECK: }
// CHECK: memref.store %[[VAL_44]], %[[VAL_24]]{{\[}}%[[VAL_38]]] : memref<?xf64> // CHECK: memref.store %[[VAL_44]], %[[VAL_24]]{{\[}}%[[VAL_38]]] : memref<?xf64>
// CHECK: scf.yield %[[VAL_49:.*]] : index // CHECK: scf.yield %[[VAL_49:.*]] : index
// CHECK: } // CHECK: }
// CHECK: scf.yield %[[VAL_50:.*]] : index // CHECK: scf.yield %[[VAL_50:.*]] : index
// CHECK: } // CHECK: }
// CHECK: %[[VAL_51:.*]] = sparse_tensor.compress %[[VAL_24]], %[[VAL_25]], %[[VAL_26]], %[[VAL_52:.*]] into %[[VAL_22]]{{\[}}%[[VAL_23]]] : memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_51:.*]] = sparse_tensor.compress %[[VAL_24]], %[[VAL_25]], %[[VAL_26]], %[[VAL_52:.*]] into %[[VAL_22]]{{\[}}%[[VAL_23]]] : memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: scf.yield %[[VAL_51]] : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_51]] : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_53:.*]] = sparse_tensor.load %[[VAL_54:.*]] hasInserts : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_53:.*]] = sparse_tensor.load %[[VAL_54:.*]] hasInserts : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: return %[[VAL_53]] : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: return %[[VAL_53]] : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
func.func @sparse_sampled_dd_unfused(%args: tensor<8x8xf64, #SM>, func.func @sparse_sampled_dd_unfused(%args: tensor<8x8xf64, #SM>,
%arga: tensor<8x8xf64>, %arga: tensor<8x8xf64>,
%argb: tensor<8x8xf64>) -> tensor<8x8xf64, #SM> { %argb: tensor<8x8xf64>) -> tensor<8x8xf64, #SM> {
// Perform dense-dense matrix matrix multiplication. // Perform dense-dense matrix matrix multiplication.
%1 = arith.constant dense<0.0> : tensor<8x8xf64> %1 = arith.constant dense<0.0> : tensor<8x8xf64>
%2 = linalg.generic #trait_matmul %2 = linalg.generic #trait_matmul
ins(%arga, %argb : tensor<8x8xf64>, tensor<8x8xf64>) ins(%arga, %argb : tensor<8x8xf64>, tensor<8x8xf64>)
Show All 17 Lines

mlir/test/Dialect/SparseTensor/sparse_sddmm_org.mlir

// RUN: mlir-opt %s --pre-sparsification-rewrite --sparsification --cse | FileCheck %s // RUN: mlir-opt %s --pre-sparsification-rewrite --sparsification --cse | FileCheck %s
#SM = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #SM = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
#trait_matmul = { #trait_matmul = {
indexing_maps = [ indexing_maps = [
affine_map<(d0, d1, d2) -> (d1, d0)>, affine_map<(d0, d1, d2) -> (d1, d0)>,
affine_map<(d0, d1, d2) -> (d0, d2)>, affine_map<(d0, d1, d2) -> (d0, d2)>,
affine_map<(d0, d1, d2) -> (d1, d2)> affine_map<(d0, d1, d2) -> (d1, d2)>
], ],
iterator_types = ["reduction", "parallel", "parallel"] iterator_types = ["reduction", "parallel", "parallel"]
} }
#trait_scale = { #trait_scale = {
indexing_maps = [ indexing_maps = [
affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>,
affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>,
affine_map<(d0, d1) -> (d0, d1)> affine_map<(d0, d1) -> (d0, d1)>
], ],
iterator_types = ["parallel", "parallel"] iterator_types = ["parallel", "parallel"]
} }
// CHECK-LABEL: func.func @sparse_sampled_dd_unfused( // CHECK-LABEL: func.func @sparse_sampled_dd_unfused(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<8x8xf64>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<8x8xf64>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<8x8xf64>) -> tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<8x8xf64>) -> tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant false // CHECK-DAG: %[[VAL_6:.*]] = arith.constant false
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant true // CHECK-DAG: %[[VAL_7:.*]] = arith.constant true
// CHECK: %[[VAL_8:.*]] = bufferization.alloc_tensor() : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_8:.*]] = bufferization.alloc_tensor() : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<8x8xf64> // CHECK: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<8x8xf64>
// CHECK: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_2]] : memref<8x8xf64> // CHECK: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_2]] : memref<8x8xf64>
// CHECK: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_13:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_13:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_14:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_14:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_15:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf64> // CHECK: %[[VAL_15:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf64>
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_18:.*]] = scf.for %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_5]] iter_args(%[[VAL_20:.*]] = %[[VAL_8]]) -> (tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_18:.*]] = scf.for %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_5]] iter_args(%[[VAL_20:.*]] = %[[VAL_8]]) -> (tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_19]]] : memref<?xindex> // CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_19]]] : memref<?xindex>
// CHECK: %[[VAL_22:.*]], %[[VAL_23:.*]], %[[VAL_24:.*]], %[[VAL_25:.*]] = sparse_tensor.expand %[[VAL_8]] : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf64>, memref<?xi1>, memref<?xindex> // CHECK: %[[VAL_22:.*]], %[[VAL_23:.*]], %[[VAL_24:.*]], %[[VAL_25:.*]] = sparse_tensor.expand %[[VAL_8]] : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf64>, memref<?xi1>, memref<?xindex>
// CHECK: %[[VAL_26:.*]] = scf.for %[[VAL_27:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] iter_args(%[[VAL_28:.*]] = %[[VAL_25]]) -> (index) { // CHECK: %[[VAL_26:.*]] = scf.for %[[VAL_27:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] iter_args(%[[VAL_28:.*]] = %[[VAL_25]]) -> (index) {
// CHECK: %[[VAL_29:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_21]], %[[VAL_27]]] : memref<8x8xf64> // CHECK: %[[VAL_29:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_21]], %[[VAL_27]]] : memref<8x8xf64>
// CHECK: %[[VAL_30:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_19]]] : memref<?xindex> // CHECK: %[[VAL_30:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_19]]] : memref<?xindex>
// CHECK: %[[VAL_31:.*]] = arith.addi %[[VAL_19]], %[[VAL_5]] : index // CHECK: %[[VAL_31:.*]] = arith.addi %[[VAL_19]], %[[VAL_5]] : index
// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_31]]] : memref<?xindex> // CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_31]]] : memref<?xindex>
// CHECK: %[[VAL_33:.*]] = scf.for %[[VAL_34:.*]] = %[[VAL_30]] to %[[VAL_32]] step %[[VAL_5]] iter_args(%[[VAL_35:.*]] = %[[VAL_28]]) -> (index) { // CHECK: %[[VAL_33:.*]] = scf.for %[[VAL_34:.*]] = %[[VAL_30]] to %[[VAL_32]] step %[[VAL_5]] iter_args(%[[VAL_35:.*]] = %[[VAL_28]]) -> (index) {
// CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_34]]] : memref<?xindex> // CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_34]]] : memref<?xindex>
// CHECK: %[[VAL_37:.*]] = memref.load %[[VAL_22]]{{\[}}%[[VAL_36]]] : memref<?xf64> // CHECK: %[[VAL_37:.*]] = memref.load %[[VAL_22]]{{\[}}%[[VAL_36]]] : memref<?xf64>
Show All 12 Lines
// CHECK: } else { // CHECK: } else {
// CHECK: scf.yield %[[VAL_35]] : index // CHECK: scf.yield %[[VAL_35]] : index
// CHECK: } // CHECK: }
// CHECK: memref.store %[[VAL_42]], %[[VAL_22]]{{\[}}%[[VAL_36]]] : memref<?xf64> // CHECK: memref.store %[[VAL_42]], %[[VAL_22]]{{\[}}%[[VAL_36]]] : memref<?xf64>
// CHECK: scf.yield %[[VAL_47:.*]] : index // CHECK: scf.yield %[[VAL_47:.*]] : index
// CHECK: } {"Emitted from" = "linalg.generic"} // CHECK: } {"Emitted from" = "linalg.generic"}
// CHECK: scf.yield %[[VAL_48:.*]] : index // CHECK: scf.yield %[[VAL_48:.*]] : index
// CHECK: } {"Emitted from" = "linalg.generic"} // CHECK: } {"Emitted from" = "linalg.generic"}
// CHECK: %[[VAL_49:.*]] = sparse_tensor.compress %[[VAL_22]], %[[VAL_23]], %[[VAL_24]], %[[VAL_50:.*]] into %[[VAL_20]]{{\[}}%[[VAL_21]]] : memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_49:.*]] = sparse_tensor.compress %[[VAL_22]], %[[VAL_23]], %[[VAL_24]], %[[VAL_50:.*]] into %[[VAL_20]]{{\[}}%[[VAL_21]]] : memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: scf.yield %[[VAL_49]] : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_49]] : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } {"Emitted from" = "linalg.generic"} // CHECK: } {"Emitted from" = "linalg.generic"}
// CHECK: %[[VAL_51:.*]] = sparse_tensor.load %[[VAL_52:.*]] hasInserts : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_51:.*]] = sparse_tensor.load %[[VAL_52:.*]] hasInserts : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: return %[[VAL_51]] : tensor<8x8xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: return %[[VAL_51]] : tensor<8x8xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
func.func @sparse_sampled_dd_unfused(%args: tensor<8x8xf64, #SM>, func.func @sparse_sampled_dd_unfused(%args: tensor<8x8xf64, #SM>,
%arga: tensor<8x8xf64>, %arga: tensor<8x8xf64>,
%argb: tensor<8x8xf64>) -> tensor<8x8xf64, #SM> { %argb: tensor<8x8xf64>) -> tensor<8x8xf64, #SM> {
// Perform dense-dense matrix matrix multiplication. // Perform dense-dense matrix matrix multiplication.
%1 = arith.constant dense<0.0> : tensor<8x8xf64> %1 = arith.constant dense<0.0> : tensor<8x8xf64>
%2 = linalg.generic #trait_matmul %2 = linalg.generic #trait_matmul
ins(%arga, %argb : tensor<8x8xf64>, tensor<8x8xf64>) ins(%arga, %argb : tensor<8x8xf64>, tensor<8x8xf64>)
Show All 17 Lines

mlir/test/Dialect/SparseTensor/sparse_storage.mlir

// RUN: mlir-opt %s -sparsification= | FileCheck %s // RUN: mlir-opt %s -sparsification= | FileCheck %s
#SparseVector64 = #sparse_tensor.encoding<{ #SparseVector64 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed" ], lvlTypes = [ "compressed" ],
posWidth = 64, posWidth = 64,
crdWidth = 64 crdWidth = 64
}> }>
#SparseVector32 = #sparse_tensor.encoding<{ #SparseVector32 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed" ], lvlTypes = [ "compressed" ],
posWidth = 32, posWidth = 32,
crdWidth = 32 crdWidth = 32
}> }>
#trait_mul = { #trait_mul = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)>, // b affine_map<(i) -> (i)>, // b
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_transpose.mlir

// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#transpose_trait = { #transpose_trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (j,i)>, // A affine_map<(i,j) -> (j,i)>, // A
affine_map<(i,j) -> (i,j)> // X affine_map<(i,j) -> (i,j)> // X
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
doc = "X(i,j) = A(j,i)" doc = "X(i,j) = A(j,i)"
} }
// TODO: improve auto-conversion followed by yield // TODO: improve auto-conversion followed by yield
// CHECK-LABEL: func.func @sparse_transpose_auto( // CHECK-LABEL: func.func @sparse_transpose_auto(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<3x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) -> tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> { // CHECK-SAME: %[[VAL_0:.*]]: tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) -> tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> {
// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_3:.*]] = bufferization.alloc_tensor() : tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK-DAG: %[[VAL_3:.*]] = bufferization.alloc_tensor() : tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK-DAG: %[[VAL_4:.*]] = sparse_tensor.convert %[[VAL_0]] : tensor<3x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to tensor<3x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> // CHECK-DAG: %[[VAL_4:.*]] = sparse_tensor.convert %[[VAL_0]] : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>
// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_4]] {level = 0 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex> // CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_4]] {level = 0 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_4]] {level = 0 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex> // CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_4]] {level = 0 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_4]] {level = 1 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex> // CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_4]] {level = 1 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_4]] {level = 1 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex> // CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_4]] {level = 1 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_4]] : tensor<3x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xf64> // CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_4]] : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xf64>
// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_1]]] : memref<?xindex> // CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_1]]] : memref<?xindex>
// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK: %[[VAL_12:.*]] = scf.for %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_14:.*]] = %[[VAL_3]]) -> (tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_12:.*]] = scf.for %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_14:.*]] = %[[VAL_3]]) -> (tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex>
// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xindex> // CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xindex>
// CHECK: %[[VAL_17:.*]] = arith.addi %[[VAL_13]], %[[VAL_2]] : index // CHECK: %[[VAL_17:.*]] = arith.addi %[[VAL_13]], %[[VAL_2]] : index
// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_17]]] : memref<?xindex> // CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_17]]] : memref<?xindex>
// CHECK: %[[VAL_19:.*]] = scf.for %[[VAL_20:.*]] = %[[VAL_16]] to %[[VAL_18]] step %[[VAL_2]] iter_args(%[[VAL_21:.*]] = %[[VAL_14]]) -> (tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) { // CHECK: %[[VAL_19:.*]] = scf.for %[[VAL_20:.*]] = %[[VAL_16]] to %[[VAL_18]] step %[[VAL_2]] iter_args(%[[VAL_21:.*]] = %[[VAL_14]]) -> (tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_20]]] : memref<?xindex> // CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_20]]] : memref<?xindex>
// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_20]]] : memref<?xf64> // CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_20]]] : memref<?xf64>
// CHECK: %[[VAL_24:.*]] = sparse_tensor.insert %[[VAL_23]] into %[[VAL_21]]{{\[}}%[[VAL_15]], %[[VAL_22]]] : tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_24:.*]] = sparse_tensor.insert %[[VAL_23]] into %[[VAL_21]]{{\[}}%[[VAL_15]], %[[VAL_22]]] : tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: scf.yield %[[VAL_24]] : tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_24]] : tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: scf.yield %[[VAL_25:.*]] : tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: scf.yield %[[VAL_25:.*]] : tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: } // CHECK: }
// CHECK: %[[VAL_26:.*]] = sparse_tensor.load %[[VAL_27:.*]] hasInserts : tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: %[[VAL_26:.*]] = sparse_tensor.load %[[VAL_27:.*]] hasInserts : tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// CHECK: bufferization.dealloc_tensor %[[VAL_4]] : tensor<3x4xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> // CHECK: bufferization.dealloc_tensor %[[VAL_4]] : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>
// CHECK: return %[[VAL_26]] : tensor<4x3xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> // CHECK: return %[[VAL_26]] : tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
// 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/Dialect/SparseTensor/sparse_vector.mlir

// RUN: mlir-opt %s -sparsification -cse -split-input-file | \ // RUN: mlir-opt %s -sparsification -cse -split-input-file | \
// RUN: FileCheck %s --check-prefix=CHECK-SCALAR // RUN: FileCheck %s --check-prefix=CHECK-SCALAR
// RUN: mlir-opt %s -sparsification -cse -sparse-vectorization="vl=16" -cse -split-input-file | \ // RUN: mlir-opt %s -sparsification -cse -sparse-vectorization="vl=16" -cse -split-input-file | \
// RUN: FileCheck %s --check-prefix=CHECK-VEC16 // RUN: FileCheck %s --check-prefix=CHECK-VEC16
// RUN: mlir-opt %s -sparsification -cse -sparse-vectorization="vl=16 enable-simd-index32=true" -cse -split-input-file | \ // RUN: mlir-opt %s -sparsification -cse -sparse-vectorization="vl=16 enable-simd-index32=true" -cse -split-input-file | \
// RUN: FileCheck %s --check-prefix=CHECK-VEC16-IDX32 // RUN: FileCheck %s --check-prefix=CHECK-VEC16-IDX32
// RUN: mlir-opt %s -sparsification -cse -sparse-vectorization="vl=4 enable-vla-vectorization=true" -cse -split-input-file | \ // RUN: mlir-opt %s -sparsification -cse -sparse-vectorization="vl=4 enable-vla-vectorization=true" -cse -split-input-file | \
// RUN: FileCheck %s --check-prefix=CHECK-VEC4-SVE // RUN: FileCheck %s --check-prefix=CHECK-VEC4-SVE
#DenseVector = #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }> #DenseVector = #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>
#trait_scale_d = { #trait_scale_d = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "x(i) = a(i) * b" doc = "x(i) = a(i) * b"
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines outs(%argx: tensor<1024xf32>) {
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<1024xf32> } -> tensor<1024xf32>
return %0 : tensor<1024xf32> return %0 : tensor<1024xf32>
} }
// ----- // -----
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = [ "compressed" ], lvlTypes = [ "compressed" ],
posWidth = 32, posWidth = 32,
crdWidth = 32 crdWidth = 32
}> }>
#trait_mul_s = { #trait_mul_s = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)>, // b affine_map<(i) -> (i)>, // b
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines outs(%argx: tensor<1024xf32>) {
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<1024xf32> } -> tensor<1024xf32>
return %0 : tensor<1024xf32> return %0 : tensor<1024xf32>
} }
// ----- // -----
#DenseVector = #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }> #DenseVector = #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>
#trait_reduction_d = { #trait_reduction_d = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)>, // b affine_map<(i) -> (i)>, // b
affine_map<(i) -> ()> // x (out) affine_map<(i) -> ()> // x (out)
], ],
iterator_types = ["reduction"], iterator_types = ["reduction"],
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines outs(%argx: tensor<f32>) {
linalg.yield %1 : f32 linalg.yield %1 : f32
} -> tensor<f32> } -> tensor<f32>
return %0 : tensor<f32> return %0 : tensor<f32>
} }
// ----- // -----
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
posWidth = 32, posWidth = 32,
crdWidth = 32 crdWidth = 32
}> }>
#trait_mul_ds = { #trait_mul_ds = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (i,j)>, // B affine_map<(i,j) -> (i,j)>, // B
▲ Show 20 Lines • Show All 122 Lines • ▼ Show 20 Lines outs(%argx: tensor<512x1024xf32>) {
%0 = arith.mulf %a, %b : f32 %0 = arith.mulf %a, %b : f32
linalg.yield %0 : f32 linalg.yield %0 : f32
} -> tensor<512x1024xf32> } -> tensor<512x1024xf32>
return %0 : tensor<512x1024xf32> return %0 : tensor<512x1024xf32>
} }
// ----- // -----
#SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["dense","compressed"]}> #SparseMatrix = #sparse_tensor.encoding<{lvlTypes = ["dense","compressed"]}>
#trait_affine = { #trait_affine = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, affine_map<(i,j) -> (i,j)>,
affine_map<(i,j) -> (i+1,j)> affine_map<(i,j) -> (i+1,j)>
], ],
iterator_types = ["parallel","parallel"], iterator_types = ["parallel","parallel"],
doc = "X(i+1,j) += A(i,j)" doc = "X(i+1,j) += A(i,j)"
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_vector_chain.mlir

// RUN: mlir-opt %s -sparsification -cse -sparse-vectorization="vl=8" -cse | \ // RUN: mlir-opt %s -sparsification -cse -sparse-vectorization="vl=8" -cse | \
// RUN: FileCheck %s // RUN: FileCheck %s
#SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["dense","compressed"]}> #SparseMatrix = #sparse_tensor.encoding<{lvlTypes = ["dense","compressed"]}>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // a (in) affine_map<(i,j) -> (i,j)>, // a (in)
affine_map<(i,j) -> (i,j)>, // b (in) affine_map<(i,j) -> (i,j)>, // b (in)
affine_map<(i,j) -> ()> // x (out) affine_map<(i,j) -> ()> // x (out)
], ],
iterator_types = ["reduction", "reduction"] iterator_types = ["reduction", "reduction"]
} }
// //
// Verifies that the SIMD reductions in the two for-loops after the // Verifies that the SIMD reductions in the two for-loops after the
// while-loop are chained before horizontally reducing these back to scalar. // while-loop are chained before horizontally reducing these back to scalar.
// //
// CHECK-LABEL: func.func @sparse_matrix_sum( // CHECK-LABEL: func.func @sparse_matrix_sum(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<f64>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<f64>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<64x32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<64x32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<64x32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>) -> tensor<f64> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<64x32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>) -> tensor<f64> {
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant dense<0.000000e+00> : vector<8xf64> // CHECK-DAG: %[[VAL_4:.*]] = arith.constant dense<0.000000e+00> : vector<8xf64>
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 64 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 64 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
// CHECK: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<64x32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<64x32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<64x32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 1 : index} : tensor<64x32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<64x32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf64> // CHECK: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<64x32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf64>
// CHECK: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_2]] {level = 1 : index} : tensor<64x32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_11:.*]] = sparse_tensor.positions %[[VAL_2]] {level = 1 : index} : tensor<64x32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_2]] {level = 1 : index} : tensor<64x32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_12:.*]] = sparse_tensor.coordinates %[[VAL_2]] {level = 1 : index} : tensor<64x32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_13:.*]] = sparse_tensor.values %[[VAL_2]] : tensor<64x32xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf64> // CHECK: %[[VAL_13:.*]] = sparse_tensor.values %[[VAL_2]] : tensor<64x32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf64>
// CHECK: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f64> // CHECK: %[[VAL_14:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f64>
// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_14]][] : memref<f64> // CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_14]][] : memref<f64>
// CHECK: %[[VAL_16:.*]] = scf.for %[[VAL_17:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] iter_args(%[[VAL_18:.*]] = %[[VAL_15]]) -> (f64) { // CHECK: %[[VAL_16:.*]] = scf.for %[[VAL_17:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] iter_args(%[[VAL_18:.*]] = %[[VAL_15]]) -> (f64) {
// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_17]]] : memref<?xindex> // CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_17]]] : memref<?xindex>
// CHECK: %[[VAL_20:.*]] = arith.addi %[[VAL_17]], %[[VAL_7]] : index // CHECK: %[[VAL_20:.*]] = arith.addi %[[VAL_17]], %[[VAL_7]] : index
// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_20]]] : memref<?xindex> // CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_20]]] : memref<?xindex>
// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_17]]] : memref<?xindex> // CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_17]]] : memref<?xindex>
// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_20]]] : memref<?xindex> // CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_20]]] : memref<?xindex>
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_vector_concat.mlir

// RUN: mlir-opt %s --sparse-compiler="enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // RUN: mlir-opt %s --sparse-compiler="enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
#MAT_D_C = #sparse_tensor.encoding<{ #MAT_D_C = #sparse_tensor.encoding<{
dimLevelType = ["dense", "compressed"] lvlTypes = ["dense", "compressed"]
}> }>
#MAT_C_C_P = #sparse_tensor.encoding<{ #MAT_C_C_P = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#MAT_C_D_P = #sparse_tensor.encoding<{ #MAT_C_D_P = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense" ], lvlTypes = [ "compressed", "dense" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
// //
// Ensures only last loop is vectorized // Ensures only last loop is vectorized
// (vectorizing the others would crash). // (vectorizing the others would crash).
// //
// CHECK-LABEL: llvm.func @foo // CHECK-LABEL: llvm.func @foo
Show All 10 Lines

mlir/test/Dialect/SparseTensor/sparse_vector_index.mlir

// RUN: mlir-opt %s -sparsification -cse -sparse-vectorization="vl=8" -cse | \ // RUN: mlir-opt %s -sparsification -cse -sparse-vectorization="vl=8" -cse | \
// RUN: FileCheck %s // RUN: FileCheck %s
// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] lvlTypes = ["compressed"]
}> }>
#trait_1d = { #trait_1d = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "X(i) = a(i) op i" doc = "X(i) = a(i) op i"
} }
// CHECK-LABEL: func.func @sparse_index_1d_conj( // CHECK-LABEL: func.func @sparse_index_1d_conj(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<8xi64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<8xi64> { // CHECK-SAME: %[[VAL_0:.*]]: tensor<8xi64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<8xi64> {
// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_1:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant dense<0> : vector<8xi64> // CHECK-DAG: %[[VAL_2:.*]] = arith.constant dense<0> : vector<8xi64>
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant dense<0> : vector<8xindex> // CHECK-DAG: %[[VAL_3:.*]] = arith.constant dense<0> : vector<8xindex>
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : i64 // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : i64
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_7:.*]] = tensor.empty() : tensor<8xi64> // CHECK-DAG: %[[VAL_7:.*]] = tensor.empty() : tensor<8xi64>
// CHECK: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<8xi64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<8xi64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<8xi64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<8xi64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<8xi64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi64> // CHECK: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<8xi64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi64>
// CHECK: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_7]] : memref<8xi64> // CHECK: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_7]] : memref<8xi64>
// CHECK: linalg.fill ins(%[[VAL_4]] : i64) outs(%[[VAL_11]] : memref<8xi64>) // CHECK: linalg.fill ins(%[[VAL_4]] : i64) outs(%[[VAL_11]] : memref<8xi64>)
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_6]]] : memref<?xindex> // CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_6]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_12]] to %[[VAL_13]] step %[[VAL_1]] { // CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_12]] to %[[VAL_13]] step %[[VAL_1]] {
// CHECK: %[[VAL_15:.*]] = affine.min #map(%[[VAL_13]], %[[VAL_14]]){{\[}}%[[VAL_1]]] // CHECK: %[[VAL_15:.*]] = affine.min #map(%[[VAL_13]], %[[VAL_14]]){{\[}}%[[VAL_1]]]
// CHECK: %[[VAL_16:.*]] = vector.create_mask %[[VAL_15]] : vector<8xi1> // CHECK: %[[VAL_16:.*]] = vector.create_mask %[[VAL_15]] : vector<8xi1>
// CHECK: %[[VAL_17:.*]] = vector.maskedload %[[VAL_9]]{{\[}}%[[VAL_14]]], %[[VAL_16]], %[[VAL_3]] : memref<?xindex>, vector<8xi1>, vector<8xindex> into vector<8xindex> // CHECK: %[[VAL_17:.*]] = vector.maskedload %[[VAL_9]]{{\[}}%[[VAL_14]]], %[[VAL_16]], %[[VAL_3]] : memref<?xindex>, vector<8xi1>, vector<8xindex> into vector<8xindex>
Show All 15 Lines outs(%init: tensor<8xi64>) {
%ii = arith.index_cast %i : index to i64 %ii = arith.index_cast %i : index to i64
%m1 = arith.muli %a, %ii : i64 %m1 = arith.muli %a, %ii : i64
linalg.yield %m1 : i64 linalg.yield %m1 : i64
} -> tensor<8xi64> } -> tensor<8xi64>
return %r : tensor<8xi64> return %r : tensor<8xi64>
} }
// CHECK-LABEL: func.func @sparse_index_1d_disj( // CHECK-LABEL: func.func @sparse_index_1d_disj(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<8xi64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<8xi64> { // CHECK-SAME: %[[VAL_0:.*]]: tensor<8xi64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<8xi64> {
// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 8 : index // CHECK-DAG: %[[VAL_1:.*]] = arith.constant 8 : index
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant dense<[0, 1, 2, 3, 4, 5, 6, 7]> : vector<8xindex> // CHECK-DAG: %[[VAL_2:.*]] = arith.constant dense<[0, 1, 2, 3, 4, 5, 6, 7]> : vector<8xindex>
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : i64 // CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : i64
// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-DAG: %[[VAL_6:.*]] = arith.constant true // CHECK-DAG: %[[VAL_6:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_7:.*]] = tensor.empty() : tensor<8xi64> // CHECK-DAG: %[[VAL_7:.*]] = tensor.empty() : tensor<8xi64>
// CHECK: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<8xi64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<8xi64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<8xi64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<8xi64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<8xi64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi64> // CHECK: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<8xi64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi64>
// CHECK: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_7]] : memref<8xi64> // CHECK: %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_7]] : memref<8xi64>
// CHECK: linalg.fill ins(%[[VAL_3]] : i64) outs(%[[VAL_11]] : memref<8xi64>) // CHECK: linalg.fill ins(%[[VAL_3]] : i64) outs(%[[VAL_11]] : memref<8xi64>)
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK: %[[VAL_14:.*]]:2 = scf.while (%[[VAL_15:.*]] = %[[VAL_12]], %[[VAL_16:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) { // CHECK: %[[VAL_14:.*]]:2 = scf.while (%[[VAL_15:.*]] = %[[VAL_12]], %[[VAL_16:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) {
// CHECK: %[[VAL_17:.*]] = arith.cmpi ult, %[[VAL_15]], %[[VAL_13]] : index // CHECK: %[[VAL_17:.*]] = arith.cmpi ult, %[[VAL_15]], %[[VAL_13]] : index
// CHECK: scf.condition(%[[VAL_17]]) %[[VAL_15]], %[[VAL_16]] : index, index // CHECK: scf.condition(%[[VAL_17]]) %[[VAL_15]], %[[VAL_16]] : index, index
// CHECK: } do { // CHECK: } do {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_vector_mv.mlir

// RUN: mlir-opt %s -sparse-compiler="vl=8" | FileCheck %s // RUN: mlir-opt %s -sparse-compiler="vl=8" | FileCheck %s
#Dense = #sparse_tensor.encoding<{ #Dense = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense" ] lvlTypes = [ "dense", "dense" ]
}> }>
#matvec = { #matvec = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (j)>, // b affine_map<(i,j) -> (j)>, // b
affine_map<(i,j) -> (i)> // x (out) affine_map<(i,j) -> (i)> // x (out)
], ],
Show All 19 Lines

mlir/test/Dialect/SparseTensor/sparse_vector_ops.mlir

// RUN: mlir-opt %s -sparsification -cse -sparse-vectorization="vl=8" -cse | \ // RUN: mlir-opt %s -sparsification -cse -sparse-vectorization="vl=8" -cse | \
// RUN: FileCheck %s // RUN: FileCheck %s
#DenseVector = #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }> #DenseVector = #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)>, // b affine_map<(i) -> (i)>, // b
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/sparse_vector_peeled.mlir

// RUN: mlir-opt %s --sparsification -cse -sparse-vectorization="vl=16" -scf-for-loop-peeling -canonicalize -cse | \ // RUN: mlir-opt %s --sparsification -cse -sparse-vectorization="vl=16" -scf-for-loop-peeling -canonicalize -cse | \
// RUN: FileCheck %s // RUN: FileCheck %s
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = [ "compressed" ], lvlTypes = [ "compressed" ],
posWidth = 32, posWidth = 32,
crdWidth = 32 crdWidth = 32
}> }>
#trait_mul_s = { #trait_mul_s = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)>, // b affine_map<(i) -> (i)>, // b
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/specifier_to_llvm.mlir

// RUN: mlir-opt %s -sparse-storage-specifier-to-llvm --cse --canonicalize | FileCheck %s // RUN: mlir-opt %s -sparse-storage-specifier-to-llvm --cse --canonicalize | FileCheck %s
#CSR = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
// CHECK-LABEL: func.func @sparse_metadata_init() -> !llvm.struct<(array<2 x i64>, array<3 x i64>)> { // CHECK-LABEL: func.func @sparse_metadata_init() -> !llvm.struct<(array<2 x i64>, array<3 x i64>)> {
// CHECK: %[[VAL_0:.*]] = arith.constant 0 : i64 // CHECK: %[[VAL_0:.*]] = arith.constant 0 : i64
// CHECK: %[[VAL_1:.*]] = llvm.mlir.undef : !llvm.struct<(array<2 x i64>, array<3 x i64>)> // CHECK: %[[VAL_1:.*]] = llvm.mlir.undef : !llvm.struct<(array<2 x i64>, array<3 x i64>)>
// CHECK: %[[VAL_2:.*]] = llvm.insertvalue %[[VAL_0]], %[[VAL_1]][1, 0] : !llvm.struct<(array<2 x i64>, array<3 x i64>)> // CHECK: %[[VAL_2:.*]] = llvm.insertvalue %[[VAL_0]], %[[VAL_1]][1, 0] : !llvm.struct<(array<2 x i64>, array<3 x i64>)>
// CHECK: %[[VAL_3:.*]] = llvm.insertvalue %[[VAL_0]], %[[VAL_2]][1, 1] : !llvm.struct<(array<2 x i64>, array<3 x i64>)> // CHECK: %[[VAL_3:.*]] = llvm.insertvalue %[[VAL_0]], %[[VAL_2]][1, 1] : !llvm.struct<(array<2 x i64>, array<3 x i64>)>
// CHECK: %[[VAL_4:.*]] = llvm.insertvalue %[[VAL_0]], %[[VAL_3]][1, 2] : !llvm.struct<(array<2 x i64>, array<3 x i64>)> // CHECK: %[[VAL_4:.*]] = llvm.insertvalue %[[VAL_0]], %[[VAL_3]][1, 2] : !llvm.struct<(array<2 x i64>, array<3 x i64>)>
// CHECK: return %[[VAL_4]] : !llvm.struct<(array<2 x i64>, array<3 x i64>)> // CHECK: return %[[VAL_4]] : !llvm.struct<(array<2 x i64>, array<3 x i64>)>
Show All 29 Lines

mlir/test/Dialect/SparseTensor/vectorize_reduction.mlir

Show All 22 Lines
// With vectorization off: // With vectorization off:
// dense scf.for // dense scf.for
// sparse scf.for // sparse scf.for
// mul in accumulator // mul in accumulator
// final store // final store
// //
// CHECK-ON-LABEL: func.func @sparse_product_reduction_dense_sparse( // CHECK-ON-LABEL: func.func @sparse_product_reduction_dense_sparse(
// CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<f64>, // CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<f64>,
// CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>) -> tensor<f64> { // CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>) -> tensor<f64> {
// CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index // CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index
// CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<1.000000e+00> : vector<8xf64> // CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<1.000000e+00> : vector<8xf64>
// CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant dense<0.000000e+00> : vector<8xf64> // CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant dense<0.000000e+00> : vector<8xf64>
// CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-ON-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-ON-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-ON-DAG: %[[VAL_7:.*]] = tensor.dim %[[VAL_1]], %[[VAL_5]] : tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> // CHECK-ON-DAG: %[[VAL_7:.*]] = tensor.dim %[[VAL_1]], %[[VAL_5]] : tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>
// CHECK-ON: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-ON: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-ON: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf64> // CHECK-ON: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf64>
// CHECK-ON: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f64> // CHECK-ON: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f64>
// CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_10]][] : memref<f64> // CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_10]][] : memref<f64>
// CHECK-ON: %[[VAL_12:.*]] = scf.for %[[VAL_13:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_6]] iter_args(%[[VAL_14:.*]] = %[[VAL_11]]) -> (f64) { // CHECK-ON: %[[VAL_12:.*]] = scf.for %[[VAL_13:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_6]] iter_args(%[[VAL_14:.*]] = %[[VAL_11]]) -> (f64) {
// CHECK-ON: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_13]]] : memref<?xindex> // CHECK-ON: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_13]]] : memref<?xindex>
// CHECK-ON: %[[VAL_16:.*]] = arith.addi %[[VAL_13]], %[[VAL_6]] : index // CHECK-ON: %[[VAL_16:.*]] = arith.addi %[[VAL_13]], %[[VAL_6]] : index
// CHECK-ON: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xindex> // CHECK-ON: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xindex>
// CHECK-ON: %[[VAL_18:.*]] = vector.insertelement %[[VAL_14]], %[[VAL_3]]{{\[}}%[[VAL_5]] : index] : vector<8xf64> // CHECK-ON: %[[VAL_18:.*]] = vector.insertelement %[[VAL_14]], %[[VAL_3]]{{\[}}%[[VAL_5]] : index] : vector<8xf64>
// CHECK-ON: %[[VAL_19:.*]] = scf.for %[[VAL_20:.*]] = %[[VAL_15]] to %[[VAL_17]] step %[[VAL_2]] iter_args(%[[VAL_21:.*]] = %[[VAL_18]]) -> (vector<8xf64>) { // CHECK-ON: %[[VAL_19:.*]] = scf.for %[[VAL_20:.*]] = %[[VAL_15]] to %[[VAL_17]] step %[[VAL_2]] iter_args(%[[VAL_21:.*]] = %[[VAL_18]]) -> (vector<8xf64>) {
Show All 9 Lines
// CHECK-ON: } {"Emitted from" = "linalg.generic"} // CHECK-ON: } {"Emitted from" = "linalg.generic"}
// CHECK-ON: memref.store %[[VAL_29:.*]], %[[VAL_10]][] : memref<f64> // CHECK-ON: memref.store %[[VAL_29:.*]], %[[VAL_10]][] : memref<f64>
// CHECK-ON: %[[VAL_30:.*]] = bufferization.to_tensor %[[VAL_10]] : memref<f64> // CHECK-ON: %[[VAL_30:.*]] = bufferization.to_tensor %[[VAL_10]] : memref<f64>
// CHECK-ON: return %[[VAL_30]] : tensor<f64> // CHECK-ON: return %[[VAL_30]] : tensor<f64>
// CHECK-ON: } // CHECK-ON: }
// //
// CHECK-OFF-LABEL: func.func @sparse_product_reduction_dense_sparse( // CHECK-OFF-LABEL: func.func @sparse_product_reduction_dense_sparse(
// CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<f64>, // CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<f64>,
// CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>>) -> tensor<f64> { // CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>) -> tensor<f64> {
// CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-OFF: %[[VAL_4:.*]] = tensor.dim %[[VAL_1]], %[[VAL_2]] : tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> // CHECK-OFF: %[[VAL_4:.*]] = tensor.dim %[[VAL_1]], %[[VAL_2]] : tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>>
// CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xindex> // CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xindex>
// CHECK-OFF: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> to memref<?xf64> // CHECK-OFF: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> to memref<?xf64>
// CHECK-OFF: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f64> // CHECK-OFF: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f64>
// CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_7]][] : memref<f64> // CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_7]][] : memref<f64>
// CHECK-OFF: %[[VAL_9:.*]] = scf.for %[[VAL_10:.*]] = %[[VAL_2]] to %[[VAL_4]] step %[[VAL_3]] iter_args(%[[VAL_11:.*]] = %[[VAL_8]]) -> (f64) { // CHECK-OFF: %[[VAL_9:.*]] = scf.for %[[VAL_10:.*]] = %[[VAL_2]] to %[[VAL_4]] step %[[VAL_3]] iter_args(%[[VAL_11:.*]] = %[[VAL_8]]) -> (f64) {
// CHECK-OFF: %[[VAL_12:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_10]]] : memref<?xindex> // CHECK-OFF: %[[VAL_12:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_10]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_13:.*]] = arith.addi %[[VAL_10]], %[[VAL_3]] : index // CHECK-OFF: %[[VAL_13:.*]] = arith.addi %[[VAL_10]], %[[VAL_3]] : index
// CHECK-OFF: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_13]]] : memref<?xindex> // CHECK-OFF: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_13]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_15:.*]] = scf.for %[[VAL_16:.*]] = %[[VAL_12]] to %[[VAL_14]] step %[[VAL_3]] iter_args(%[[VAL_17:.*]] = %[[VAL_11]]) -> (f64) { // CHECK-OFF: %[[VAL_15:.*]] = scf.for %[[VAL_16:.*]] = %[[VAL_12]] to %[[VAL_14]] step %[[VAL_3]] iter_args(%[[VAL_17:.*]] = %[[VAL_11]]) -> (f64) {
// CHECK-OFF: %[[VAL_18:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_16]]] : memref<?xf64> // CHECK-OFF: %[[VAL_18:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_16]]] : memref<?xf64>
// CHECK-OFF: %[[VAL_19:.*]] = arith.mulf %[[VAL_17]], %[[VAL_18]] : f64 // CHECK-OFF: %[[VAL_19:.*]] = arith.mulf %[[VAL_17]], %[[VAL_18]] : f64
// CHECK-OFF: scf.yield %[[VAL_19]] : f64 // CHECK-OFF: scf.yield %[[VAL_19]] : f64
// CHECK-OFF: } {"Emitted from" = "linalg.generic"} // CHECK-OFF: } {"Emitted from" = "linalg.generic"}
// CHECK-OFF: scf.yield %[[VAL_20:.*]] : f64 // CHECK-OFF: scf.yield %[[VAL_20:.*]] : f64
// CHECK-OFF: } {"Emitted from" = "linalg.generic"} // CHECK-OFF: } {"Emitted from" = "linalg.generic"}
// CHECK-OFF: memref.store %[[VAL_21:.*]], %[[VAL_7]][] : memref<f64> // CHECK-OFF: memref.store %[[VAL_21:.*]], %[[VAL_7]][] : memref<f64>
// CHECK-OFF: %[[VAL_22:.*]] = bufferization.to_tensor %[[VAL_7]] : memref<f64> // CHECK-OFF: %[[VAL_22:.*]] = bufferization.to_tensor %[[VAL_7]] : memref<f64>
// CHECK-OFF: return %[[VAL_22]] : tensor<f64> // CHECK-OFF: return %[[VAL_22]] : tensor<f64>
// CHECK-OFF: } // CHECK-OFF: }
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["dense","compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["dense","compressed"]}>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // a (in) affine_map<(i,j) -> (i,j)>, // a (in)
affine_map<(i,j) -> ()> // x (out) affine_map<(i,j) -> ()> // x (out)
], ],
iterator_types = ["reduction", "reduction"] iterator_types = ["reduction", "reduction"]
} }
Show All 12 Lines
} }
// ----- // -----
// Same as sparse_product_reduction_dense_sparse but with the outer loop being sparse. // Same as sparse_product_reduction_dense_sparse but with the outer loop being sparse.
// //
// CHECK-ON-LABEL: func.func @sparse_product_reduction_sparse_sparse( // CHECK-ON-LABEL: func.func @sparse_product_reduction_sparse_sparse(
// CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<f64>, // CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<f64>,
// CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) -> tensor<f64> { // CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) -> tensor<f64> {
// CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index // CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index
// CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<1.000000e+00> : vector<8xf64> // CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<1.000000e+00> : vector<8xf64>
// CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant dense<0.000000e+00> : vector<8xf64> // CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant dense<0.000000e+00> : vector<8xf64>
// CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 0 : index // CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 0 : index
// CHECK-ON-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-ON-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-ON: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-ON: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-ON: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf64> // CHECK-ON: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf64>
// CHECK-ON: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f64> // CHECK-ON: %[[VAL_10:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f64>
// CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_10]][] : memref<f64> // CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_10]][] : memref<f64>
// CHECK-ON: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-ON: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-ON: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex> // CHECK-ON: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex>
// CHECK-ON: %[[VAL_14:.*]] = scf.for %[[VAL_15:.*]] = %[[VAL_12]] to %[[VAL_13]] step %[[VAL_6]] iter_args(%[[VAL_16:.*]] = %[[VAL_11]]) -> (f64) { // CHECK-ON: %[[VAL_14:.*]] = scf.for %[[VAL_15:.*]] = %[[VAL_12]] to %[[VAL_13]] step %[[VAL_6]] iter_args(%[[VAL_16:.*]] = %[[VAL_11]]) -> (f64) {
// CHECK-ON: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_15]]] : memref<?xindex> // CHECK-ON: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_15]]] : memref<?xindex>
// CHECK-ON: %[[VAL_18:.*]] = arith.addi %[[VAL_15]], %[[VAL_6]] : index // CHECK-ON: %[[VAL_18:.*]] = arith.addi %[[VAL_15]], %[[VAL_6]] : index
// CHECK-ON: %[[VAL_19:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_18]]] : memref<?xindex> // CHECK-ON: %[[VAL_19:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_18]]] : memref<?xindex>
Show All 11 Lines
// CHECK-ON: } {"Emitted from" = "linalg.generic"} // CHECK-ON: } {"Emitted from" = "linalg.generic"}
// CHECK-ON: memref.store %[[VAL_31:.*]], %[[VAL_10]][] : memref<f64> // CHECK-ON: memref.store %[[VAL_31:.*]], %[[VAL_10]][] : memref<f64>
// CHECK-ON: %[[VAL_32:.*]] = bufferization.to_tensor %[[VAL_10]] : memref<f64> // CHECK-ON: %[[VAL_32:.*]] = bufferization.to_tensor %[[VAL_10]] : memref<f64>
// CHECK-ON: return %[[VAL_32]] : tensor<f64> // CHECK-ON: return %[[VAL_32]] : tensor<f64>
// CHECK-ON: } // CHECK-ON: }
// //
// CHECK-OFF-LABEL: func.func @sparse_product_reduction_sparse_sparse( // CHECK-OFF-LABEL: func.func @sparse_product_reduction_sparse_sparse(
// CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<f64>, // CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<f64>,
// CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>>) -> tensor<f64> { // CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) -> tensor<f64> {
// CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xindex> // CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 1 : index} : tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xindex>
// CHECK-OFF: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x128xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }>> to memref<?xf64> // CHECK-OFF: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x128xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to memref<?xf64>
// CHECK-OFF: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f64> // CHECK-OFF: %[[VAL_7:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f64>
// CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_7]][] : memref<f64> // CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_7]][] : memref<f64>
// CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_10:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-OFF: %[[VAL_10:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_11:.*]] = scf.for %[[VAL_12:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_3]] iter_args(%[[VAL_13:.*]] = %[[VAL_8]]) -> (f64) { // CHECK-OFF: %[[VAL_11:.*]] = scf.for %[[VAL_12:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_3]] iter_args(%[[VAL_13:.*]] = %[[VAL_8]]) -> (f64) {
// CHECK-OFF: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xindex> // CHECK-OFF: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_15:.*]] = arith.addi %[[VAL_12]], %[[VAL_3]] : index // CHECK-OFF: %[[VAL_15:.*]] = arith.addi %[[VAL_12]], %[[VAL_3]] : index
// CHECK-OFF: %[[VAL_16:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_15]]] : memref<?xindex> // CHECK-OFF: %[[VAL_16:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_15]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_17:.*]] = scf.for %[[VAL_18:.*]] = %[[VAL_14]] to %[[VAL_16]] step %[[VAL_3]] iter_args(%[[VAL_19:.*]] = %[[VAL_13]]) -> (f64) { // CHECK-OFF: %[[VAL_17:.*]] = scf.for %[[VAL_18:.*]] = %[[VAL_14]] to %[[VAL_16]] step %[[VAL_3]] iter_args(%[[VAL_19:.*]] = %[[VAL_13]]) -> (f64) {
// CHECK-OFF: %[[VAL_20:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_18]]] : memref<?xf64> // CHECK-OFF: %[[VAL_20:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_18]]] : memref<?xf64>
// CHECK-OFF: %[[VAL_21:.*]] = arith.mulf %[[VAL_19]], %[[VAL_20]] : f64 // CHECK-OFF: %[[VAL_21:.*]] = arith.mulf %[[VAL_19]], %[[VAL_20]] : f64
// CHECK-OFF: scf.yield %[[VAL_21]] : f64 // CHECK-OFF: scf.yield %[[VAL_21]] : f64
// CHECK-OFF: } {"Emitted from" = "linalg.generic"} // CHECK-OFF: } {"Emitted from" = "linalg.generic"}
// CHECK-OFF: scf.yield %[[VAL_22:.*]] : f64 // CHECK-OFF: scf.yield %[[VAL_22:.*]] : f64
// CHECK-OFF: } {"Emitted from" = "linalg.generic"} // CHECK-OFF: } {"Emitted from" = "linalg.generic"}
// CHECK-OFF: memref.store %[[VAL_23:.*]], %[[VAL_7]][] : memref<f64> // CHECK-OFF: memref.store %[[VAL_23:.*]], %[[VAL_7]][] : memref<f64>
// CHECK-OFF: %[[VAL_24:.*]] = bufferization.to_tensor %[[VAL_7]] : memref<f64> // CHECK-OFF: %[[VAL_24:.*]] = bufferization.to_tensor %[[VAL_7]] : memref<f64>
// CHECK-OFF: return %[[VAL_24]] : tensor<f64> // CHECK-OFF: return %[[VAL_24]] : tensor<f64>
// CHECK-OFF: } // CHECK-OFF: }
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed","compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed","compressed"]}>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // a (in) affine_map<(i,j) -> (i,j)>, // a (in)
affine_map<(i,j) -> ()> // x (out) affine_map<(i,j) -> ()> // x (out)
], ],
iterator_types = ["reduction", "reduction"] iterator_types = ["reduction", "reduction"]
} }
Show All 18 Lines
// doesn't matter for vectorization. // doesn't matter for vectorization.
// As a result from this point forward, use tensors with fewer dimensions. // As a result from this point forward, use tensors with fewer dimensions.
// Check that we vectorize reductions with ori. // Check that we vectorize reductions with ori.
// Note: The weird element type here is to check that we create the right // Note: The weird element type here is to check that we create the right
// constant type for the pass-through value. // constant type for the pass-through value.
// CHECK-ON-LABEL: func.func @sparse_reduction_ori( // CHECK-ON-LABEL: func.func @sparse_reduction_ori(
// CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i13>, // CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i13>,
// CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi13, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i13> { // CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi13, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i13> {
// CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index // CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index
// CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0> : vector<8xi13> // CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0> : vector<8xi13>
// CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi13, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi13, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi13, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi13> // CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi13, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi13>
// CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i13> // CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i13>
// CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<i13> // CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<i13>
// CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-ON: %[[VAL_12:.*]] = vector.broadcast %[[VAL_9]] : i13 to vector<8xi13> // CHECK-ON: %[[VAL_12:.*]] = vector.broadcast %[[VAL_9]] : i13 to vector<8xi13>
// CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xi13>) { // CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xi13>) {
// CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]] // CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]]
// CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1> // CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1>
// CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xi13>, vector<8xi1>, vector<8xi13> into vector<8xi13> // CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xi13>, vector<8xi1>, vector<8xi13> into vector<8xi13>
// CHECK-ON: %[[VAL_19:.*]] = arith.ori %[[VAL_15]], %[[VAL_18]] : vector<8xi13> // CHECK-ON: %[[VAL_19:.*]] = arith.ori %[[VAL_15]], %[[VAL_18]] : vector<8xi13>
// CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xi13> // CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xi13>
// CHECK-ON: scf.yield %[[VAL_20]] : vector<8xi13> // CHECK-ON: scf.yield %[[VAL_20]] : vector<8xi13>
// CHECK-ON: } {"Emitted from" = "linalg.generic"} // CHECK-ON: } {"Emitted from" = "linalg.generic"}
// CHECK-ON: %[[VAL_21:.*]] = vector.reduction <or>, %[[VAL_22:.*]] : vector<8xi13> into i13 // CHECK-ON: %[[VAL_21:.*]] = vector.reduction <or>, %[[VAL_22:.*]] : vector<8xi13> into i13
// CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<i13> // CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<i13>
// CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<i13> // CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<i13>
// CHECK-ON: return %[[VAL_23]] : tensor<i13> // CHECK-ON: return %[[VAL_23]] : tensor<i13>
// CHECK-ON: } // CHECK-ON: }
// //
// CHECK-OFF-LABEL: func.func @sparse_reduction_ori( // CHECK-OFF-LABEL: func.func @sparse_reduction_ori(
// CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i13>, // CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i13>,
// CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi13, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i13> { // CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi13, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i13> {
// CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi13, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi13, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi13, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi13> // CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi13, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi13>
// CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i13> // CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i13>
// CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i13> // CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i13>
// CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i13) { // CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i13) {
// CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi13> // CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi13>
// CHECK-OFF: %[[VAL_14:.*]] = arith.ori %[[VAL_12]], %[[VAL_13]] : i13 // CHECK-OFF: %[[VAL_14:.*]] = arith.ori %[[VAL_12]], %[[VAL_13]] : i13
// CHECK-OFF: scf.yield %[[VAL_14]] : i13 // CHECK-OFF: scf.yield %[[VAL_14]] : i13
// CHECK-OFF: } {"Emitted from" = "linalg.generic"} // CHECK-OFF: } {"Emitted from" = "linalg.generic"}
// CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i13> // CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i13>
// CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i13> // CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i13>
// CHECK-OFF: return %[[VAL_16]] : tensor<i13> // CHECK-OFF: return %[[VAL_16]] : tensor<i13>
// CHECK-OFF: } // CHECK-OFF: }
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> ()> // x (out) affine_map<(i) -> ()> // x (out)
], ],
iterator_types = ["reduction"] iterator_types = ["reduction"]
} }
Show All 15 Lines
// Same test as sparse_reduction_ori except that the accumulator is on the // Same test as sparse_reduction_ori except that the accumulator is on the
// rhs of the operation. // rhs of the operation.
// This checks that we can recognize a reduction irrespective to where the // This checks that we can recognize a reduction irrespective to where the
// accumalator appears on commutative operations. // accumalator appears on commutative operations.
// CHECK-ON-LABEL: func.func @sparse_reduction_ori_accumulator_on_rhs( // CHECK-ON-LABEL: func.func @sparse_reduction_ori_accumulator_on_rhs(
// CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i13>, // CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i13>,
// CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi13, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i13> { // CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi13, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i13> {
// CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index // CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index
// CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0> : vector<8xi13> // CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0> : vector<8xi13>
// CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi13, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi13, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi13, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi13> // CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi13, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi13>
// CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i13> // CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i13>
// CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<i13> // CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<i13>
// CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-ON: %[[VAL_12:.*]] = vector.broadcast %[[VAL_9]] : i13 to vector<8xi13> // CHECK-ON: %[[VAL_12:.*]] = vector.broadcast %[[VAL_9]] : i13 to vector<8xi13>
// CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xi13>) { // CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xi13>) {
// CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]] // CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]]
// CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1> // CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1>
// CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xi13>, vector<8xi1>, vector<8xi13> into vector<8xi13> // CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xi13>, vector<8xi1>, vector<8xi13> into vector<8xi13>
// CHECK-ON: %[[VAL_19:.*]] = arith.ori %[[VAL_18]], %[[VAL_15]] : vector<8xi13> // CHECK-ON: %[[VAL_19:.*]] = arith.ori %[[VAL_18]], %[[VAL_15]] : vector<8xi13>
// CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xi13> // CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xi13>
// CHECK-ON: scf.yield %[[VAL_20]] : vector<8xi13> // CHECK-ON: scf.yield %[[VAL_20]] : vector<8xi13>
// CHECK-ON: } {"Emitted from" = "linalg.generic"} // CHECK-ON: } {"Emitted from" = "linalg.generic"}
// CHECK-ON: %[[VAL_21:.*]] = vector.reduction <or>, %[[VAL_22:.*]] : vector<8xi13> into i13 // CHECK-ON: %[[VAL_21:.*]] = vector.reduction <or>, %[[VAL_22:.*]] : vector<8xi13> into i13
// CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<i13> // CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<i13>
// CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<i13> // CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<i13>
// CHECK-ON: return %[[VAL_23]] : tensor<i13> // CHECK-ON: return %[[VAL_23]] : tensor<i13>
// CHECK-ON: } // CHECK-ON: }
// //
// CHECK-OFF-LABEL: func.func @sparse_reduction_ori_accumulator_on_rhs( // CHECK-OFF-LABEL: func.func @sparse_reduction_ori_accumulator_on_rhs(
// CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i13>, // CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i13>,
// CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi13, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i13> { // CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi13, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i13> {
// CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi13, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi13, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi13, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi13> // CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi13, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi13>
// CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i13> // CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i13>
// CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i13> // CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i13>
// CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i13) { // CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i13) {
// CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi13> // CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi13>
// CHECK-OFF: %[[VAL_14:.*]] = arith.ori %[[VAL_13]], %[[VAL_12]] : i13 // CHECK-OFF: %[[VAL_14:.*]] = arith.ori %[[VAL_13]], %[[VAL_12]] : i13
// CHECK-OFF: scf.yield %[[VAL_14]] : i13 // CHECK-OFF: scf.yield %[[VAL_14]] : i13
// CHECK-OFF: } {"Emitted from" = "linalg.generic"} // CHECK-OFF: } {"Emitted from" = "linalg.generic"}
// CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i13> // CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i13>
// CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i13> // CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i13>
// CHECK-OFF: return %[[VAL_16]] : tensor<i13> // CHECK-OFF: return %[[VAL_16]] : tensor<i13>
// CHECK-OFF: } // CHECK-OFF: }
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> ()> // x (out) affine_map<(i) -> ()> // x (out)
], ],
iterator_types = ["reduction"] iterator_types = ["reduction"]
} }
Show All 12 Lines
} }
// ----- // -----
// Check that we vectorize reduction with subi. // Check that we vectorize reduction with subi.
// //
// CHECK-ON-LABEL: func.func @sparse_reduction_subi( // CHECK-ON-LABEL: func.func @sparse_reduction_subi(
// CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i32>, // CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i32>,
// CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i32> { // CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i32> {
// CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index // CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index
// CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant dense<0> : vector<8xi32> // CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant dense<0> : vector<8xi32>
// CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi32> // CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi32>
// CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32> // CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32>
// CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<i32> // CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<i32>
// CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-ON: %[[VAL_12:.*]] = vector.insertelement %[[VAL_9]], %[[VAL_4]]{{\[}}%[[VAL_3]] : index] : vector<8xi32> // CHECK-ON: %[[VAL_12:.*]] = vector.insertelement %[[VAL_9]], %[[VAL_4]]{{\[}}%[[VAL_3]] : index] : vector<8xi32>
// CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xi32>) { // CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xi32>) {
// CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]] // CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]]
// CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1> // CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1>
// CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_4]] : memref<?xi32>, vector<8xi1>, vector<8xi32> into vector<8xi32> // CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_4]] : memref<?xi32>, vector<8xi1>, vector<8xi32> into vector<8xi32>
// CHECK-ON: %[[VAL_19:.*]] = arith.subi %[[VAL_15]], %[[VAL_18]] : vector<8xi32> // CHECK-ON: %[[VAL_19:.*]] = arith.subi %[[VAL_15]], %[[VAL_18]] : vector<8xi32>
// CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xi32> // CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xi32>
// CHECK-ON: scf.yield %[[VAL_20]] : vector<8xi32> // CHECK-ON: scf.yield %[[VAL_20]] : vector<8xi32>
// CHECK-ON: } {"Emitted from" = "linalg.generic"} // CHECK-ON: } {"Emitted from" = "linalg.generic"}
// CHECK-ON: %[[VAL_21:.*]] = vector.reduction <add>, %[[VAL_22:.*]] : vector<8xi32> into i32 // CHECK-ON: %[[VAL_21:.*]] = vector.reduction <add>, %[[VAL_22:.*]] : vector<8xi32> into i32
// CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<i32> // CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<i32>
// CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<i32> // CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<i32>
// CHECK-ON: return %[[VAL_23]] : tensor<i32> // CHECK-ON: return %[[VAL_23]] : tensor<i32>
// CHECK-ON: } // CHECK-ON: }
// //
// CHECK-OFF-LABEL: func.func @sparse_reduction_subi( // CHECK-OFF-LABEL: func.func @sparse_reduction_subi(
// CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i32>, // CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i32>,
// CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i32> { // CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i32> {
// CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi32> // CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi32>
// CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32> // CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32>
// CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i32> // CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i32>
// CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i32) { // CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i32) {
// CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi32> // CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi32>
// CHECK-OFF: %[[VAL_14:.*]] = arith.subi %[[VAL_12]], %[[VAL_13]] : i32 // CHECK-OFF: %[[VAL_14:.*]] = arith.subi %[[VAL_12]], %[[VAL_13]] : i32
// CHECK-OFF: scf.yield %[[VAL_14]] : i32 // CHECK-OFF: scf.yield %[[VAL_14]] : i32
// CHECK-OFF: } {"Emitted from" = "linalg.generic"} // CHECK-OFF: } {"Emitted from" = "linalg.generic"}
// CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i32> // CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i32>
// CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i32> // CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i32>
// CHECK-OFF: return %[[VAL_16]] : tensor<i32> // CHECK-OFF: return %[[VAL_16]] : tensor<i32>
// CHECK-OFF: } // CHECK-OFF: }
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> ()> // x (out) affine_map<(i) -> ()> // x (out)
], ],
iterator_types = ["reduction"] iterator_types = ["reduction"]
} }
Show All 14 Lines
// ----- // -----
// From this point forward, we essentially have the same test for all // From this point forward, we essentially have the same test for all
// arithmetic operation. This is for a code coverage perspective. // arithmetic operation. This is for a code coverage perspective.
// Check that we vectorize xor. // Check that we vectorize xor.
// CHECK-ON-LABEL: func.func @sparse_reduction_xor( // CHECK-ON-LABEL: func.func @sparse_reduction_xor(
// CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i32>, // CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i32>,
// CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i32> { // CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i32> {
// CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index // CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index
// CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0> : vector<8xi32> // CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0> : vector<8xi32>
// CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi32> // CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi32>
// CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32> // CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32>
// CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<i32> // CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<i32>
// CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-ON: %[[VAL_12:.*]] = vector.insertelement %[[VAL_9]], %[[VAL_3]]{{\[}}%[[VAL_4]] : index] : vector<8xi32> // CHECK-ON: %[[VAL_12:.*]] = vector.insertelement %[[VAL_9]], %[[VAL_3]]{{\[}}%[[VAL_4]] : index] : vector<8xi32>
// CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xi32>) { // CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xi32>) {
// CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]] // CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]]
// CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1> // CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1>
// CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xi32>, vector<8xi1>, vector<8xi32> into vector<8xi32> // CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xi32>, vector<8xi1>, vector<8xi32> into vector<8xi32>
// CHECK-ON: %[[VAL_19:.*]] = arith.xori %[[VAL_15]], %[[VAL_18]] : vector<8xi32> // CHECK-ON: %[[VAL_19:.*]] = arith.xori %[[VAL_15]], %[[VAL_18]] : vector<8xi32>
// CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xi32> // CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xi32>
// CHECK-ON: scf.yield %[[VAL_20]] : vector<8xi32> // CHECK-ON: scf.yield %[[VAL_20]] : vector<8xi32>
// CHECK-ON: } {"Emitted from" = "linalg.generic"} // CHECK-ON: } {"Emitted from" = "linalg.generic"}
// CHECK-ON: %[[VAL_21:.*]] = vector.reduction <xor>, %[[VAL_22:.*]] : vector<8xi32> into i32 // CHECK-ON: %[[VAL_21:.*]] = vector.reduction <xor>, %[[VAL_22:.*]] : vector<8xi32> into i32
// CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<i32> // CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<i32>
// CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<i32> // CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<i32>
// CHECK-ON: return %[[VAL_23]] : tensor<i32> // CHECK-ON: return %[[VAL_23]] : tensor<i32>
// CHECK-ON: } // CHECK-ON: }
// //
// CHECK-OFF-LABEL: func.func @sparse_reduction_xor( // CHECK-OFF-LABEL: func.func @sparse_reduction_xor(
// CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i32>, // CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i32>,
// CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i32> { // CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i32> {
// CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi32> // CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi32>
// CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32> // CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32>
// CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i32> // CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i32>
// CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i32) { // CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i32) {
// CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi32> // CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi32>
// CHECK-OFF: %[[VAL_14:.*]] = arith.xori %[[VAL_12]], %[[VAL_13]] : i32 // CHECK-OFF: %[[VAL_14:.*]] = arith.xori %[[VAL_12]], %[[VAL_13]] : i32
// CHECK-OFF: scf.yield %[[VAL_14]] : i32 // CHECK-OFF: scf.yield %[[VAL_14]] : i32
// CHECK-OFF: } {"Emitted from" = "linalg.generic"} // CHECK-OFF: } {"Emitted from" = "linalg.generic"}
// CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i32> // CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i32>
// CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i32> // CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i32>
// CHECK-OFF: return %[[VAL_16]] : tensor<i32> // CHECK-OFF: return %[[VAL_16]] : tensor<i32>
// CHECK-OFF: } // CHECK-OFF: }
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> ()> // x (out) affine_map<(i) -> ()> // x (out)
], ],
iterator_types = ["reduction"] iterator_types = ["reduction"]
} }
Show All 10 Lines -> tensor<i32> {
} -> tensor<i32> } -> tensor<i32>
return %0 : tensor<i32> return %0 : tensor<i32>
} }
// ----- // -----
// Check that we vectorize and. // Check that we vectorize and.
// CHECK-ON-LABEL: func.func @sparse_reduction_and( // CHECK-ON-LABEL: func.func @sparse_reduction_and(
// CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i32>, // CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i32>,
// CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i32> { // CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i32> {
// CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index // CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index
// CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0> : vector<8xi32> // CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0> : vector<8xi32>
// CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi32> // CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi32>
// CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32> // CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32>
// CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<i32> // CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<i32>
// CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-ON: %[[VAL_12:.*]] = vector.broadcast %[[VAL_9]] : i32 to vector<8xi32> // CHECK-ON: %[[VAL_12:.*]] = vector.broadcast %[[VAL_9]] : i32 to vector<8xi32>
// CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xi32>) { // CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xi32>) {
// CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]] // CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]]
// CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1> // CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1>
// CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xi32>, vector<8xi1>, vector<8xi32> into vector<8xi32> // CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xi32>, vector<8xi1>, vector<8xi32> into vector<8xi32>
// CHECK-ON: %[[VAL_19:.*]] = arith.andi %[[VAL_15]], %[[VAL_18]] : vector<8xi32> // CHECK-ON: %[[VAL_19:.*]] = arith.andi %[[VAL_15]], %[[VAL_18]] : vector<8xi32>
// CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xi32> // CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xi32>
// CHECK-ON: scf.yield %[[VAL_20]] : vector<8xi32> // CHECK-ON: scf.yield %[[VAL_20]] : vector<8xi32>
// CHECK-ON: } {"Emitted from" = "linalg.generic"} // CHECK-ON: } {"Emitted from" = "linalg.generic"}
// CHECK-ON: %[[VAL_21:.*]] = vector.reduction <and>, %[[VAL_22:.*]] : vector<8xi32> into i32 // CHECK-ON: %[[VAL_21:.*]] = vector.reduction <and>, %[[VAL_22:.*]] : vector<8xi32> into i32
// CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<i32> // CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<i32>
// CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<i32> // CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<i32>
// CHECK-ON: return %[[VAL_23]] : tensor<i32> // CHECK-ON: return %[[VAL_23]] : tensor<i32>
// CHECK-ON: } // CHECK-ON: }
// //
// CHECK-OFF-LABEL: func.func @sparse_reduction_and( // CHECK-OFF-LABEL: func.func @sparse_reduction_and(
// CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i32>, // CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i32>,
// CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i32> { // CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i32> {
// CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi32> // CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi32>
// CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32> // CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32>
// CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i32> // CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i32>
// CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i32) { // CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i32) {
// CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi32> // CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi32>
// CHECK-OFF: %[[VAL_14:.*]] = arith.andi %[[VAL_12]], %[[VAL_13]] : i32 // CHECK-OFF: %[[VAL_14:.*]] = arith.andi %[[VAL_12]], %[[VAL_13]] : i32
// CHECK-OFF: scf.yield %[[VAL_14]] : i32 // CHECK-OFF: scf.yield %[[VAL_14]] : i32
// CHECK-OFF: } {"Emitted from" = "linalg.generic"} // CHECK-OFF: } {"Emitted from" = "linalg.generic"}
// CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i32> // CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i32>
// CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i32> // CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i32>
// CHECK-OFF: return %[[VAL_16]] : tensor<i32> // CHECK-OFF: return %[[VAL_16]] : tensor<i32>
// CHECK-OFF: } // CHECK-OFF: }
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> ()> // x (out) affine_map<(i) -> ()> // x (out)
], ],
iterator_types = ["reduction"] iterator_types = ["reduction"]
} }
Show All 10 Lines -> tensor<i32> {
} -> tensor<i32> } -> tensor<i32>
return %0 : tensor<i32> return %0 : tensor<i32>
} }
// ----- // -----
// Check that we vectorize muli. // Check that we vectorize muli.
// CHECK-ON-LABEL: func.func @sparse_reduction_muli( // CHECK-ON-LABEL: func.func @sparse_reduction_muli(
// CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i32>, // CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i32>,
// CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i32> { // CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i32> {
// CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index // CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index
// CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<1> : vector<8xi32> // CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<1> : vector<8xi32>
// CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant dense<0> : vector<8xi32> // CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant dense<0> : vector<8xi32>
// CHECK-ON-DAG: %[[VAL_6:.*]] = arith.constant 1 : index // CHECK-ON-DAG: %[[VAL_6:.*]] = arith.constant 1 : index
// CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-ON: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi32> // CHECK-ON: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi32>
// CHECK-ON: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32> // CHECK-ON: %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32>
// CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_9]][] : memref<i32> // CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_9]][] : memref<i32>
// CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-ON: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex> // CHECK-ON: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex>
// CHECK-ON: %[[VAL_13:.*]] = vector.insertelement %[[VAL_10]], %[[VAL_3]]{{\[}}%[[VAL_4]] : index] : vector<8xi32> // CHECK-ON: %[[VAL_13:.*]] = vector.insertelement %[[VAL_10]], %[[VAL_3]]{{\[}}%[[VAL_4]] : index] : vector<8xi32>
// CHECK-ON: %[[VAL_14:.*]] = scf.for %[[VAL_15:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_2]] iter_args(%[[VAL_16:.*]] = %[[VAL_13]]) -> (vector<8xi32>) { // CHECK-ON: %[[VAL_14:.*]] = scf.for %[[VAL_15:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_2]] iter_args(%[[VAL_16:.*]] = %[[VAL_13]]) -> (vector<8xi32>) {
// CHECK-ON: %[[VAL_17:.*]] = affine.min #map(%[[VAL_12]], %[[VAL_15]]){{\[}}%[[VAL_2]]] // CHECK-ON: %[[VAL_17:.*]] = affine.min #map(%[[VAL_12]], %[[VAL_15]]){{\[}}%[[VAL_2]]]
// CHECK-ON: %[[VAL_18:.*]] = vector.create_mask %[[VAL_17]] : vector<8xi1> // CHECK-ON: %[[VAL_18:.*]] = vector.create_mask %[[VAL_17]] : vector<8xi1>
// CHECK-ON: %[[VAL_19:.*]] = vector.maskedload %[[VAL_8]]{{\[}}%[[VAL_15]]], %[[VAL_18]], %[[VAL_5]] : memref<?xi32>, vector<8xi1>, vector<8xi32> into vector<8xi32> // CHECK-ON: %[[VAL_19:.*]] = vector.maskedload %[[VAL_8]]{{\[}}%[[VAL_15]]], %[[VAL_18]], %[[VAL_5]] : memref<?xi32>, vector<8xi1>, vector<8xi32> into vector<8xi32>
// CHECK-ON: %[[VAL_20:.*]] = arith.muli %[[VAL_16]], %[[VAL_19]] : vector<8xi32> // CHECK-ON: %[[VAL_20:.*]] = arith.muli %[[VAL_16]], %[[VAL_19]] : vector<8xi32>
// CHECK-ON: %[[VAL_21:.*]] = arith.select %[[VAL_18]], %[[VAL_20]], %[[VAL_16]] : vector<8xi1>, vector<8xi32> // CHECK-ON: %[[VAL_21:.*]] = arith.select %[[VAL_18]], %[[VAL_20]], %[[VAL_16]] : vector<8xi1>, vector<8xi32>
// CHECK-ON: scf.yield %[[VAL_21]] : vector<8xi32> // CHECK-ON: scf.yield %[[VAL_21]] : vector<8xi32>
// CHECK-ON: } {"Emitted from" = "linalg.generic"} // CHECK-ON: } {"Emitted from" = "linalg.generic"}
// CHECK-ON: %[[VAL_22:.*]] = vector.reduction <mul>, %[[VAL_23:.*]] : vector<8xi32> into i32 // CHECK-ON: %[[VAL_22:.*]] = vector.reduction <mul>, %[[VAL_23:.*]] : vector<8xi32> into i32
// CHECK-ON: memref.store %[[VAL_22]], %[[VAL_9]][] : memref<i32> // CHECK-ON: memref.store %[[VAL_22]], %[[VAL_9]][] : memref<i32>
// CHECK-ON: %[[VAL_24:.*]] = bufferization.to_tensor %[[VAL_9]] : memref<i32> // CHECK-ON: %[[VAL_24:.*]] = bufferization.to_tensor %[[VAL_9]] : memref<i32>
// CHECK-ON: return %[[VAL_24]] : tensor<i32> // CHECK-ON: return %[[VAL_24]] : tensor<i32>
// CHECK-ON: } // CHECK-ON: }
// //
// CHECK-OFF-LABEL: func.func @sparse_reduction_muli( // CHECK-OFF-LABEL: func.func @sparse_reduction_muli(
// CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i32>, // CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i32>,
// CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i32> { // CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i32> {
// CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi32> // CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi32>
// CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32> // CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32>
// CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i32> // CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i32>
// CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i32) { // CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i32) {
// CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi32> // CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi32>
// CHECK-OFF: %[[VAL_14:.*]] = arith.muli %[[VAL_12]], %[[VAL_13]] : i32 // CHECK-OFF: %[[VAL_14:.*]] = arith.muli %[[VAL_12]], %[[VAL_13]] : i32
// CHECK-OFF: scf.yield %[[VAL_14]] : i32 // CHECK-OFF: scf.yield %[[VAL_14]] : i32
// CHECK-OFF: } {"Emitted from" = "linalg.generic"} // CHECK-OFF: } {"Emitted from" = "linalg.generic"}
// CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i32> // CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i32>
// CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i32> // CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i32>
// CHECK-OFF: return %[[VAL_16]] : tensor<i32> // CHECK-OFF: return %[[VAL_16]] : tensor<i32>
// CHECK-OFF: } // CHECK-OFF: }
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> ()> // x (out) affine_map<(i) -> ()> // x (out)
], ],
iterator_types = ["reduction"] iterator_types = ["reduction"]
} }
Show All 10 Lines -> tensor<i32> {
} -> tensor<i32> } -> tensor<i32>
return %0 : tensor<i32> return %0 : tensor<i32>
} }
// ----- // -----
// Check that we vectorize addi. // Check that we vectorize addi.
// CHECK-ON-LABEL: func.func @sparse_reduction_addi( // CHECK-ON-LABEL: func.func @sparse_reduction_addi(
// CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i32>, // CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<i32>,
// CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i32> { // CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i32> {
// CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index // CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index
// CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0> : vector<8xi32> // CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0> : vector<8xi32>
// CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi32> // CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi32>
// CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32> // CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32>
// CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<i32> // CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<i32>
// CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-ON: %[[VAL_12:.*]] = vector.insertelement %[[VAL_9]], %[[VAL_3]]{{\[}}%[[VAL_4]] : index] : vector<8xi32> // CHECK-ON: %[[VAL_12:.*]] = vector.insertelement %[[VAL_9]], %[[VAL_3]]{{\[}}%[[VAL_4]] : index] : vector<8xi32>
// CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xi32>) { // CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xi32>) {
// CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]] // CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]]
// CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1> // CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1>
// CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xi32>, vector<8xi1>, vector<8xi32> into vector<8xi32> // CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xi32>, vector<8xi1>, vector<8xi32> into vector<8xi32>
// CHECK-ON: %[[VAL_19:.*]] = arith.addi %[[VAL_15]], %[[VAL_18]] : vector<8xi32> // CHECK-ON: %[[VAL_19:.*]] = arith.addi %[[VAL_15]], %[[VAL_18]] : vector<8xi32>
// CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xi32> // CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xi32>
// CHECK-ON: scf.yield %[[VAL_20]] : vector<8xi32> // CHECK-ON: scf.yield %[[VAL_20]] : vector<8xi32>
// CHECK-ON: } {"Emitted from" = "linalg.generic"} // CHECK-ON: } {"Emitted from" = "linalg.generic"}
// CHECK-ON: %[[VAL_21:.*]] = vector.reduction <add>, %[[VAL_22:.*]] : vector<8xi32> into i32 // CHECK-ON: %[[VAL_21:.*]] = vector.reduction <add>, %[[VAL_22:.*]] : vector<8xi32> into i32
// CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<i32> // CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<i32>
// CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<i32> // CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<i32>
// CHECK-ON: return %[[VAL_23]] : tensor<i32> // CHECK-ON: return %[[VAL_23]] : tensor<i32>
// CHECK-ON: } // CHECK-ON: }
// //
// CHECK-OFF-LABEL: func.func @sparse_reduction_addi( // CHECK-OFF-LABEL: func.func @sparse_reduction_addi(
// CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i32>, // CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<i32>,
// CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<i32> { // CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<i32> {
// CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xi32> // CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xi32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xi32>
// CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32> // CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<i32>
// CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i32> // CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<i32>
// CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i32) { // CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (i32) {
// CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi32> // CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xi32>
// CHECK-OFF: %[[VAL_14:.*]] = arith.addi %[[VAL_12]], %[[VAL_13]] : i32 // CHECK-OFF: %[[VAL_14:.*]] = arith.addi %[[VAL_12]], %[[VAL_13]] : i32
// CHECK-OFF: scf.yield %[[VAL_14]] : i32 // CHECK-OFF: scf.yield %[[VAL_14]] : i32
// CHECK-OFF: } {"Emitted from" = "linalg.generic"} // CHECK-OFF: } {"Emitted from" = "linalg.generic"}
// CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i32> // CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<i32>
// CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i32> // CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<i32>
// CHECK-OFF: return %[[VAL_16]] : tensor<i32> // CHECK-OFF: return %[[VAL_16]] : tensor<i32>
// CHECK-OFF: } // CHECK-OFF: }
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> ()> // x (out) affine_map<(i) -> ()> // x (out)
], ],
iterator_types = ["reduction"] iterator_types = ["reduction"]
} }
Show All 10 Lines -> tensor<i32> {
} -> tensor<i32> } -> tensor<i32>
return %0 : tensor<i32> return %0 : tensor<i32>
} }
// ----- // -----
// Check that we vectorize subf. // Check that we vectorize subf.
// CHECK-ON-LABEL: func.func @sparse_reduction_subf( // CHECK-ON-LABEL: func.func @sparse_reduction_subf(
// CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<f32>, // CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<f32>,
// CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<f32> { // CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<f32> {
// CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index // CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index
// CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0.000000e+00> : vector<8xf32> // CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0.000000e+00> : vector<8xf32>
// CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f32> // CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f32>
// CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<f32> // CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<f32>
// CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-ON: %[[VAL_12:.*]] = vector.insertelement %[[VAL_9]], %[[VAL_3]]{{\[}}%[[VAL_4]] : index] : vector<8xf32> // CHECK-ON: %[[VAL_12:.*]] = vector.insertelement %[[VAL_9]], %[[VAL_3]]{{\[}}%[[VAL_4]] : index] : vector<8xf32>
// CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xf32>) { // CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xf32>) {
// CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]] // CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]]
// CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1> // CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1>
// CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xf32>, vector<8xi1>, vector<8xf32> into vector<8xf32> // CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xf32>, vector<8xi1>, vector<8xf32> into vector<8xf32>
// CHECK-ON: %[[VAL_19:.*]] = arith.subf %[[VAL_15]], %[[VAL_18]] : vector<8xf32> // CHECK-ON: %[[VAL_19:.*]] = arith.subf %[[VAL_15]], %[[VAL_18]] : vector<8xf32>
// CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xf32> // CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xf32>
// CHECK-ON: scf.yield %[[VAL_20]] : vector<8xf32> // CHECK-ON: scf.yield %[[VAL_20]] : vector<8xf32>
// CHECK-ON: } {"Emitted from" = "linalg.generic"} // CHECK-ON: } {"Emitted from" = "linalg.generic"}
// CHECK-ON: %[[VAL_21:.*]] = vector.reduction <add>, %[[VAL_22:.*]] : vector<8xf32> into f32 // CHECK-ON: %[[VAL_21:.*]] = vector.reduction <add>, %[[VAL_22:.*]] : vector<8xf32> into f32
// CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<f32> // CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<f32>
// CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<f32> // CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<f32>
// CHECK-ON: return %[[VAL_23]] : tensor<f32> // CHECK-ON: return %[[VAL_23]] : tensor<f32>
// CHECK-ON: } // CHECK-ON: }
// //
// CHECK-OFF-LABEL: func.func @sparse_reduction_subf( // CHECK-OFF-LABEL: func.func @sparse_reduction_subf(
// CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<f32>, // CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<f32>,
// CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<f32> { // CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<f32> {
// CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f32> // CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f32>
// CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<f32> // CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<f32>
// CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (f32) { // CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (f32) {
// CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xf32> // CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xf32>
// CHECK-OFF: %[[VAL_14:.*]] = arith.subf %[[VAL_12]], %[[VAL_13]] : f32 // CHECK-OFF: %[[VAL_14:.*]] = arith.subf %[[VAL_12]], %[[VAL_13]] : f32
// CHECK-OFF: scf.yield %[[VAL_14]] : f32 // CHECK-OFF: scf.yield %[[VAL_14]] : f32
// CHECK-OFF: } {"Emitted from" = "linalg.generic"} // CHECK-OFF: } {"Emitted from" = "linalg.generic"}
// CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<f32> // CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<f32>
// CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<f32> // CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<f32>
// CHECK-OFF: return %[[VAL_16]] : tensor<f32> // CHECK-OFF: return %[[VAL_16]] : tensor<f32>
// CHECK-OFF: } // CHECK-OFF: }
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> ()> // x (out) affine_map<(i) -> ()> // x (out)
], ],
iterator_types = ["reduction"] iterator_types = ["reduction"]
} }
Show All 10 Lines -> tensor<f32> {
} -> tensor<f32> } -> tensor<f32>
return %0 : tensor<f32> return %0 : tensor<f32>
} }
// ----- // -----
// Check that we vectorize addf. // Check that we vectorize addf.
// CHECK-ON-LABEL: func.func @sparse_reduction_addf( // CHECK-ON-LABEL: func.func @sparse_reduction_addf(
// CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<f32>, // CHECK-ON-SAME: %[[VAL_0:.*]]: tensor<f32>,
// CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<f32> { // CHECK-ON-SAME: %[[VAL_1:.*]]: tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<f32> {
// CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index // CHECK-ON-DAG: %[[VAL_2:.*]] = arith.constant 8 : index
// CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0.000000e+00> : vector<8xf32> // CHECK-ON-DAG: %[[VAL_3:.*]] = arith.constant dense<0.000000e+00> : vector<8xf32>
// CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index // CHECK-ON-DAG: %[[VAL_4:.*]] = arith.constant 0 : index
// CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK-ON-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
// CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-ON: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-ON: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f32> // CHECK-ON: %[[VAL_8:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f32>
// CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<f32> // CHECK-ON: %[[VAL_9:.*]] = memref.load %[[VAL_8]][] : memref<f32>
// CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> // CHECK-ON: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> // CHECK-ON: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
// CHECK-ON: %[[VAL_12:.*]] = vector.insertelement %[[VAL_9]], %[[VAL_3]]{{\[}}%[[VAL_4]] : index] : vector<8xf32> // CHECK-ON: %[[VAL_12:.*]] = vector.insertelement %[[VAL_9]], %[[VAL_3]]{{\[}}%[[VAL_4]] : index] : vector<8xf32>
// CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xf32>) { // CHECK-ON: %[[VAL_13:.*]] = scf.for %[[VAL_14:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (vector<8xf32>) {
// CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]] // CHECK-ON: %[[VAL_16:.*]] = affine.min #map(%[[VAL_11]], %[[VAL_14]]){{\[}}%[[VAL_2]]]
// CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1> // CHECK-ON: %[[VAL_17:.*]] = vector.create_mask %[[VAL_16]] : vector<8xi1>
// CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xf32>, vector<8xi1>, vector<8xf32> into vector<8xf32> // CHECK-ON: %[[VAL_18:.*]] = vector.maskedload %[[VAL_7]]{{\[}}%[[VAL_14]]], %[[VAL_17]], %[[VAL_3]] : memref<?xf32>, vector<8xi1>, vector<8xf32> into vector<8xf32>
// CHECK-ON: %[[VAL_19:.*]] = arith.addf %[[VAL_15]], %[[VAL_18]] : vector<8xf32> // CHECK-ON: %[[VAL_19:.*]] = arith.addf %[[VAL_15]], %[[VAL_18]] : vector<8xf32>
// CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xf32> // CHECK-ON: %[[VAL_20:.*]] = arith.select %[[VAL_17]], %[[VAL_19]], %[[VAL_15]] : vector<8xi1>, vector<8xf32>
// CHECK-ON: scf.yield %[[VAL_20]] : vector<8xf32> // CHECK-ON: scf.yield %[[VAL_20]] : vector<8xf32>
// CHECK-ON: } {"Emitted from" = "linalg.generic"} // CHECK-ON: } {"Emitted from" = "linalg.generic"}
// CHECK-ON: %[[VAL_21:.*]] = vector.reduction <add>, %[[VAL_22:.*]] : vector<8xf32> into f32 // CHECK-ON: %[[VAL_21:.*]] = vector.reduction <add>, %[[VAL_22:.*]] : vector<8xf32> into f32
// CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<f32> // CHECK-ON: memref.store %[[VAL_21]], %[[VAL_8]][] : memref<f32>
// CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<f32> // CHECK-ON: %[[VAL_23:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<f32>
// CHECK-ON: return %[[VAL_23]] : tensor<f32> // CHECK-ON: return %[[VAL_23]] : tensor<f32>
// CHECK-ON: } // CHECK-ON: }
// //
// CHECK-OFF-LABEL: func.func @sparse_reduction_addf( // CHECK-OFF-LABEL: func.func @sparse_reduction_addf(
// CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<f32>, // CHECK-OFF-SAME: %[[VAL_0:.*]]: tensor<f32>,
// CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<f32> { // CHECK-OFF-SAME: %[[VAL_1:.*]]: tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>) -> tensor<f32> {
// CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index // CHECK-OFF-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
// CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK-OFF-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
// CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex> // CHECK-OFF: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xindex>
// CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xf32> // CHECK-OFF: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>> to memref<?xf32>
// CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f32> // CHECK-OFF: %[[VAL_6:.*]] = bufferization.to_memref %[[VAL_0]] : memref<f32>
// CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<f32> // CHECK-OFF: %[[VAL_7:.*]] = memref.load %[[VAL_6]][] : memref<f32>
// CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> // CHECK-OFF: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> // CHECK-OFF: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (f32) { // CHECK-OFF: %[[VAL_10:.*]] = scf.for %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_12:.*]] = %[[VAL_7]]) -> (f32) {
// CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xf32> // CHECK-OFF: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xf32>
// CHECK-OFF: %[[VAL_14:.*]] = arith.addf %[[VAL_12]], %[[VAL_13]] : f32 // CHECK-OFF: %[[VAL_14:.*]] = arith.addf %[[VAL_12]], %[[VAL_13]] : f32
// CHECK-OFF: scf.yield %[[VAL_14]] : f32 // CHECK-OFF: scf.yield %[[VAL_14]] : f32
// CHECK-OFF: } {"Emitted from" = "linalg.generic"} // CHECK-OFF: } {"Emitted from" = "linalg.generic"}
// CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<f32> // CHECK-OFF: memref.store %[[VAL_15:.*]], %[[VAL_6]][] : memref<f32>
// CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<f32> // CHECK-OFF: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<f32>
// CHECK-OFF: return %[[VAL_16]] : tensor<f32> // CHECK-OFF: return %[[VAL_16]] : tensor<f32>
// CHECK-OFF: } // CHECK-OFF: }
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> ()> // x (out) affine_map<(i) -> ()> // x (out)
], ],
iterator_types = ["reduction"] iterator_types = ["reduction"]
} }
Show All 13 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_lib_dir/libmlir_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#MAT_C_C = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
#MAT_D_C = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#MAT_C_D = #sparse_tensor.encoding<{dimLevelType = ["compressed", "dense"]}> #MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
#MAT_D_D = #sparse_tensor.encoding<{ #MAT_D_D = #sparse_tensor.encoding<{
dimLevelType = ["dense", "dense"], lvlTypes = ["dense", "dense"],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#MAT_C_C_P = #sparse_tensor.encoding<{ #MAT_C_C_P = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#MAT_C_D_P = #sparse_tensor.encoding<{ #MAT_C_D_P = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense" ], lvlTypes = [ "compressed", "dense" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#MAT_D_C_P = #sparse_tensor.encoding<{ #MAT_D_C_P = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
module { module {
func.func private @printMemrefF64(%ptr : tensor<*xf64>) func.func private @printMemrefF64(%ptr : tensor<*xf64>)
func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface } func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface }
// //
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_lib_dir/libmlir_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#MAT_C_C = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
#MAT_D_C = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#MAT_C_D = #sparse_tensor.encoding<{dimLevelType = ["compressed", "dense"]}> #MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
#MAT_D_D = #sparse_tensor.encoding<{ #MAT_D_D = #sparse_tensor.encoding<{
dimLevelType = ["dense", "dense"], lvlTypes = ["dense", "dense"],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#MAT_C_C_P = #sparse_tensor.encoding<{ #MAT_C_C_P = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#MAT_C_D_P = #sparse_tensor.encoding<{ #MAT_C_D_P = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense" ], lvlTypes = [ "compressed", "dense" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#MAT_D_C_P = #sparse_tensor.encoding<{ #MAT_D_C_P = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
module { module {
func.func private @printMemrefF64(%ptr : tensor<*xf64>) func.func private @printMemrefF64(%ptr : tensor<*xf64>)
func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface } func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface }
// //
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

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

Show All 10 Lines
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run}
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run}
#MAT_C_C = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
#MAT_D_C = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#MAT_C_D = #sparse_tensor.encoding<{dimLevelType = ["compressed", "dense"]}> #MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
#MAT_D_D = #sparse_tensor.encoding<{ #MAT_D_D = #sparse_tensor.encoding<{
dimLevelType = ["dense", "dense"], lvlTypes = ["dense", "dense"],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#MAT_C_C_P = #sparse_tensor.encoding<{ #MAT_C_C_P = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#MAT_C_D_P = #sparse_tensor.encoding<{ #MAT_C_D_P = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense" ], lvlTypes = [ "compressed", "dense" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#MAT_D_C_P = #sparse_tensor.encoding<{ #MAT_D_C_P = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
module { module {
func.func private @printMemrefF64(%ptr : tensor<*xf64>) func.func private @printMemrefF64(%ptr : tensor<*xf64>)
func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface } func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface }
// //
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_lib_dir/libmlir_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#MAT_C_C = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
#MAT_D_C = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#MAT_C_D = #sparse_tensor.encoding<{dimLevelType = ["compressed", "dense"]}> #MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
#MAT_D_D = #sparse_tensor.encoding<{ #MAT_D_D = #sparse_tensor.encoding<{
dimLevelType = ["dense", "dense"], lvlTypes = ["dense", "dense"],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#MAT_C_C_P = #sparse_tensor.encoding<{ #MAT_C_C_P = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#MAT_C_D_P = #sparse_tensor.encoding<{ #MAT_C_D_P = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense" ], lvlTypes = [ "compressed", "dense" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#MAT_D_C_P = #sparse_tensor.encoding<{ #MAT_D_C_P = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
module { module {
func.func private @printMemrefF64(%ptr : tensor<*xf64>) func.func private @printMemrefF64(%ptr : tensor<*xf64>)
func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface } func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface }
// //
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

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

Show All 25 Lines
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#DenseMatrix = #sparse_tensor.encoding<{ #DenseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense" ], lvlTypes = [ "dense", "dense" ],
dimOrdering = affine_map<(i,j) -> (i,j)> dimOrdering = affine_map<(i,j) -> (i,j)>
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (i,j)> dimOrdering = affine_map<(i,j) -> (i,j)>
}> }>
#trait_assign = { #trait_assign = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

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

Show All 11 Lines
// RUN: %{command} // RUN: %{command}
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{command} // RUN: %{command}
// UNSUPPORTED: target=aarch64{{.*}} // UNSUPPORTED: target=aarch64{{.*}}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#DenseVector = #sparse_tensor.encoding<{dimLevelType = ["dense"]}> #DenseVector = #sparse_tensor.encoding<{lvlTypes = ["dense"]}>
#trait_vec_op = { #trait_vec_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)>, // b (in) affine_map<(i) -> (i)>, // b (in)
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"] iterator_types = ["parallel"]
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#DenseVector = #sparse_tensor.encoding<{dimLevelType = ["dense"]}> #DenseVector = #sparse_tensor.encoding<{lvlTypes = ["dense"]}>
#trait_vec_op = { #trait_vec_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)>, // b (in) affine_map<(i) -> (i)>, // b (in)
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"] iterator_types = ["parallel"]
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

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

Show All 10 Lines
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=true" // REDEFINE: %{option} = "enable-runtime-library=true"
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run}
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run}
#COO_2D = #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton" ], posWidth = 32, crdWidth = 32 }> #COO_2D = #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ], posWidth = 32, crdWidth = 32 }>
#COO_3D = #sparse_tensor.encoding<{ dimLevelType = [ "compressed-nu", "singleton-nu", "singleton" ], posWidth = 32, crdWidth = 32 }> #COO_3D = #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ], posWidth = 32, crdWidth = 32 }>
module { module {
func.func private @printMemref3dF32(%ptr : tensor<?x?x?xf32>) attributes { llvm.emit_c_interface } func.func private @printMemref3dF32(%ptr : tensor<?x?x?xf32>) attributes { llvm.emit_c_interface }
func.func private @printMemref2dF32(%ptr : tensor<?x?xf32>) attributes { llvm.emit_c_interface } func.func private @printMemref2dF32(%ptr : tensor<?x?xf32>) attributes { llvm.emit_c_interface }
func.func @test_sparse_rhs(%arg0: tensor<5x6xf32>, %arg1: tensor<6x2x3xf32, #COO_3D>) -> tensor<?x?x?xf32> { func.func @test_sparse_rhs(%arg0: tensor<5x6xf32>, %arg1: tensor<6x2x3xf32, #COO_3D>) -> tensor<?x?x?xf32> {
%collapsed = tensor.collapse_shape %arg1 [[0], [1, 2]] : tensor<6x2x3xf32, #COO_3D> into tensor<6x6xf32, #COO_2D> %collapsed = tensor.collapse_shape %arg1 [[0], [1, 2]] : tensor<6x2x3xf32, #COO_3D> into tensor<6x6xf32, #COO_2D>
%0 = tensor.empty() : tensor<5x6xf32> %0 = tensor.empty() : tensor<5x6xf32>
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_op = { #trait_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "x(i) = OP a(i)" doc = "x(i) = OP a(i)"
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// //
// Traits for tensor operations. // Traits for tensor operations.
// //
#trait_vec_scale = { #trait_vec_scale = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
▲ Show 20 Lines • Show All 543 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_cast = { #trait_cast = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // A (in) affine_map<(i) -> (i)>, // A (in)
affine_map<(i) -> (i)> // X (out) affine_map<(i) -> (i)> // X (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "X(i) = cast A(i)" doc = "X(i) = cast A(i)"
▲ Show 20 Lines • Show All 244 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed"] lvlTypes = [ "compressed", "compressed"]
}> }>
module { module {
// //
// Main driver. // Main driver.
// //
func.func @entry() { func.func @entry() {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
Show All 28 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#Row = #sparse_tensor.encoding<{ #Row = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense" ] lvlTypes = [ "compressed", "dense" ]
}> }>
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
#DCSC = #sparse_tensor.encoding<{ #DCSC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
#SortedCOOPerm = #sparse_tensor.encoding<{ #SortedCOOPerm = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ], lvlTypes = [ "compressed-nu", "singleton" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#CCCPerm = #sparse_tensor.encoding<{ #CCCPerm = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed"], lvlTypes = [ "compressed", "compressed", "compressed"],
dimOrdering = affine_map<(d0, d1, d2) -> (d1, d2, d0)> dimOrdering = affine_map<(d0, d1, d2) -> (d1, d2, d0)>
}> }>
module { module {
/// uses foreach operator to print coords and values. /// uses foreach operator to print coords and values.
func.func @foreach_print_const() { func.func @foreach_print_const() {
// Initialize a tensor. // Initialize a tensor.
%0 = arith.constant sparse<[[0, 0], [1, 6]], [1.0, 5.0]> : tensor<8x7xf32> %0 = arith.constant sparse<[[0, 0], [1, 6]], [1.0, 5.0]> : tensor<8x7xf32>
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] lvlTypes = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = ["compressed", "compressed"] lvlTypes = ["compressed", "compressed"]
}> }>
#Sparse3dTensor = #sparse_tensor.encoding<{ #Sparse3dTensor = #sparse_tensor.encoding<{
dimLevelType = ["compressed", "compressed", "compressed"] lvlTypes = ["compressed", "compressed", "compressed"]
}> }>
#Sparse4dTensor = #sparse_tensor.encoding<{ #Sparse4dTensor = #sparse_tensor.encoding<{
dimLevelType = ["compressed", "compressed", "compressed", "compressed"] lvlTypes = ["compressed", "compressed", "compressed", "compressed"]
}> }>
// //
// Test with various forms of the two most elementary reshape // Test with various forms of the two most elementary reshape
// operations: collapse. // operations: collapse.
// //
module { module {
▲ Show 20 Lines • Show All 188 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait_op = { #trait_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)>, // b (in) affine_map<(i) -> (i)>, // b (in)
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait_op = { #trait_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)>, // b (in) affine_map<(i) -> (i)>, // b (in)
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait_op1 = { #trait_op1 = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "x(i) = OP a(i)" doc = "x(i) = OP a(i)"
▲ Show 20 Lines • Show All 240 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed"] lvlTypes = [ "compressed", "compressed"]
}> }>
// //
// Integration tests for conversions from sparse constants to sparse tensors. // Integration tests for conversions from sparse constants to sparse tensors.
// //
module { module {
func.func @entry() { func.func @entry() {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
Show All 33 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#CCC = #sparse_tensor.encoding<{ #CCC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ] }> lvlTypes = [ "compressed", "compressed", "compressed" ] }>
#CDC = #sparse_tensor.encoding<{ #CDC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense", "compressed" ] lvlTypes = [ "compressed", "dense", "compressed" ]
// FIXME: Still inadmissible might need investigation // FIXME: Still inadmissible might need investigation
// dimOrdering = affine_map<(i,j,k) -> (j,k,i)> // dimOrdering = affine_map<(i,j,k) -> (j,k,i)>
}> }>
// Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f // Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f
func.func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> tensor<?x?x?xf32> { func.func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> tensor<?x?x?xf32> {
%buf = bufferization.alloc_tensor(%s1, %s2, %s3) : tensor<?x?x?xf32> %buf = bufferization.alloc_tensor(%s1, %s2, %s3) : tensor<?x?x?xf32>
%ret = linalg.fill ins(%f : f32) outs(%buf : tensor<?x?x?xf32>) -> tensor<?x?x?xf32> %ret = linalg.fill ins(%f : f32) outs(%buf : tensor<?x?x?xf32>) -> tensor<?x?x?xf32>
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
#CSR = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#CDR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "dense"]}> #CDR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
// An example of a 2D convolution with a sparse filter. // An example of a 2D convolution with a sparse filter.
module { module {
func.func @conv2d(%input: tensor<8x8xi32>, func.func @conv2d(%input: tensor<8x8xi32>,
%filter: tensor<3x3xi32>, %filter: tensor<3x3xi32>,
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#CCCC = #sparse_tensor.encoding<{ #CCCC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed", "compressed", "compressed" ]
}> }>
#CDCD = #sparse_tensor.encoding<{ #CDCD = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense", "compressed", "dense" ] lvlTypes = [ "compressed", "dense", "compressed", "dense" ]
}> }>
// Creates and returns 4-D buffer of size (%s1, %s2, %s3, %s4) filled with the value %f // Creates and returns 4-D buffer of size (%s1, %s2, %s3, %s4) filled with the value %f
func.func @alloc_4d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %f : f32) -> tensor<?x?x?x?xf32> { func.func @alloc_4d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %f : f32) -> tensor<?x?x?x?xf32> {
%buf = bufferization.alloc_tensor(%s1, %s2, %s3, %s4) : tensor<?x?x?x?xf32> %buf = bufferization.alloc_tensor(%s1, %s2, %s3, %s4) : tensor<?x?x?x?xf32>
%ret = linalg.fill ins(%f : f32) outs(%buf : tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32> %ret = linalg.fill ins(%f : f32) outs(%buf : tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32>
return %ret : tensor<?x?x?x?xf32> return %ret : tensor<?x?x?x?xf32>
} }
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#CCC = #sparse_tensor.encoding<{ #CCC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed", "compressed" ]
}> }>
#CDC = #sparse_tensor.encoding<{ #CDC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense", "compressed" ] lvlTypes = [ "compressed", "dense", "compressed" ]
}> }>
#DDC = #sparse_tensor.encoding<{ #DDC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed", "compressed" ] lvlTypes = [ "dense", "compressed", "compressed" ]
}> }>
// Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f // Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f
func.func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> tensor<?x?x?xf32> { func.func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> tensor<?x?x?xf32> {
%buf = bufferization.alloc_tensor(%s1, %s2, %s3) : tensor<?x?x?xf32> %buf = bufferization.alloc_tensor(%s1, %s2, %s3) : tensor<?x?x?xf32>
%ret = linalg.fill ins(%f : f32) outs(%buf : tensor<?x?x?xf32>) -> tensor<?x?x?xf32> %ret = linalg.fill ins(%f : f32) outs(%buf : tensor<?x?x?xf32>) -> tensor<?x?x?xf32>
return %ret : tensor<?x?x?xf32> return %ret : tensor<?x?x?xf32>
} }
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#CCCCC = #sparse_tensor.encoding<{ #CCCCC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed", "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed", "compressed", "compressed", "compressed" ]
}> }>
#CDCDC = #sparse_tensor.encoding<{ #CDCDC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense", "compressed", "dense", "compressed"] lvlTypes = [ "compressed", "dense", "compressed", "dense", "compressed"]
}> }>
// Creates and returns 5-D buffer of size (%s1, %s2, %s3, %s4, %s5) filled with the value %f // Creates and returns 5-D buffer of size (%s1, %s2, %s3, %s4, %s5) filled with the value %f
func.func @alloc_5d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %s5 : index, %f : f32) -> tensor<?x?x?x?x?xf32> { func.func @alloc_5d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %s5 : index, %f : f32) -> tensor<?x?x?x?x?xf32> {
%buf = bufferization.alloc_tensor(%s1, %s2, %s3, %s4, %s5) : tensor<?x?x?x?x?xf32> %buf = bufferization.alloc_tensor(%s1, %s2, %s3, %s4, %s5) : tensor<?x?x?x?x?xf32>
%ret = linalg.fill ins(%f : f32) outs(%buf : tensor<?x?x?x?x?xf32>) -> tensor<?x?x?x?x?xf32> %ret = linalg.fill ins(%f : f32) outs(%buf : tensor<?x?x?x?x?xf32>) -> tensor<?x?x?x?x?xf32>
return %ret : tensor<?x?x?x?x?xf32> return %ret : tensor<?x?x?x?x?xf32>
} }
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (i,j,k)> dimOrdering = affine_map<(i,j,k) -> (i,j,k)>
}> }>
#Tensor2 = #sparse_tensor.encoding<{ #Tensor2 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (j,k,i)> dimOrdering = affine_map<(i,j,k) -> (j,k,i)>
}> }>
#Tensor3 = #sparse_tensor.encoding<{ #Tensor3 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (k,i,j)> dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
}> }>
// //
// Integration test that tests conversions between sparse tensors. // Integration test that tests conversions between sparse tensors.
// //
module { module {
// //
▲ Show 20 Lines • Show All 267 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#DCSC = #sparse_tensor.encoding<{ #DCSC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
// //
// Integration test that tests conversions between sparse tensors, // Integration test that tests conversions between sparse tensors,
// where the dynamic sizes of the shape of the enveloping tensor // where the dynamic sizes of the shape of the enveloping tensor
// may change (the actual underlying sizes obviously never change). // may change (the actual underlying sizes obviously never change).
// //
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

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

Show All 17 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ]
}> }>
#Tensor2 = #sparse_tensor.encoding<{ #Tensor2 = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed", "dense" ] lvlTypes = [ "dense", "compressed", "dense" ]
}> }>
#Tensor3 = #sparse_tensor.encoding<{ #Tensor3 = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense", "compressed" ], lvlTypes = [ "dense", "dense", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (i,k,j)> dimOrdering = affine_map<(i,j,k) -> (i,k,j)>
}> }>
module { module {
// //
// Utility for output. // Utility for output.
// //
func.func @dump(%arg0: tensor<2x3x4xf32>) { func.func @dump(%arg0: tensor<2x3x4xf32>) {
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
posWidth = 8, posWidth = 8,
crdWidth = 8 crdWidth = 8
}> }>
#DCSC = #sparse_tensor.encoding<{ #DCSC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)>, dimOrdering = affine_map<(i,j) -> (j,i)>,
posWidth = 64, posWidth = 64,
crdWidth = 64 crdWidth = 64
}> }>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)>, dimOrdering = affine_map<(i,j) -> (j,i)>,
posWidth = 16, posWidth = 16,
crdWidth = 32 crdWidth = 32
}> }>
// //
// Integration test that tests conversions between sparse tensors, // Integration test that tests conversions between sparse tensors,
// where the position and index sizes in the overhead storage change // where the position and index sizes in the overhead storage change
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (i,j,k)> dimOrdering = affine_map<(i,j,k) -> (i,j,k)>
}> }>
#Tensor2 = #sparse_tensor.encoding<{ #Tensor2 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (j,k,i)> dimOrdering = affine_map<(i,j,k) -> (j,k,i)>
}> }>
#Tensor3 = #sparse_tensor.encoding<{ #Tensor3 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (k,i,j)> dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
}> }>
#Tensor4 = #sparse_tensor.encoding<{ #Tensor4 = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed", "compressed" ], lvlTypes = [ "dense", "compressed", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (i,j,k)> dimOrdering = affine_map<(i,j,k) -> (i,j,k)>
}> }>
#Tensor5 = #sparse_tensor.encoding<{ #Tensor5 = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed", "compressed" ], lvlTypes = [ "dense", "compressed", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (j,k,i)> dimOrdering = affine_map<(i,j,k) -> (j,k,i)>
}> }>
#Tensor6 = #sparse_tensor.encoding<{ #Tensor6 = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed", "compressed" ], lvlTypes = [ "dense", "compressed", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (k,i,j)> dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
}> }>
// //
// Integration test that tests conversions from sparse to dense tensors. // Integration test that tests conversions from sparse to dense tensors.
// //
module { module {
// //
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

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

Show All 22 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense", "compressed" ] lvlTypes = [ "dense", "dense", "compressed" ]
}> }>
// NOTE: dense after compressed is not currently supported for the target // NOTE: dense after compressed is not currently supported for the target
// of direct-sparse2sparse conversion. (It's fine for the source though.) // of direct-sparse2sparse conversion. (It's fine for the source though.)
#Tensor2 = #sparse_tensor.encoding<{ #Tensor2 = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed", "dense" ] lvlTypes = [ "dense", "compressed", "dense" ]
}> }>
#Tensor3 = #sparse_tensor.encoding<{ #Tensor3 = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense", "compressed" ], lvlTypes = [ "dense", "dense", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (i,k,j)> dimOrdering = affine_map<(i,j,k) -> (i,k,j)>
}> }>
#SingletonTensor1 = #sparse_tensor.encoding<{ #SingletonTensor1 = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed", "singleton" ] lvlTypes = [ "dense", "compressed", "singleton" ]
}> }>
// This also checks the compressed->dense conversion (when there are zeros). // This also checks the compressed->dense conversion (when there are zeros).
#SingletonTensor2 = #sparse_tensor.encoding<{ #SingletonTensor2 = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense", "singleton" ] lvlTypes = [ "dense", "dense", "singleton" ]
}> }>
// This also checks the singleton->compressed conversion. // This also checks the singleton->compressed conversion.
#SingletonTensor3 = #sparse_tensor.encoding<{ #SingletonTensor3 = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense", "compressed" ] lvlTypes = [ "dense", "dense", "compressed" ]
}> }>
module { module {
// //
// Utility for output. // Utility for output.
// //
func.func @dump(%arg0: tensor<2x3x4xf64>) { func.func @dump(%arg0: tensor<2x3x4xf64>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (i,j)>, // B affine_map<(i,j) -> (i,j)>, // B
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Lines func.func @entry() {
bufferization.dealloc_tensor %C3 : tensor<8x8xf32> bufferization.dealloc_tensor %C3 : tensor<8x8xf32>
bufferization.dealloc_tensor %CSR_A : tensor<8x8xf32, #CSR> bufferization.dealloc_tensor %CSR_A : tensor<8x8xf32, #CSR>
bufferization.dealloc_tensor %COO_A : tensor<8x8xf32, #SortedCOO> bufferization.dealloc_tensor %COO_A : tensor<8x8xf32, #SortedCOO>
bufferization.dealloc_tensor %COO_B : tensor<8x8xf32, #SortedCOO> bufferization.dealloc_tensor %COO_B : tensor<8x8xf32, #SortedCOO>
return return
} }
} }
No newline at end of file

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
module { module {
// //
// Sparse kernel. // Sparse kernel.
// //
func.func @sparse_dot(%a: tensor<1024xf32, #SparseVector>, func.func @sparse_dot(%a: tensor<1024xf32, #SparseVector>,
%b: tensor<1024xf32, #SparseVector>, %b: tensor<1024xf32, #SparseVector>,
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
module { module {
func.func private @printMemrefF64(%ptr : tensor<*xf64>) func.func private @printMemrefF64(%ptr : tensor<*xf64>)
// //
// Column-wise storage forces the ijk loop to permute into jki // Column-wise storage forces the ijk loop to permute into jki
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] lvlTypes = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = ["compressed", "compressed"] lvlTypes = ["compressed", "compressed"]
}> }>
#Sparse3dTensor = #sparse_tensor.encoding<{ #Sparse3dTensor = #sparse_tensor.encoding<{
dimLevelType = ["compressed", "compressed", "compressed"] lvlTypes = ["compressed", "compressed", "compressed"]
}> }>
#Sparse4dTensor = #sparse_tensor.encoding<{ #Sparse4dTensor = #sparse_tensor.encoding<{
dimLevelType = ["compressed", "compressed", "compressed", "compressed"] lvlTypes = ["compressed", "compressed", "compressed", "compressed"]
}> }>
// //
// Test with various forms of the two most elementary reshape // Test with various forms of the two most elementary reshape
// operations: expand // operations: expand
// //
module { module {
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
// An example of a 2D convolution with a sparse filter. // An example of a 2D convolution with a sparse filter.
module { module {
func.func @conv2d(%input: tensor<8x8xi32>, func.func @conv2d(%input: tensor<8x8xi32>,
%filter: tensor<3x3xi32, #DCSR>, %filter: tensor<3x3xi32, #DCSR>,
%output: tensor<6x6xi32>) -> tensor<6x6xi32> { %output: tensor<6x6xi32>) -> tensor<6x6xi32> {
%0 = linalg.conv_2d %0 = linalg.conv_2d
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

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

Show All 25 Lines
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed", "compressed", lvlTypes = [ "compressed", "compressed", "compressed", "compressed",
"compressed", "compressed", "compressed", "compressed" ], "compressed", "compressed", "compressed", "compressed" ],
// Note that any dimOrdering permutation should give the same results // Note that any dimOrdering permutation should give the same results
// since, even though it impacts the sparse storage scheme layout, // since, even though it impacts the sparse storage scheme layout,
// it should not change the semantics. // it should not change the semantics.
dimOrdering = affine_map<(i,j,k,l,m,n,o,p) -> (p,o,j,k,i,l,m,n)> dimOrdering = affine_map<(i,j,k,l,m,n,o,p) -> (p,o,j,k,i,l,m,n)>
}> }>
#trait_flatten = { #trait_flatten = {
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=false // DEFINE: %{option} = enable-runtime-library=false
// DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// DEFINE: mlir-cpu-runner \ // DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \ // DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s // DEFINE: FileCheck %s
// //
// RUN: %{command} // RUN: %{command}
// //
// TODO: support slices on lib path // TODO: support slices on lib path
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
#CSR_SLICE = #sparse_tensor.encoding<{ #CSR_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (1, 4, 1), (1, 4, 2) ] slice = [ (1, 4, 1), (1, 4, 2) ]
}> }>
#CSR_SLICE_DYN = #sparse_tensor.encoding<{ #CSR_SLICE_DYN = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (?, ?, ?), (?, ?, ?) ] slice = [ (?, ?, ?), (?, ?, ?) ]
}> }>
#COO = #sparse_tensor.encoding<{ #COO = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
#COO_SLICE = #sparse_tensor.encoding<{ #COO_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ], lvlTypes = [ "compressed-nu", "singleton" ],
slice = [ (1, 4, 1), (1, 4, 2) ] slice = [ (1, 4, 1), (1, 4, 2) ]
}> }>
#COO_SLICE_DYN = #sparse_tensor.encoding<{ #COO_SLICE_DYN = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ], lvlTypes = [ "compressed-nu", "singleton" ],
slice = [ (?, ?, ?), (?, ?, ?) ] slice = [ (?, ?, ?), (?, ?, ?) ]
}> }>
module { module {
func.func @foreach_print_non_slice(%A: tensor<4x4xf64, #CSR>) { func.func @foreach_print_non_slice(%A: tensor<4x4xf64, #CSR>) {
sparse_tensor.foreach in %A : tensor<4x4xf64, #CSR> do { sparse_tensor.foreach in %A : tensor<4x4xf64, #CSR> do {
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] lvlTypes = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = ["compressed", "compressed"] lvlTypes = ["compressed", "compressed"]
}> }>
#trait_1d = { #trait_1d = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
▲ Show 20 Lines • Show All 251 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] lvlTypes = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = ["compressed", "compressed"] lvlTypes = ["compressed", "compressed"]
}> }>
#trait_1d = { #trait_1d = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

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

Show All 18 Lines
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
// Insertion example using pure codegen (no sparse runtime support lib). // Insertion example using pure codegen (no sparse runtime support lib).
#SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_mul_s = { #trait_mul_s = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "x(i) = x(i) * 2.0" doc = "x(i) = x(i) * 2.0"
} }
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

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

Show All 17 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#Dense = #sparse_tensor.encoding<{ #Dense = #sparse_tensor.encoding<{
dimLevelType = ["dense", "dense"] lvlTypes = ["dense", "dense"]
}> }>
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#Row = #sparse_tensor.encoding<{ #Row = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense" ] lvlTypes = [ "compressed", "dense" ]
}> }>
module { module {
func.func @dump_dense(%arg0: tensor<4x3xf64, #Dense>) { func.func @dump_dense(%arg0: tensor<4x3xf64, #Dense>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%fu = arith.constant 99.0 : f64 %fu = arith.constant 99.0 : f64
%v = sparse_tensor.values %arg0 : tensor<4x3xf64, #Dense> to memref<?xf64> %v = sparse_tensor.values %arg0 : tensor<4x3xf64, #Dense> to memref<?xf64>
▲ Show 20 Lines • Show All 197 Lines • Show Last 20 Lines

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

Show All 17 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#TensorCSR = #sparse_tensor.encoding<{ #TensorCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense", "compressed" ] lvlTypes = [ "compressed", "dense", "compressed" ]
}> }>
#TensorRow = #sparse_tensor.encoding<{ #TensorRow = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "dense" ] lvlTypes = [ "compressed", "compressed", "dense" ]
}> }>
#CCoo = #sparse_tensor.encoding<{ #CCoo = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed-nu", "singleton" ] lvlTypes = [ "compressed", "compressed-nu", "singleton" ]
}> }>
#DCoo = #sparse_tensor.encoding<{ #DCoo = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed-nu", "singleton" ] lvlTypes = [ "dense", "compressed-nu", "singleton" ]
}> }>
module { module {
func.func @dump(%arg0: tensor<5x4x3xf64, #TensorCSR>) { func.func @dump(%arg0: tensor<5x4x3xf64, #TensorCSR>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%fu = arith.constant 99.0 : f64 %fu = arith.constant 99.0 : f64
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

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

Show All 31 Lines
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
// TODO: Investigate the output generated for SVE, see https://github.com/llvm/llvm-project/issues/60626 // TODO: Investigate the output generated for SVE, see https://github.com/llvm/llvm-project/issues/60626
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (i,j)> dimOrdering = affine_map<(i,j) -> (i,j)>
}> }>
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (i,j)> dimOrdering = affine_map<(i,j) -> (i,j)>
}> }>
module { module {
func.func private @printMemrefF64(%ptr : tensor<*xf64>) func.func private @printMemrefF64(%ptr : tensor<*xf64>)
func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface } func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface }
// //
▲ Show 20 Lines • Show All 273 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=false // DEFINE: %{option} = enable-runtime-library=false
// DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// DEFINE: mlir-cpu-runner \ // DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \ // DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext | \ // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// DEFINE: FileCheck %s // DEFINE: FileCheck %s
// //
// RUN: %{command} // RUN: %{command}
// //
// TODO: support lib path. // TODO: support lib path.
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#DCSR_SLICE = #sparse_tensor.encoding<{ #DCSR_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
slice = [ (0, 4, 1), (0, 8, 1) ] slice = [ (0, 4, 1), (0, 8, 1) ]
}> }>
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
#CSR_SLICE = #sparse_tensor.encoding<{ #CSR_SLICE = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (0, 4, 1), (0, 8, 1) ] slice = [ (0, 4, 1), (0, 8, 1) ]
}> }>
#COO = #sparse_tensor.encoding<{ #COO = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
#CSR_SLICE_1 = #sparse_tensor.encoding<{ #CSR_SLICE_1 = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (0, 4, 2), (0, 4, 1) ] slice = [ (0, 4, 2), (0, 4, 1) ]
}> }>
#DCSR_SLICE_1 = #sparse_tensor.encoding<{ #DCSR_SLICE_1 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
slice = [ (0, 4, 2), (1, 4, 1) ] slice = [ (0, 4, 2), (1, 4, 1) ]
}> }>
#COO_SLICE_1 = #sparse_tensor.encoding<{ #COO_SLICE_1 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ], lvlTypes = [ "compressed-nu", "singleton" ],
slice = [ (0, 4, 2), (0, 4, 1) ] slice = [ (0, 4, 2), (0, 4, 1) ]
}> }>
#COO_SLICE_2 = #sparse_tensor.encoding<{ #COO_SLICE_2 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ], lvlTypes = [ "compressed-nu", "singleton" ],
slice = [ (0, 4, 2), (1, 4, 1) ] slice = [ (0, 4, 2), (1, 4, 1) ]
}> }>
#CSR_SLICE_dyn = #sparse_tensor.encoding<{ #CSR_SLICE_dyn = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
slice = [ (?, 4, ?), (?, 4, ?) ] slice = [ (?, 4, ?), (?, 4, ?) ]
}> }>
#DCSR_SLICE_dyn = #sparse_tensor.encoding<{ #DCSR_SLICE_dyn = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
slice = [ (?, 4, ?), (?, 4, ?) ] slice = [ (?, 4, ?), (?, 4, ?) ]
}> }>
module { module {
func.func private @printMemrefF64(%ptr : tensor<*xf64>) func.func private @printMemrefF64(%ptr : tensor<*xf64>)
func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface } func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface }
// //
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// //
// Traits for 2-d tensor (aka matrix) operations. // Traits for 2-d tensor (aka matrix) operations.
// //
#trait_scale = { #trait_scale = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A (in) affine_map<(i,j) -> (i,j)>, // A (in)
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

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

Show All 32 Lines
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
posWidth = 8, posWidth = 8,
crdWidth = 8 crdWidth = 8
}> }>
#matvec = { #matvec = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (j)>, // b affine_map<(i,j) -> (j)>, // b
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

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

Show All 25 Lines
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext -dlopen=%mlir_runner_utils| \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext -dlopen=%mlir_runner_utils| \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed", "compressed" ]
}> }>
#mttkrp = { #mttkrp = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j,k,l) -> (i,k,l)>, // B affine_map<(i,j,k,l) -> (i,k,l)>, // B
affine_map<(i,j,k,l) -> (k,j)>, // C affine_map<(i,j,k,l) -> (k,j)>, // C
affine_map<(i,j,k,l) -> (l,j)>, // D affine_map<(i,j,k,l) -> (l,j)>, // D
affine_map<(i,j,k,l) -> (i,j)> // A (out) affine_map<(i,j,k,l) -> (i,j)> // A (out)
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#trait_mult_elt = { #trait_mult_elt = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (i,j)>, // B affine_map<(i,j) -> (i,j)>, // B
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed", "compressed" ]
}> }>
#redsum = { #redsum = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j,k) -> (i,j,k)>, // A affine_map<(i,j,k) -> (i,j,k)>, // A
affine_map<(i,j,k) -> (i,j,k)>, // B affine_map<(i,j,k) -> (i,j,k)>, // B
affine_map<(i,j,k) -> (i,j)> // X (out) affine_map<(i,j,k) -> (i,j)> // X (out)
], ],
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

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

Show All 25 Lines
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (i,j)> dimOrdering = affine_map<(i,j) -> (i,j)>
}> }>
#eltwise_mult = { #eltwise_mult = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

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

Show All 16 Lines
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
// TODO: Pack only support CodeGen Path // TODO: Pack only support CodeGen Path
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
#SortedCOOI32 = #sparse_tensor.encoding<{ #SortedCOOI32 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ], lvlTypes = [ "compressed-nu", "singleton" ],
posWidth = 32, posWidth = 32,
crdWidth = 32 crdWidth = 32
}> }>
#BCOO = #sparse_tensor.encoding<{ #BCOO = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed-hi-nu", "singleton" ] lvlTypes = [ "dense", "compressed-hi-nu", "singleton" ]
}> }>
module { module {
// //
// Main driver. // Main driver.
// //
func.func @entry() { func.func @entry() {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
// An example of a quantized sparse matmul. With the zero offset for the // An example of a quantized sparse matmul. With the zero offset for the
// sparse input, the sparse compiler generates very efficient code for the // sparse input, the sparse compiler generates very efficient code for the
// x(i,j) += (ext(a(i,k)) - 2) * ext(b(k,j)) // x(i,j) += (ext(a(i,k)) - 2) * ext(b(k,j))
// operation. // operation.
module { module {
func.func @quantized_matmul(%input1: tensor<5x3xi8>, func.func @quantized_matmul(%input1: tensor<5x3xi8>,
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait_op = { #trait_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "x(i) = OP a(i)" doc = "x(i) = OP a(i)"
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

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

Show All 22 Lines
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
// Reduction in this file _are_ supported by the AArch64 SVE backend // Reduction in this file _are_ supported by the AArch64 SVE backend
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#CSR = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
// //
// Traits for tensor operations. // Traits for tensor operations.
// //
#trait_matmul = { #trait_matmul = {
indexing_maps = [ indexing_maps = [
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

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

Show All 13 Lines
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run}
// Product reductions - kept in a seperate file as these are not supported by // Product reductions - kept in a seperate file as these are not supported by
// the AArch64 SVE backend (so the set-up is a bit different to // the AArch64 SVE backend (so the set-up is a bit different to
// sparse_reducitons.mlir) // sparse_reducitons.mlir)
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#CSR = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
// //
// Traits for tensor operations. // Traits for tensor operations.
// //
#trait_mat_reduce_rowwise = { #trait_mat_reduce_rowwise = {
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// Reduction in this file _are_ supported by the AArch64 SVE backend // Reduction in this file _are_ supported by the AArch64 SVE backend
#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#DV = #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }> #DV = #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>
#trait_reduction = { #trait_reduction = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> ()> // x (scalar out) affine_map<(i) -> ()> // x (scalar out)
], ],
iterator_types = ["reduction"], iterator_types = ["reduction"],
doc = "x += OPER_i a(i)" doc = "x += OPER_i a(i)"
▲ Show 20 Lines • Show All 150 Lines • Show Last 20 Lines

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

Show All 13 Lines
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{command} // RUN: %{command}
// Product reductions - kept in a seperate file as these are not supported by // Product reductions - kept in a seperate file as these are not supported by
// the AArch64 SVE backend (so the set-up is a bit different to // the AArch64 SVE backend (so the set-up is a bit different to
// sparse_reducitons.mlir) // sparse_reducitons.mlir)
#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#DV = #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }> #DV = #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>
#trait_reduction = { #trait_reduction = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> ()> // x (scalar out) affine_map<(i) -> ()> // x (scalar out)
], ],
iterator_types = ["reduction"], iterator_types = ["reduction"],
doc = "x += OPER_i a(i)" doc = "x += OPER_i a(i)"
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

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

Show All 25 Lines
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
posWidth = 32, posWidth = 32,
crdWidth = 32 crdWidth = 32
}> }>
#trait_sampled_dense_dense = { #trait_sampled_dense_dense = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j,k) -> (i,j)>, // S affine_map<(i,j,k) -> (i,j)>, // S
affine_map<(i,j,k) -> (i,k)>, // A affine_map<(i,j,k) -> (i,k)>, // A
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SM = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #SM = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
#trait_sampled_dense_dense = { #trait_sampled_dense_dense = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j,k) -> (i,j)>, // S affine_map<(i,j,k) -> (i,j)>, // S
affine_map<(i,j,k) -> (i,k)>, // A affine_map<(i,j,k) -> (i,k)>, // A
affine_map<(i,j,k) -> (k,j)>, // B affine_map<(i,j,k) -> (k,j)>, // B
affine_map<(i,j,k) -> (i,j)> // X (out) affine_map<(i,j,k) -> (i,j)> // X (out)
], ],
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

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

Show All 16 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#CSR = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }> #CSR = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>
#trait_scale = { #trait_scale = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
doc = "X(i,j) = X(i,j) * 2" doc = "X(i,j) = X(i,j) * 2"
} }
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

Show All 17 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> #map = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
#SparseMatrix = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }> #SparseMatrix = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>
module @func_sparse.2 { module @func_sparse.2 {
// Do elementwise x+1 when true, x-1 when false // Do elementwise x+1 when true, x-1 when false
func.func public @condition(%cond: i1, %arg0: tensor<2x3x4xf64, #SparseMatrix>) -> tensor<2x3x4xf64, #SparseMatrix> { func.func public @condition(%cond: i1, %arg0: tensor<2x3x4xf64, #SparseMatrix>) -> tensor<2x3x4xf64, #SparseMatrix> {
%1 = scf.if %cond -> (tensor<2x3x4xf64, #SparseMatrix>) { %1 = scf.if %cond -> (tensor<2x3x4xf64, #SparseMatrix>) {
%cst_2 = arith.constant dense<1.000000e+00> : tensor<f64> %cst_2 = arith.constant dense<1.000000e+00> : tensor<f64>
%cst_3 = arith.constant dense<1.000000e+00> : tensor<2x3x4xf64> %cst_3 = arith.constant dense<1.000000e+00> : tensor<2x3x4xf64>
%2 = bufferization.alloc_tensor() : tensor<2x3x4xf64, #SparseMatrix> %2 = bufferization.alloc_tensor() : tensor<2x3x4xf64, #SparseMatrix>
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

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

Show All 16 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#CSR = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
// //
// Traits for tensor operations. // Traits for tensor operations.
// //
#trait_vec_select = { #trait_vec_select = {
indexing_maps = [ indexing_maps = [
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

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

Show All 16 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_op = { #trait_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "x(i) = OP a(i)" doc = "x(i) = OP a(i)"
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

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

Show All 23 Lines
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
#SortedCOOPermuted = #sparse_tensor.encoding<{ #SortedCOOPermuted = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ], lvlTypes = [ "compressed-nu", "singleton" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#SortedCOO3D = #sparse_tensor.encoding<{ #SortedCOO3D = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ]
}> }>
#SortedCOO3DPermuted = #sparse_tensor.encoding<{ #SortedCOO3DPermuted = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton-nu", "singleton" ], lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ],
dimOrdering = affine_map<(i,j,k) -> (k,i,j)> dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
}> }>
#trait_scale = { #trait_scale = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
▲ Show 20 Lines • Show All 204 Lines • Show Last 20 Lines

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

Show All 25 Lines
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
#spmm = { #spmm = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j,k) -> (i,k)>, // A affine_map<(i,j,k) -> (i,k)>, // A
affine_map<(i,j,k) -> (k,j)>, // B affine_map<(i,j,k) -> (k,j)>, // B
affine_map<(i,j,k) -> (i,j)> // X (out) affine_map<(i,j,k) -> (i,j)> // X (out)
], ],
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

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

Show All 25 Lines
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
// //
// Several common sparse storage schemes. // Several common sparse storage schemes.
// //
#Dense = #sparse_tensor.encoding<{ #Dense = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense" ] lvlTypes = [ "dense", "dense" ]
}> }>
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#DCSC = #sparse_tensor.encoding<{ #DCSC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#BlockRow = #sparse_tensor.encoding<{ #BlockRow = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense" ] lvlTypes = [ "compressed", "dense" ]
}> }>
#BlockCol = #sparse_tensor.encoding<{ #BlockCol = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense" ], lvlTypes = [ "compressed", "dense" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
// //
// Integration test that looks "under the hood" of sparse storage schemes. // Integration test that looks "under the hood" of sparse storage schemes.
// //
module { module {
// //
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

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

Show All 28 Lines
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
// TODO: The test currently only operates on the triangular part of the // TODO: The test currently only operates on the triangular part of the
// symmetric matrix. // symmetric matrix.
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#trait_sum_reduce = { #trait_sum_reduce = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> ()> // x (out) affine_map<(i,j) -> ()> // x (out)
], ],
iterator_types = ["reduction", "reduction"], iterator_types = ["reduction", "reduction"],
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

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

Show All 14 Lines
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{command} // RUN: %{command}
// UNSUPPORTED: target=aarch64{{.*}} // UNSUPPORTED: target=aarch64{{.*}}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#trait_sum_reduce = { #trait_sum_reduce = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> ()> // x (out) affine_map<(i,j) -> ()> // x (out)
], ],
iterator_types = ["reduction", "reduction"], iterator_types = ["reduction", "reduction"],
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

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

Show All 28 Lines
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
// TODO: The test currently only operates on the triangular part of the // TODO: The test currently only operates on the triangular part of the
// symmetric matrix. // symmetric matrix.
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#trait_sum_reduce = { #trait_sum_reduce = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> ()> // x (out) affine_map<(i,j) -> ()> // x (out)
], ],
iterator_types = ["reduction", "reduction"], iterator_types = ["reduction", "reduction"],
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

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

Show All 23 Lines
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#trait_sum_reduce = { #trait_sum_reduce = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> ()> // x (out) affine_map<(i,j) -> ()> // x (out)
], ],
iterator_types = ["reduction", "reduction"], iterator_types = ["reduction", "reduction"],
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

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

Show All 23 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_op = { #trait_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)> // X (out) affine_map<(i) -> (i)> // X (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "X(i) = OP X(i)" doc = "X(i) = OP X(i)"
} }
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#ST = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed", "compressed"]}> #ST = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed", "compressed"]}>
// //
// Trait for 3-d tensor element wise multiplication. // Trait for 3-d tensor element wise multiplication.
// //
#trait_mul = { #trait_mul = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j,k) -> (i,j,k)>, // A (in) affine_map<(i,j,k) -> (i,j,k)>, // A (in)
affine_map<(i,j,k) -> (i,j,k)>, // B (in) affine_map<(i,j,k) -> (i,j,k)>, // B (in)
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#ST1 = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed", "compressed"]}> #ST1 = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed", "compressed"]}>
#ST2 = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed", "dense"]}> #ST2 = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed", "dense"]}>
// //
// Trait for 3-d tensor operation. // Trait for 3-d tensor operation.
// //
#trait_scale = { #trait_scale = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j,k) -> (i,j,k)>, // A (in) affine_map<(i,j,k) -> (i,j,k)>, // A (in)
affine_map<(i,j,k) -> (i,j,k)> // X (out) affine_map<(i,j,k) -> (i,j,k)> // X (out)
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

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

Show All 21 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#DCSC = #sparse_tensor.encoding<{ #DCSC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
#transpose_trait = { #transpose_trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (j,i)>, // A affine_map<(i,j) -> (j,i)>, // A
affine_map<(i,j) -> (i,j)> // X affine_map<(i,j) -> (i,j)> // X
], ],
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

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

Show All 22 Lines
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
module { module {
// A linalg representation of some higher "transpose" op. // A linalg representation of some higher "transpose" op.
func.func @transpose_coo(%arga: tensor<10x5xf32, #SortedCOO>) func.func @transpose_coo(%arga: tensor<10x5xf32, #SortedCOO>)
-> tensor<5x10xf32, #SortedCOO> { -> tensor<5x10xf32, #SortedCOO> {
%0 = bufferization.alloc_tensor() : tensor<5x10xf32, #SortedCOO> %0 = bufferization.alloc_tensor() : tensor<5x10xf32, #SortedCOO>
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// //
// Traits for tensor operations. // Traits for tensor operations.
// //
#trait_vec_scale = { #trait_vec_scale = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
▲ Show 20 Lines • Show All 251 Lines • Show Last 20 Lines

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

Show All 20 Lines
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#DenseVector = #sparse_tensor.encoding<{dimLevelType = ["dense"]}> #DenseVector = #sparse_tensor.encoding<{lvlTypes = ["dense"]}>
// //
// Traits for 1-d tensor (aka vector) operations. // Traits for 1-d tensor (aka vector) operations.
// //
#trait_scale = { #trait_scale = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
▲ Show 20 Lines • Show All 219 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/GPU/CUDA/sparse-matvec-const.mlir

// //
// NOTE: this test requires gpu-sm80 // NOTE: this test requires gpu-sm80
// //
// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparse-compiler="enable-runtime-library=false parallelization-strategy=dense-outer-loop gpu-triple=nvptx64-nvidia-cuda gpu-chip=sm_80 gpu-features=+ptx71" \ // RUN: --sparse-compiler="enable-runtime-library=false parallelization-strategy=dense-outer-loop gpu-triple=nvptx64-nvidia-cuda gpu-chip=sm_80 gpu-features=+ptx71" \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_cuda_runtime \ // RUN: --shared-libs=%mlir_cuda_runtime \
// RUN: --shared-libs=%mlir_c_runner_utils \ // RUN: --shared-libs=%mlir_c_runner_utils \
// RUN: --e main --entry-point-result=void \ // RUN: --e main --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
#CSR = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }> #CSR = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>
module { module {
// Compute matrix vector y = Ax // Compute matrix vector y = Ax
func.func @matvec(%A: tensor<1024x64xf64, #CSR>, %x: tensor<64xf64>, %y_in: tensor<1024xf64>) -> tensor<1024xf64> { func.func @matvec(%A: tensor<1024x64xf64, #CSR>, %x: tensor<64xf64>, %y_in: tensor<1024xf64>) -> tensor<1024xf64> {
%y_out = linalg.matvec %y_out = linalg.matvec
ins(%A, %x: tensor<1024x64xf64, #CSR>, tensor<64xf64>) ins(%A, %x: tensor<1024x64xf64, #CSR>, tensor<64xf64>)
outs(%y_in: tensor<1024xf64>) -> tensor<1024xf64> outs(%y_in: tensor<1024xf64>) -> tensor<1024xf64>
return %y_out : tensor<1024xf64> return %y_out : tensor<1024xf64>
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/GPU/CUDA/sparse-matvec.mlir

// //
// NOTE: this test requires gpu-sm80 // NOTE: this test requires gpu-sm80
// //
// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparse-compiler="enable-runtime-library=false parallelization-strategy=dense-outer-loop gpu-triple=nvptx64-nvidia-cuda gpu-chip=sm_80 gpu-features=+ptx71" \ // RUN: --sparse-compiler="enable-runtime-library=false parallelization-strategy=dense-outer-loop gpu-triple=nvptx64-nvidia-cuda gpu-chip=sm_80 gpu-features=+ptx71" \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_cuda_runtime \ // RUN: --shared-libs=%mlir_cuda_runtime \
// RUN: --shared-libs=%mlir_c_runner_utils \ // RUN: --shared-libs=%mlir_c_runner_utils \
// RUN: --e main --entry-point-result=void \ // RUN: --e main --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
#CSR = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }> #CSR = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>
module { module {
// Compute matrix vector y = Ax // Compute matrix vector y = Ax
func.func @matvec(%A: tensor<?x?xf64, #CSR>, %x: tensor<?xf64>, %y_in: tensor<?xf64>) -> tensor<?xf64> { func.func @matvec(%A: tensor<?x?xf64, #CSR>, %x: tensor<?xf64>, %y_in: tensor<?xf64>) -> tensor<?xf64> {
%y_out = linalg.matvec %y_out = linalg.matvec
ins(%A, %x: tensor<?x?xf64, #CSR>, tensor<?xf64>) ins(%A, %x: tensor<?x?xf64, #CSR>, tensor<?xf64>)
outs(%y_in: tensor<?xf64>) -> tensor<?xf64> outs(%y_in: tensor<?xf64>) -> tensor<?xf64>
return %y_out : tensor<?xf64> return %y_out : tensor<?xf64>
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

Show All 14 Lines
sys.path.append(_SCRIPT_PATH) sys.path.append(_SCRIPT_PATH)
from tools import np_to_sparse_tensor as test_tools from tools import np_to_sparse_tensor as test_tools
from tools import sparse_compiler from tools import sparse_compiler
# TODO: Use linalg_structured_op to generate the kernel after making it to # TODO: Use linalg_structured_op to generate the kernel after making it to
# handle sparse tensor outputs. # handle sparse tensor outputs.
_KERNEL_STR = """ _KERNEL_STR = """
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#trait_add_elt = { #trait_add_elt = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
affine_map<(i,j) -> (i,j)>, // B affine_map<(i,j) -> (i,j)>, // B
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/taco/tools/mlir_pytaco_utils.py

Show First 20 Lines • Show All 249 Lines • ▼ Show 20 Linesdef _get_create_sparse_tensor_kernel(
# Get the MLIR text code to write the dimension sizes to the output buffer. # Get the MLIR text code to write the dimension sizes to the output buffer.
output_dims = "\n".join( output_dims = "\n".join(
map(lambda d: _output_one_dim(d, rank, shape, type), range(rank))) map(lambda d: _output_one_dim(d, rank, shape, type), range(rank)))
# Return the MLIR text kernel. # Return the MLIR text kernel.
return f""" return f"""
!Ptr = !llvm.ptr<i8> !Ptr = !llvm.ptr<i8>
#enc = #sparse_tensor.encoding<{{ #enc = #sparse_tensor.encoding<{{
dimLevelType = [ {sparsity} ] lvlTypes = [ {sparsity} ]
}}> }}>
func.func @{_ENTRY_NAME}(%filename: !Ptr) -> (tensor<{shape}x{type}, #enc>, memref<{rank}xindex>) func.func @{_ENTRY_NAME}(%filename: !Ptr) -> (tensor<{shape}x{type}, #enc>, memref<{rank}xindex>)
attributes {{ llvm.emit_c_interface }} {{ attributes {{ llvm.emit_c_interface }} {{
%t = sparse_tensor.new %filename : !Ptr to tensor<{shape}x{type}, #enc> %t = sparse_tensor.new %filename : !Ptr to tensor<{shape}x{type}, #enc>
%b = memref.alloc() : memref<{rank}xindex> %b = memref.alloc() : memref<{rank}xindex>
{output_dims} {output_dims}
return %t, %b : tensor<{shape}x{type}, #enc>, memref<{rank}xindex> return %t, %b : tensor<{shape}x{type}, #enc>, memref<{rank}xindex>
}}""" }}"""
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesdef _get_output_sparse_tensor_kernel(
sparsity = ", ".join( sparsity = ", ".join(
map(lambda s: '"compressed"' map(lambda s: '"compressed"'
if s.value else '"dense"', sparsity_codes)) if s.value else '"dense"', sparsity_codes))
# Return the MLIR text kernel. # Return the MLIR text kernel.
return f""" return f"""
!Ptr = !llvm.ptr<i8> !Ptr = !llvm.ptr<i8>
#enc = #sparse_tensor.encoding<{{ #enc = #sparse_tensor.encoding<{{
dimLevelType = [ {sparsity} ] lvlTypes = [ {sparsity} ]
}}> }}>
func.func @{_ENTRY_NAME}(%t: tensor<{shape}x{type}, #enc>, %filename: !Ptr) func.func @{_ENTRY_NAME}(%t: tensor<{shape}x{type}, #enc>, %filename: !Ptr)
attributes {{ llvm.emit_c_interface }} {{ attributes {{ llvm.emit_c_interface }} {{
sparse_tensor.out %t, %filename : tensor<{shape}x{type}, #enc>, !Ptr sparse_tensor.out %t, %filename : tensor<{shape}x{type}, #enc>, !Ptr
func.return func.return
}}""" }}"""
Show All 32 Lines

mlir/test/python/dialects/sparse_tensor/dialect.py

# RUN: %PYTHON %s | FileCheck %s # RUN: %PYTHON %s | FileCheck %s
from mlir.ir import * from mlir.ir import *
from mlir.dialects import sparse_tensor as st from mlir.dialects import sparse_tensor as st
def run(f): def run(f):
print("\nTEST:", f.__name__) print("\nTEST:", f.__name__)
f() f()
return f return f
# CHECK-LABEL: TEST: testEncodingAttr1D # CHECK-LABEL: TEST: testEncodingAttr1D
@run @run
def testEncodingAttr1D(): def testEncodingAttr1D():
with Context() as ctx: with Context() as ctx:
parsed = Attribute.parse('#sparse_tensor.encoding<{' parsed = Attribute.parse('#sparse_tensor.encoding<{'
' dimLevelType = [ "compressed" ],' ' lvlTypes = [ "compressed" ],'
' posWidth = 16,' ' posWidth = 16,'
' crdWidth = 32' ' crdWidth = 32'
'}>') '}>')
# CHECK: #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], posWidth = 16, crdWidth = 32 }> # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ], posWidth = 16, crdWidth = 32 }>
print(parsed) print(parsed)
casted = st.EncodingAttr(parsed) casted = st.EncodingAttr(parsed)
# CHECK: equal: True # CHECK: equal: True
print(f"equal: {casted == parsed}") print(f"equal: {casted == parsed}")
# CHECK: dim_level_types: [<DimLevelType.compressed: 8>] # CHECK: lvl_types: [<DimLevelType.compressed: 8>]
print(f"dim_level_types: {casted.dim_level_types}") print(f"lvl_types: {casted.lvl_types}")
# CHECK: dim_ordering: None # CHECK: dim_ordering: None
print(f"dim_ordering: {casted.dim_ordering}") print(f"dim_ordering: {casted.dim_ordering}")
# CHECK: pos_width: 16 # CHECK: pos_width: 16
print(f"pos_width: {casted.pos_width}") print(f"pos_width: {casted.pos_width}")
# CHECK: crd_width: 32 # CHECK: crd_width: 32
print(f"crd_width: {casted.crd_width}") print(f"crd_width: {casted.crd_width}")
created = st.EncodingAttr.get(casted.dim_level_types, None, None, 0, 0) created = st.EncodingAttr.get(casted.lvl_types, None, None, 0, 0)
# CHECK: #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
print(created) print(created)
# CHECK: created_equal: False # CHECK: created_equal: False
print(f"created_equal: {created == casted}") print(f"created_equal: {created == casted}")
# Verify that the factory creates an instance of the proper type. # Verify that the factory creates an instance of the proper type.
# CHECK: is_proper_instance: True # CHECK: is_proper_instance: True
print(f"is_proper_instance: {isinstance(created, st.EncodingAttr)}") print(f"is_proper_instance: {isinstance(created, st.EncodingAttr)}")
# CHECK: created_pos_width: 0 # CHECK: created_pos_width: 0
print(f"created_pos_width: {created.pos_width}") print(f"created_pos_width: {created.pos_width}")
# CHECK-LABEL: TEST: testEncodingAttr2D # CHECK-LABEL: TEST: testEncodingAttr2D
@run @run
def testEncodingAttr2D(): def testEncodingAttr2D():
with Context() as ctx: with Context() as ctx:
parsed = Attribute.parse('#sparse_tensor.encoding<{' parsed = Attribute.parse('#sparse_tensor.encoding<{'
' dimLevelType = [ "dense", "compressed" ],' ' lvlTypes = [ "dense", "compressed" ],'
' dimOrdering = affine_map<(d0, d1) -> (d1, d0)>,' ' dimOrdering = affine_map<(d0, d1) -> (d1, d0)>,'
' posWidth = 8,' ' posWidth = 8,'
' crdWidth = 32' ' crdWidth = 32'
'}>') '}>')
# CHECK: #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)>, posWidth = 8, crdWidth = 32 }> # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)>, posWidth = 8, crdWidth = 32 }>
print(parsed) print(parsed)
casted = st.EncodingAttr(parsed) casted = st.EncodingAttr(parsed)
# CHECK: equal: True # CHECK: equal: True
print(f"equal: {casted == parsed}") print(f"equal: {casted == parsed}")
# CHECK: dim_level_types: [<DimLevelType.dense: 4>, <DimLevelType.compressed: 8>] # CHECK: lvl_types: [<DimLevelType.dense: 4>, <DimLevelType.compressed: 8>]
print(f"dim_level_types: {casted.dim_level_types}") print(f"lvl_types: {casted.lvl_types}")
# CHECK: dim_ordering: (d0, d1) -> (d1, d0) # CHECK: dim_ordering: (d0, d1) -> (d1, d0)
print(f"dim_ordering: {casted.dim_ordering}") print(f"dim_ordering: {casted.dim_ordering}")
# CHECK: pos_width: 8 # CHECK: pos_width: 8
print(f"pos_width: {casted.pos_width}") print(f"pos_width: {casted.pos_width}")
# CHECK: crd_width: 32 # CHECK: crd_width: 32
print(f"crd_width: {casted.crd_width}") print(f"crd_width: {casted.crd_width}")
created = st.EncodingAttr.get(casted.dim_level_types, casted.dim_ordering, created = st.EncodingAttr.get(casted.lvl_types, casted.dim_ordering,
casted.higher_ordering, 8, 32) casted.higher_ordering, 8, 32)
# CHECK: #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)>, posWidth = 8, crdWidth = 32 }> # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)>, posWidth = 8, crdWidth = 32 }>
print(created) print(created)
# CHECK: created_equal: True # CHECK: created_equal: True
print(f"created_equal: {created == casted}") print(f"created_equal: {created == casted}")
# CHECK-LABEL: TEST: testEncodingAttrOnTensorType # CHECK-LABEL: TEST: testEncodingAttrOnTensorType
@run @run
def testEncodingAttrOnTensorType(): def testEncodingAttrOnTensorType():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
encoding = st.EncodingAttr( encoding = st.EncodingAttr(
Attribute.parse('#sparse_tensor.encoding<{' Attribute.parse('#sparse_tensor.encoding<{'
' dimLevelType = [ "compressed" ], ' ' lvlTypes = [ "compressed" ], '
' posWidth = 64,' ' posWidth = 64,'
' crdWidth = 32' ' crdWidth = 32'
'}>')) '}>'))
tt = RankedTensorType.get((1024,), F32Type.get(), encoding=encoding) tt = RankedTensorType.get((1024,), F32Type.get(), encoding=encoding)
# CHECK: tensor<1024xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], posWidth = 64, crdWidth = 32 }>> # CHECK: tensor<1024xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ], posWidth = 64, crdWidth = 32 }>>
print(tt) print(tt)
# CHECK: #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], posWidth = 64, crdWidth = 32 }> # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ], posWidth = 64, crdWidth = 32 }>
print(tt.encoding) print(tt.encoding)
assert tt.encoding == encoding assert tt.encoding == encoding