This is an archive of the discontinued LLVM Phabricator instance.

Differential D135759

[mlir][Linalg] NFC - Drop CodegenStrategy and remaining strategy passes
ClosedPublic

Authored by nicolasvasilache on Oct 12 2022, 3:27 AM.

Details

Reviewers
ftynse
springerm
mravishankar
ThomasRaoux
Commits
rG15faa55f6576: [mlir][Linalg] NFC - Drop CodegenStrategy and remaining strategy passes

Diff Detail

Revision Contents

PathSize
mlir/
include/
mlir/
Dialect/
Linalg/
14 lines
11 lines
Transforms/
lib/
Dialect/
Linalg/
Transforms/
2 lines

Diff 467090

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

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
/// operations. /// operations.
std::unique_ptr<OperationPass<func::FuncOp>> createLinalgGeneralizationPass(); std::unique_ptr<OperationPass<func::FuncOp>> createLinalgGeneralizationPass();
/// Create a pass to convert Linalg operations to equivalent operations that /// Create a pass to convert Linalg operations to equivalent operations that
/// work on primitive types, if possible. /// work on primitive types, if possible.
std::unique_ptr<Pass> createLinalgDetensorizePass(); std::unique_ptr<Pass> createLinalgDetensorizePass();
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Linalg strategy passes.
//===----------------------------------------------------------------------===//
/// Create a LinalgStrategyTilePass.
std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyTilePass(
StringRef opName = "",
const linalg::LinalgTilingOptions &opt = linalg::LinalgTilingOptions(),
const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyRemoveMarkersPass.
std::unique_ptr<OperationPass<func::FuncOp>>
createLinalgStrategyRemoveMarkersPass();
//===----------------------------------------------------------------------===//
// Registration // Registration
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Generate the code for registering passes. /// Generate the code for registering passes.
#define GEN_PASS_REGISTRATION #define GEN_PASS_REGISTRATION
#include "mlir/Dialect/Linalg/Passes.h.inc" #include "mlir/Dialect/Linalg/Passes.h.inc"
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_LINALG_PASSES_H_ #endif // MLIR_DIALECT_LINALG_PASSES_H_

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

Show First 20 Lines • Show All 140 Lines • ▼ Show 20 Linesdef LinalgDetensorize : Pass<"linalg-detensorize", ""> {
let options = [ let options = [
Option<"aggressiveMode", "aggressive-mode", "bool", /*default=*/"false", Option<"aggressiveMode", "aggressive-mode", "bool", /*default=*/"false",
"Detensorize all ops that qualify for detensoring along with branch" "Detensorize all ops that qualify for detensoring along with branch"
" operands and basic-block arguments."> " operands and basic-block arguments.">
]; ];
} }
def LinalgStrategyRemoveMarkersPass
: Pass<"linalg-strategy-remove-markers-pass", "func::FuncOp"> {
let summary = "Cleanup pass that drops markers.";
let constructor = "mlir::createLinalgStrategyRemoveMarkersPass()";
let dependentDialects = ["linalg::LinalgDialect"];
let options = [
Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
"Which func op is the anchor to latch on.">,
];
}
#endif // MLIR_DIALECT_LINALG_PASSES #endif // MLIR_DIALECT_LINALG_PASSES

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

  • This file was deleted.
//===- CodegenStrategy.h - Linalg programmable codegen strategy -*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_LINALG_TRANSFORMS_CODEGENSTRATEGY_H_
#define MLIR_DIALECT_LINALG_TRANSFORMS_CODEGENSTRATEGY_H_
#include <utility>
#include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Pass/PassManager.h"
namespace mlir {
namespace linalg {
/// Abstract Transformation class applied in a sequence that also handles state
/// through markers.
struct Transformation {
explicit Transformation(LinalgTransformationFilter::FilterFunction f)
: filter(std::move(f)) {}
virtual ~Transformation() = default;
virtual void addToPassPipeline(OpPassManager &pm,
LinalgTransformationFilter m) const = 0;
LinalgTransformationFilter::FilterFunction filter = nullptr;
};
/// Codegen strategy controls how a Linalg op is progressively lowered.
struct CodegenStrategy {
/// Configure the post staged-patterns global enabling passes options.
CodegenStrategy &
setVectorTransferToSCFOptions(LinalgEnablingOptions options) {
linalgEnablingOptions = options;
return *this;
}
/// Apply the transformation patterns in sequence with cleanup
/// transformations interleaved.
void configurePassPipeline(OpPassManager &pm, MLIRContext *context,
bool addEnablePass = true) const;
private:
LogicalResult postPatternTransforms(Operation *func) const;
LinalgEnablingOptions linalgEnablingOptions;
SmallVector<std::unique_ptr<Transformation>, 4> transformationSequence;
};
} // namespace linalg
} // namespace mlir
#endif // MLIR_DIALECT_LINALG_TRANSFORMS_CODEGENSTRATEGY_H_

mlir/lib/Dialect/Linalg/Transforms/CMakeLists.txt

add_mlir_dialect_library(MLIRLinalgTransforms add_mlir_dialect_library(MLIRLinalgTransforms
BubbleUpExtractSlice.cpp BubbleUpExtractSlice.cpp
BufferizableOpInterfaceImpl.cpp BufferizableOpInterfaceImpl.cpp
Bufferize.cpp Bufferize.cpp
CodegenStrategy.cpp
ConstantFold.cpp ConstantFold.cpp
DecomposeLinalgOps.cpp DecomposeLinalgOps.cpp
Detensorize.cpp Detensorize.cpp
DropUnitDims.cpp DropUnitDims.cpp
ElementwiseOpFusion.cpp ElementwiseOpFusion.cpp
ElementwiseToLinalg.cpp ElementwiseToLinalg.cpp
FusePadOpWithLinalgProducer.cpp FusePadOpWithLinalgProducer.cpp
Fusion.cpp Fusion.cpp
FusionOnTensors.cpp FusionOnTensors.cpp
Generalization.cpp Generalization.cpp
Hoisting.cpp Hoisting.cpp
HoistPadding.cpp HoistPadding.cpp
InlineScalarOperands.cpp InlineScalarOperands.cpp
Interchange.cpp Interchange.cpp
Loops.cpp Loops.cpp
LinalgStrategyPasses.cpp
NamedOpConversions.cpp NamedOpConversions.cpp
Promotion.cpp Promotion.cpp
Split.cpp Split.cpp
SplitReduction.cpp SplitReduction.cpp
SwapExtractSliceWithFillPatterns.cpp SwapExtractSliceWithFillPatterns.cpp
Tiling.cpp Tiling.cpp
TilingInterfaceImpl.cpp TilingInterfaceImpl.cpp
Transforms.cpp Transforms.cpp
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

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

  • This file was deleted.
//===- CodegenStrategy.cpp - Linalg programmable codegen strategy ---------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements logic and helpers to expose Linalg transforms as
// composable rewrite patterns through a programmable CodegenStrategy object.
//
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Transforms/CodegenStrategy.h"
#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/Hoisting.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Transforms/VectorTransforms.h"
#include "mlir/Pass/PassManager.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Transforms/Passes.h"
using namespace mlir;
using namespace mlir::linalg;
#define DEBUG_TYPE "linalg-codegen-strategy"
void mlir::linalg::CodegenStrategy::configurePassPipeline(
OpPassManager &pm, MLIRContext *context, bool addEnablePass) const {
for (unsigned stepCount = 0, e = transformationSequence.size(); stepCount < e;
++stepCount) {
const std::unique_ptr<Transformation> &t =
transformationSequence[stepCount];
std::string currentStr = std::to_string(stepCount);
auto currentState = StringAttr::get(context, currentStr);
std::string nextStr = std::to_string(stepCount + 1);
auto nextState = StringAttr::get(context, nextStr);
auto filter = (currentState.str() == std::to_string(0))
? linalg::LinalgTransformationFilter(
t->filter, ArrayRef<StringAttr>{}, nextState)
: linalg::LinalgTransformationFilter(
t->filter, currentState, nextState);
t->addToPassPipeline(pm, filter);
}
pm.addPass(createLinalgStrategyRemoveMarkersPass());
}

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

  • This file was deleted.
//===- LinalgStrategyPasses.cpp - Implementation of Linalg passes ---------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements a configurable pass that can apply patterns liberally
// and be plugged in a pass pipeline.
//
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Hoisting.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Vector/Transforms/VectorTransforms.h"
#include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h"
#include "mlir/Pass/PassManager.h"
#include "mlir/Support/LLVM.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Transforms/LoopInvariantCodeMotionUtils.h"
#include "mlir/Transforms/Passes.h"
#include <utility>
namespace mlir {
#define GEN_PASS_DEF_LINALGSTRATEGYTILEANDFUSEPASS
#define GEN_PASS_DEF_LINALGSTRATEGYTILEPASS
#define GEN_PASS_DEF_LINALGSTRATEGYPADPASS
#define GEN_PASS_DEF_LINALGSTRATEGYDECOMPOSEPASS
#define GEN_PASS_DEF_LINALGSTRATEGYPEELPASS
#define GEN_PASS_DEF_LINALGSTRATEGYLOWERVECTORSPASS
#define GEN_PASS_DEF_LINALGSTRATEGYREMOVEMARKERSPASS
#include "mlir/Dialect/Linalg/Passes.h.inc"
} // namespace mlir
using namespace mlir;
using namespace mlir::vector;
using namespace linalg;
namespace {
/// Configurable pass to lower vector operations.
struct LinalgStrategyRemoveMarkersPass
: public impl::LinalgStrategyRemoveMarkersPassBase<
LinalgStrategyRemoveMarkersPass> {
void runOnOperation() override {
auto funcOp = getOperation();
if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
return;
funcOp.walk([](LinalgOp op) {
op->removeAttr(LinalgTransforms::kLinalgTransformMarker);
});
}
};
} // namespace
/// Create a LinalgStrategyRemoveMarkersPass.
std::unique_ptr<OperationPass<func::FuncOp>>
mlir::createLinalgStrategyRemoveMarkersPass() {
return std::make_unique<LinalgStrategyRemoveMarkersPass>();
}
mlir/lib/Dialect/Linalg/Transforms/CodegenStrategy.cpp