This is an archive of the discontinued LLVM Phabricator instance.

Differential D133684

[mlir][linalg] Retire Linalg's StrategyVectorizePass
ClosedPublic

Authored by guraypp on Sep 12 2022, 2:04 AM.

Details

Reviewers
nicolasvasilache
springerm
Commits
rG51e09465913a: [mlir][linalg] Retire Linalg's StrategyVectorizePass
Summary

We retire linalg's strategy vectorize pass. Our goal is to use transform dialect instead of passes.

Diff Detail

Event Timeline

guraypp created this revision.Sep 12 2022, 2:04 AM
Herald added a project: Restricted Project. · View Herald TranscriptSep 12 2022, 2:04 AM
Herald added subscribers: bzcheeseman, sdasgup3, wenzhicui and 19 others. · View Herald Transcript
guraypp requested review of this revision.Sep 12 2022, 2:04 AM
Herald added a project: Restricted Project. · View Herald TranscriptSep 12 2022, 2:04 AM
Herald added subscribers: • pcwang-thead, limo1996, stephenneuendorffer. · View Herald Transcript
Harbormaster completed remote builds in B186118: Diff 459415.Sep 12 2022, 2:20 AM
nicolasvasilache accepted this revision.Sep 12 2022, 5:28 AM
This revision is now accepted and ready to land.Sep 12 2022, 5:28 AM
guraypp added a child revision: D133699: [mlir][linalg] Retire Linalg's Vectorization Pattern.Sep 12 2022, 7:25 AM
guraypp updated this revision to Diff 460327.Sep 15 2022, 1:46 AM

did clang-format and rebase main

This revision was landed with ongoing or failed builds.Sep 15 2022, 2:12 AM
Closed by commit rG51e09465913a: [mlir][linalg] Retire Linalg's StrategyVectorizePass (authored by guraypp). · Explain Why
This revision was automatically updated to reflect the committed changes.
guraypp added a commit: rG51e09465913a: [mlir][linalg] Retire Linalg's StrategyVectorizePass.
Harbormaster completed remote builds in B186805: Diff 460327.Sep 15 2022, 2:58 AM

Revision Contents

PathSize
mlir/
include/
mlir/
Dialect/
Linalg/
9 lines
15 lines
Transforms/
45 lines
lib/
Dialect/
Linalg/
Transforms/
66 lines

Diff 460330

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

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 Lines
/// Create a LinalgStrategyPeelPass. /// Create a LinalgStrategyPeelPass.
std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyPeelPass( std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyPeelPass(
StringRef opName = "", StringRef opName = "",
const linalg::LinalgPeelOptions &opt = linalg::LinalgPeelOptions(), const linalg::LinalgPeelOptions &opt = linalg::LinalgPeelOptions(),
const linalg::LinalgTransformationFilter &filter = const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter()); linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyVectorizePass.
std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyVectorizePass(
StringRef opName = "",
linalg::LinalgVectorizationOptions opt =
linalg::LinalgVectorizationOptions(),
const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter(),
bool padVectorize = false);
/// Create a LinalgStrategyLowerVectorsPass. /// Create a LinalgStrategyLowerVectorsPass.
std::unique_ptr<OperationPass<func::FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
createLinalgStrategyLowerVectorsPass( createLinalgStrategyLowerVectorsPass(
linalg::LinalgVectorLoweringOptions opt = linalg::LinalgVectorLoweringOptions opt =
linalg::LinalgVectorLoweringOptions(), linalg::LinalgVectorLoweringOptions(),
const linalg::LinalgTransformationFilter &filter = const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter()); linalg::LinalgTransformationFilter());
Show All 15 Lines

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

Show First 20 Lines • Show All 232 Lines • ▼ Show 20 Linesdef LinalgStrategyPeelPass
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 LinalgStrategyVectorizePass
: Pass<"linalg-strategy-vectorize-pass", "func::FuncOp"> {
let summary = "Configurable pass to apply pattern-based linalg vectorization.";
let constructor = "mlir::createLinalgStrategyVectorizePass()";
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.">,
Option<"vectorizePadding", "vectorize-padding", "bool", "false",
"Enable vectorization of padding ops.">,
];
}
def LinalgStrategyLowerVectorsPass def LinalgStrategyLowerVectorsPass
: Pass<"linalg-strategy-lower-vectors-pass", "func::FuncOp"> { : Pass<"linalg-strategy-lower-vectors-pass", "func::FuncOp"> {
let summary = "Configurable pass to lower vector operations."; let summary = "Configurable pass to lower vector operations.";
let constructor = "mlir::createLinalgStrategyLowerVectorsPass()"; let constructor = "mlir::createLinalgStrategyLowerVectorsPass()";
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=*/"",
"Which func op is the anchor to latch on.">, "Which func op is the anchor to latch on.">,
Show All 15 Lines

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

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Lines void addToPassPipeline(OpPassManager &pm,
pm.addPass(createLinalgStrategyPeelPass(opName, options, m)); pm.addPass(createLinalgStrategyPeelPass(opName, options, m));
} }
private: private:
std::string opName; std::string opName;
linalg::LinalgPeelOptions options; linalg::LinalgPeelOptions options;
}; };
/// Represent one application of createLinalgStrategyVectorizePass.
struct Vectorize : public Transformation {
explicit Vectorize(linalg::LinalgVectorizationOptions options,
LinalgTransformationFilter::FilterFunction f = nullptr,
bool padVectorize = false)
: Transformation(std::move(f)), options(options),
vectorizePadding(padVectorize) {}
Vectorize(StringRef name, linalg::LinalgVectorizationOptions options,
LinalgTransformationFilter::FilterFunction f = nullptr,
bool padVectorize = false)
: Transformation(std::move(f)), opName(name), options(options),
vectorizePadding(padVectorize) {}
void addToPassPipeline(OpPassManager &pm,
LinalgTransformationFilter m) const override {
pm.addPass(createLinalgStrategyVectorizePass(opName, options, m,
vectorizePadding));
}
private:
std::string opName;
linalg::LinalgVectorizationOptions options;
bool vectorizePadding;
};
/// Represent one application of createLinalgStrategyLowerVectorsPass. /// Represent one application of createLinalgStrategyLowerVectorsPass.
struct VectorLowering : public Transformation { struct VectorLowering : public Transformation {
explicit VectorLowering( explicit VectorLowering(
linalg::LinalgVectorLoweringOptions options, linalg::LinalgVectorLoweringOptions options,
LinalgTransformationFilter::FilterFunction f = nullptr) LinalgTransformationFilter::FilterFunction f = nullptr)
: Transformation(std::move(f)), options(options) {} : Transformation(std::move(f)), options(options) {}
void addToPassPipeline(OpPassManager &pm, void addToPassPipeline(OpPassManager &pm,
▲ Show 20 Lines • Show All 49 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 patterns to decompose convolutions. /// Append patterns to decompose convolutions.
CodegenStrategy & CodegenStrategy &
decompose(const LinalgTransformationFilter::FilterFunction &f = nullptr) { decompose(const LinalgTransformationFilter::FilterFunction &f = nullptr) {
transformationSequence.emplace_back(std::make_unique<Decompose>(f)); transformationSequence.emplace_back(std::make_unique<Decompose>(f));
return *this; return *this;
} }
/// Conditionally append patterns to decompose convolutions. /// Conditionally append patterns to decompose convolutions.
CodegenStrategy & CodegenStrategy &
Show All 9 Lines peel(StringRef opName, const LinalgPeelOptions &options,
return *this; return *this;
} }
/// Conditionally append a pattern to peel 'LinalgOpType'. /// Conditionally append a pattern to peel 'LinalgOpType'.
CodegenStrategy & CodegenStrategy &
peelIf(bool b, StringRef opName, const LinalgPeelOptions &options, peelIf(bool b, StringRef opName, const LinalgPeelOptions &options,
LinalgTransformationFilter::FilterFunction f = nullptr) { LinalgTransformationFilter::FilterFunction f = nullptr) {
return b ? peel(opName, options, std::move(f)) : *this; return b ? peel(opName, options, std::move(f)) : *this;
} }
/// Append a pattern to rewrite `LinalgOpType` as a vector operation.
CodegenStrategy &
vectorize(StringRef opName,
const LinalgTransformationFilter::FilterFunction &f = nullptr,
bool vectorizePadding = false) {
transformationSequence.emplace_back(std::make_unique<Vectorize>(
opName, linalg::LinalgVectorizationOptions(), f, vectorizePadding));
return *this;
}
/// Conditionally append a pattern to rewrite `LinalgOpType` as a vector
/// operation.
CodegenStrategy &
vectorizeIf(bool b, StringRef opName,
LinalgTransformationFilter::FilterFunction f = nullptr,
bool vectorizePadding = false) {
return b ? vectorize(opName, std::move(f), vectorizePadding) : *this;
}
/// Append a pattern to lower all vector operations. /// Append a pattern to lower all vector operations.
CodegenStrategy &vectorLowering(LinalgVectorLoweringOptions options) { CodegenStrategy &vectorLowering(LinalgVectorLoweringOptions options) {
transformationSequence.emplace_back( transformationSequence.emplace_back(
std::make_unique<VectorLowering>(options)); std::make_unique<VectorLowering>(options));
return *this; return *this;
} }
/// Configure the post staged-patterns global enabling passes options. /// Configure the post staged-patterns global enabling passes options.
CodegenStrategy & CodegenStrategy &
Show All 21 Lines

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

Show All 34 Lines
#include <utility> #include <utility>
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_LINALGSTRATEGYTILEANDFUSEPASS #define GEN_PASS_DEF_LINALGSTRATEGYTILEANDFUSEPASS
#define GEN_PASS_DEF_LINALGSTRATEGYTILEPASS #define GEN_PASS_DEF_LINALGSTRATEGYTILEPASS
#define GEN_PASS_DEF_LINALGSTRATEGYPADPASS #define GEN_PASS_DEF_LINALGSTRATEGYPADPASS
#define GEN_PASS_DEF_LINALGSTRATEGYDECOMPOSEPASS #define GEN_PASS_DEF_LINALGSTRATEGYDECOMPOSEPASS
#define GEN_PASS_DEF_LINALGSTRATEGYPEELPASS #define GEN_PASS_DEF_LINALGSTRATEGYPEELPASS
#define GEN_PASS_DEF_LINALGSTRATEGYVECTORIZEPASS
#define GEN_PASS_DEF_LINALGSTRATEGYLOWERVECTORSPASS #define GEN_PASS_DEF_LINALGSTRATEGYLOWERVECTORSPASS
#define GEN_PASS_DEF_LINALGSTRATEGYREMOVEMARKERSPASS #define GEN_PASS_DEF_LINALGSTRATEGYREMOVEMARKERSPASS
#include "mlir/Dialect/Linalg/Passes.h.inc" #include "mlir/Dialect/Linalg/Passes.h.inc"
} // namespace mlir } // namespace mlir
using namespace mlir; using namespace mlir;
using namespace mlir::vector; using namespace mlir::vector;
using namespace linalg; using namespace linalg;
▲ Show 20 Lines • Show All 158 Lines • ▼ Show 20 Lines if (failed(
applyPatternsAndFoldGreedily(funcOp, std::move(peelingPatterns)))) applyPatternsAndFoldGreedily(funcOp, std::move(peelingPatterns))))
return signalPassFailure(); return signalPassFailure();
} }
LinalgPeelOptions options; LinalgPeelOptions options;
LinalgTransformationFilter filter; LinalgTransformationFilter filter;
}; };
/// Configurable pass to apply pattern-based linalg vectorization.
struct LinalgStrategyVectorizePass
: public impl::LinalgStrategyVectorizePassBase<
LinalgStrategyVectorizePass> {
LinalgStrategyVectorizePass() = default;
LinalgStrategyVectorizePass(StringRef opName, LinalgVectorizationOptions opt,
LinalgTransformationFilter filt,
bool padVectorize = false)
: options(opt), filter(std::move(filt)) {
this->anchorOpName.setValue(opName.str());
this->vectorizePadding.setValue(padVectorize);
}
void runOnOperation() override {
auto funcOp = getOperation();
if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
return;
RewritePatternSet vectorizationPatterns(funcOp.getContext());
if (!anchorOpName.empty()) {
vectorizationPatterns.add<LinalgVectorizationPattern>(
anchorOpName, funcOp.getContext(), options, filter);
} else {
vectorizationPatterns.add<LinalgVectorizationPattern>(funcOp.getContext(),
filter, options);
}
vector::populateVectorTransferPermutationMapLoweringPatterns(
vectorizationPatterns);
vector::populateVectorReductionToContractPatterns(vectorizationPatterns);
vectorizationPatterns.add<linalg::LinalgCopyVTRForwardingPattern,
linalg::LinalgCopyVTWForwardingPattern>(
funcOp.getContext(), /*benefit=*/2);
TransferReadOp::getCanonicalizationPatterns(vectorizationPatterns,
funcOp.getContext());
TransferWriteOp::getCanonicalizationPatterns(vectorizationPatterns,
funcOp.getContext());
(void)applyPatternsAndFoldGreedily(funcOp,
std::move(vectorizationPatterns));
// Apply the pad tensor op vectorization separately to avoid running the
// GenericPadOpVectorizationPattern too early.
// TODO: Improve once we have better infrastructure to control pattern
// application.
if (vectorizePadding) {
RewritePatternSet patterns(funcOp.getContext());
linalg::populatePadOpVectorizationPatterns(patterns);
(void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
}
}
LinalgVectorizationOptions options;
LinalgTransformationFilter filter;
};
/// Configurable pass to lower vector operations. /// Configurable pass to lower vector operations.
struct LinalgStrategyLowerVectorsPass struct LinalgStrategyLowerVectorsPass
: public impl::LinalgStrategyLowerVectorsPassBase< : public impl::LinalgStrategyLowerVectorsPassBase<
LinalgStrategyLowerVectorsPass> { LinalgStrategyLowerVectorsPass> {
LinalgStrategyLowerVectorsPass(LinalgVectorLoweringOptions opt, LinalgStrategyLowerVectorsPass(LinalgVectorLoweringOptions opt,
LinalgTransformationFilter filt) LinalgTransformationFilter filt)
: options(opt), filter(std::move(filt)) {} : options(opt), filter(std::move(filt)) {}
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines
/// Create a LinalgStrategyPeelPass. /// Create a LinalgStrategyPeelPass.
std::unique_ptr<OperationPass<func::FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
mlir::createLinalgStrategyPeelPass(StringRef opName, mlir::createLinalgStrategyPeelPass(StringRef opName,
const LinalgPeelOptions &opt, const LinalgPeelOptions &opt,
const LinalgTransformationFilter &filter) { const LinalgTransformationFilter &filter) {
return std::make_unique<LinalgStrategyPeelPass>(opName, opt, filter); return std::make_unique<LinalgStrategyPeelPass>(opName, opt, filter);
} }
/// Create a LinalgStrategyVectorizePass.
std::unique_ptr<OperationPass<func::FuncOp>>
mlir::createLinalgStrategyVectorizePass(
StringRef opName, LinalgVectorizationOptions opt,
const LinalgTransformationFilter &filter, bool padVectorize) {
return std::make_unique<LinalgStrategyVectorizePass>(opName, opt, filter,
padVectorize);
}
/// Create a LinalgStrategyLowerVectorsPass. /// Create a LinalgStrategyLowerVectorsPass.
std::unique_ptr<OperationPass<func::FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
mlir::createLinalgStrategyLowerVectorsPass( mlir::createLinalgStrategyLowerVectorsPass(
LinalgVectorLoweringOptions opt, const LinalgTransformationFilter &filter) { LinalgVectorLoweringOptions opt, const LinalgTransformationFilter &filter) {
return std::make_unique<LinalgStrategyLowerVectorsPass>(opt, filter); return std::make_unique<LinalgStrategyLowerVectorsPass>(opt, filter);
} }
/// Create a LinalgStrategyRemoveMarkersPass. /// Create a LinalgStrategyRemoveMarkersPass.
std::unique_ptr<OperationPass<func::FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
mlir::createLinalgStrategyRemoveMarkersPass() { mlir::createLinalgStrategyRemoveMarkersPass() {
return std::make_unique<LinalgStrategyRemoveMarkersPass>(); return std::make_unique<LinalgStrategyRemoveMarkersPass>();
} }