This is an archive of the discontinued LLVM Phabricator instance.

Differential D132363

[mlir][Linalg] Retire LinalgStrategyGeneralizePass
ClosedPublic

Authored by guraypp on Aug 22 2022, 2:58 AM.

Details

Reviewers
nicolasvasilache
springerm
Commits
rGdb0c7dde6b18: [mlir][Linalg] Retire LinalgStrategyGeneralizePass
Summary

This revision deletes LinalgStrategyGeneralizePass.

Context: https://discourse.llvm.org/t/psa-retire-linalg-filter-based-patterns/63785

Diff Detail

Event Timeline

guraypp created this revision.Aug 22 2022, 2:58 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 22 2022, 2:58 AM
Herald added subscribers: bzcheeseman, sdasgup3, wenzhicui and 19 others. · View Herald Transcript
guraypp requested review of this revision.Aug 22 2022, 2:58 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 22 2022, 2:58 AM
Herald added subscribers: limo1996, stephenneuendorffer. · View Herald Transcript
Harbormaster completed remote builds in B182540: Diff 454431.Aug 22 2022, 3:24 AM
guraypp updated this revision to Diff 454453.Aug 22 2022, 4:48 AM

run clang-format

Harbormaster completed remote builds in B182558: Diff 454453.Aug 22 2022, 4:48 AM
guraypp updated this revision to Diff 454497.Aug 22 2022, 7:12 AM

merge

Harbormaster completed remote builds in B182592: Diff 454497.Aug 22 2022, 7:13 AM
guraypp updated this revision to Diff 454503.Aug 22 2022, 7:49 AM

merge

Harbormaster completed remote builds in B182599: Diff 454503.Aug 22 2022, 7:50 AM
nicolasvasilache added a comment.Aug 22 2022, 2:38 PM

Seems like your last merge operation dropped everything?
You want to git rebase -i most of the time.

guraypp updated this revision to Diff 454727.Aug 23 2022, 1:04 AM

update revision

guraypp updated this revision to Diff 454734.Aug 23 2022, 1:20 AM

remove codes in CodegenStrategy

nicolasvasilache accepted this revision.Aug 23 2022, 1:27 AM

Looks good!

This revision is now accepted and ready to land.Aug 23 2022, 1:27 AM
This revision was landed with ongoing or failed builds.Aug 23 2022, 1:31 AM
Closed by commit rGdb0c7dde6b18: [mlir][Linalg] Retire LinalgStrategyGeneralizePass (authored by guraypp). · Explain Why
This revision was automatically updated to reflect the committed changes.
guraypp added a commit: rGdb0c7dde6b18: [mlir][Linalg] Retire LinalgStrategyGeneralizePass.
Harbormaster completed remote builds in B182769: Diff 454734.Aug 23 2022, 2:13 AM

Revision Contents

PathSize
mlir/
include/
mlir/
Dialect/
Linalg/
5 lines
13 lines
Transforms/
31 lines
lib/
Dialect/
Linalg/
Transforms/
39 lines

Diff 454431

mlir/include/mlir/Dialect/Linalg/Passes.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
/// Create a LinalgStrategyPadPass. /// Create a LinalgStrategyPadPass.
std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyPadPass( std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyPadPass(
StringRef opName = "", StringRef opName = "",
const linalg::LinalgPaddingOptions &opt = linalg::LinalgPaddingOptions(), const linalg::LinalgPaddingOptions &opt = linalg::LinalgPaddingOptions(),
const linalg::LinalgTransformationFilter &filter = const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter()); linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyGeneralizePass.
std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyGeneralizePass(
StringRef opName = "", const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyDecomposePass. /// Create a LinalgStrategyDecomposePass.
// TODO: if/when we need finer control add an `opName` parameter. // TODO: if/when we need finer control add an `opName` parameter.
std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyDecomposePass( std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyDecomposePass(
const linalg::LinalgTransformationFilter &filter = const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter()); linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyInterchangePass. /// Create a LinalgStrategyInterchangePass.
std::unique_ptr<OperationPass<func::FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Linalg/Passes.td

Show First 20 Lines • Show All 204 Lines • ▼ Show 20 Linesdef LinalgStrategyPadPass
let options = [ let options = [
Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"", Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
"Which func op is the anchor to latch on.">, "Which func op is the anchor to latch on.">,
Option<"anchorOpName", "anchor-op", "std::string", /*default=*/"", Option<"anchorOpName", "anchor-op", "std::string", /*default=*/"",
"Which linalg op within the func is the anchor to latch on.">, "Which linalg op within the func is the anchor to latch on.">,
]; ];
} }
def LinalgStrategyGeneralizePass
: Pass<"linalg-strategy-generalize-pass", "func::FuncOp"> {
let summary = "Configurable pass to apply pattern-based generalization.";
let constructor = "mlir::createLinalgStrategyGeneralizePass()";
let dependentDialects = ["linalg::LinalgDialect"];
let options = [
Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
"Which func op is the anchor to latch on.">,
Option<"anchorOpName", "anchor-op", "std::string", /*default=*/"",
"Which linalg op within the func is the anchor to latch on.">,
];
}
// TODO: if/when we need finer control add an anchorOp option. // TODO: if/when we need finer control add an anchorOp option.
def LinalgStrategyDecomposePass def LinalgStrategyDecomposePass
: Pass<"linalg-strategy-decompose-pass", "func::FuncOp"> { : Pass<"linalg-strategy-decompose-pass", "func::FuncOp"> {
let summary = "Configurable pass to apply pattern-based generalization."; let summary = "Configurable pass to apply pattern-based generalization.";
let constructor = "mlir::createLinalgStrategyDecomposePass()"; let constructor = "mlir::createLinalgStrategyDecomposePass()";
let dependentDialects = ["linalg::LinalgDialect"]; let dependentDialects = ["linalg::LinalgDialect"];
let options = [ let options = [
Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"", Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Linalg/Transforms/CodegenStrategy.h

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines void addToPassPipeline(OpPassManager &pm,
pm.addPass(createLinalgStrategyPadPass(opName, options, m)); pm.addPass(createLinalgStrategyPadPass(opName, options, m));
} }
private: private:
std::string opName; std::string opName;
linalg::LinalgPaddingOptions options; linalg::LinalgPaddingOptions options;
}; };
/// Represent one application of createLinalgStrategyGeneralizePass.
struct Generalize : public Transformation {
explicit Generalize(StringRef name,
LinalgTransformationFilter::FilterFunction f = nullptr)
: Transformation(std::move(f)), opName(name) {}
void addToPassPipeline(OpPassManager &pm,
LinalgTransformationFilter m) const override {
pm.addPass(createLinalgStrategyGeneralizePass(opName, m));
}
private:
std::string opName;
};
/// Represent one application of createLinalgStrategyInterchangePass. /// Represent one application of createLinalgStrategyInterchangePass.
struct Interchange : public Transformation { struct Interchange : public Transformation {
explicit Interchange(ArrayRef<int64_t> iteratorInterchange, explicit Interchange(ArrayRef<int64_t> iteratorInterchange,
LinalgTransformationFilter::FilterFunction f = nullptr) LinalgTransformationFilter::FilterFunction f = nullptr)
: Transformation(std::move(f)), : Transformation(std::move(f)),
iteratorInterchange(iteratorInterchange.begin(), iteratorInterchange(iteratorInterchange.begin(),
iteratorInterchange.end()) {} iteratorInterchange.end()) {}
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Lines pad(StringRef opName, const linalg::LinalgPaddingOptions &options,
return *this; return *this;
} }
/// Conditionally append a pattern to pad and hoist the operands of Op /// Conditionally append a pattern to pad and hoist the operands of Op
/// `opName` with padding `options`. /// `opName` with padding `options`.
CodegenStrategy & CodegenStrategy &
padIf(bool b, StringRef opName, linalg::LinalgPaddingOptions options, padIf(bool b, StringRef opName, linalg::LinalgPaddingOptions options,
LinalgTransformationFilter::FilterFunction f = nullptr) { LinalgTransformationFilter::FilterFunction f = nullptr) {
return b ? pad(opName, std::move(options), std::move(f)) : *this; return b ? pad(opName, std::move(options), std::move(f)) : *this;
} }
/// Append a pattern to generalize named operations.
CodegenStrategy &
generalize(StringRef opName,
const LinalgTransformationFilter::FilterFunction &f = nullptr) {
transformationSequence.emplace_back(
std::make_unique<Generalize>(opName, f));
return *this;
}
/// Conditionally append a pattern to generalize named operations.
CodegenStrategy &
generalizeIf(bool b, StringRef opName,
LinalgTransformationFilter::FilterFunction f = nullptr) {
return b ? generalize(opName, std::move(f)) : *this;
}
/// Append a pattern to interchange iterators. /// Append a pattern to interchange iterators.
CodegenStrategy & CodegenStrategy &
interchange(ArrayRef<int64_t> iteratorInterchange, interchange(ArrayRef<int64_t> iteratorInterchange,
const LinalgTransformationFilter::FilterFunction &f = nullptr) { const LinalgTransformationFilter::FilterFunction &f = nullptr) {
transformationSequence.emplace_back( transformationSequence.emplace_back(
std::make_unique<Interchange>(iteratorInterchange, f)); std::make_unique<Interchange>(iteratorInterchange, f));
return *this; return *this;
} }
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/LinalgStrategyPasses.cpp

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Lines void runOnOperation() override {
} }
(void)applyPatternsAndFoldGreedily(funcOp, std::move(paddingPattern)); (void)applyPatternsAndFoldGreedily(funcOp, std::move(paddingPattern));
} }
LinalgPaddingOptions options; LinalgPaddingOptions options;
LinalgTransformationFilter filter; LinalgTransformationFilter filter;
}; };
/// Configurable pass to apply pattern-based linalg generalization.
struct LinalgStrategyGeneralizePass
: public LinalgStrategyGeneralizePassBase<LinalgStrategyGeneralizePass> {
LinalgStrategyGeneralizePass() = default;
LinalgStrategyGeneralizePass(StringRef opName,
LinalgTransformationFilter filter)
: filter(std::move(filter)) {
this->anchorOpName.setValue(opName.str());
}
void runOnOperation() override {
auto funcOp = getOperation();
if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
return;
RewritePatternSet generalizationPattern(funcOp.getContext());
if (!anchorOpName.empty()) {
generalizationPattern.add<LinalgGeneralizationPattern>(
anchorOpName, funcOp.getContext(), filter);
} else {
generalizationPattern.add<LinalgGeneralizationPattern>(
funcOp.getContext(), filter);
}
if (failed(applyPatternsAndFoldGreedily(funcOp,
std::move(generalizationPattern))))
signalPassFailure();
}
LinalgTransformationFilter filter;
};
/// Configurable pass to apply lowering of coarser-grained named linalg ops into /// Configurable pass to apply lowering of coarser-grained named linalg ops into
/// finer-grained named versions. /// finer-grained named versions.
struct LinalgStrategyDecomposePass struct LinalgStrategyDecomposePass
: public LinalgStrategyDecomposePassBase<LinalgStrategyDecomposePass> { : public LinalgStrategyDecomposePassBase<LinalgStrategyDecomposePass> {
LinalgStrategyDecomposePass() = default; LinalgStrategyDecomposePass() = default;
▲ Show 20 Lines • Show All 286 Lines • ▼ Show 20 Lines
/// Create a LinalgStrategyPadPass. /// Create a LinalgStrategyPadPass.
std::unique_ptr<OperationPass<func::FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
mlir::createLinalgStrategyPadPass(StringRef opName, mlir::createLinalgStrategyPadPass(StringRef opName,
const LinalgPaddingOptions &opt, const LinalgPaddingOptions &opt,
const LinalgTransformationFilter &filter) { const LinalgTransformationFilter &filter) {
return std::make_unique<LinalgStrategyPadPass>(opName, opt, filter); return std::make_unique<LinalgStrategyPadPass>(opName, opt, filter);
} }
/// Create a LinalgStrategyGeneralizePass.
std::unique_ptr<OperationPass<func::FuncOp>>
mlir::createLinalgStrategyGeneralizePass(
StringRef opName, const LinalgTransformationFilter &filter) {
return std::make_unique<LinalgStrategyGeneralizePass>(opName, filter);
}
/// Create a LinalgStrategyDecomposePass. /// Create a LinalgStrategyDecomposePass.
// TODO: if/when we need finer control add an `opName` parameter. // TODO: if/when we need finer control add an `opName` parameter.
std::unique_ptr<OperationPass<func::FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
mlir::createLinalgStrategyDecomposePass( mlir::createLinalgStrategyDecomposePass(
const LinalgTransformationFilter &filter) { const LinalgTransformationFilter &filter) {
return std::make_unique<LinalgStrategyDecomposePass>(filter); return std::make_unique<LinalgStrategyDecomposePass>(filter);
} }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines