This is an archive of the discontinued LLVM Phabricator instance.

Differential D110909

[mlir][linalg] Retire PoolingMaxOp/PoolingMinOp/PoolingSumOp.
ClosedPublic

Authored by gysit on Oct 1 2021, 1:20 AM.

Details

Reviewers
nicolasvasilache
Commits
rGbf2884974584: [mlir][linalg] Retire PoolingMaxOp/PoolingMinOp/PoolingSumOp.
Summary

The pooling ops are among the last remaining hard coded Linalg operations that have no region attached. They got obsolete due to the OpDSL pooling operations. Removing them allows us to delete specialized code and tests that are not needed for the OpDSL counterparts that rely on the standard code paths.

Diff Detail

Event Timeline

gysit created this revision.Oct 1 2021, 1:20 AM
Herald added subscribers: wenzhicui, wrengr, Chia-hungDuan and 20 others. · View Herald TranscriptOct 1 2021, 1:20 AM
gysit requested review of this revision.Oct 1 2021, 1:20 AM
Harbormaster completed remote builds in B126683: Diff 376446.Oct 1 2021, 1:20 AM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptOct 1 2021, 1:20 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added a reviewer: nicolasvasilache. · View Herald Transcript
Herald added subscribers: limo1996, stephenneuendorffer, nicolasvasilache. · View Herald Transcript
gysit edited the summary of this revision. (Show Details)Oct 1 2021, 1:22 AM
gysit updated this revision to Diff 376451.Oct 1 2021, 1:54 AM

Additionally remove hasPadding specialization for the pooling ops.

Harbormaster completed remote builds in B126687: Diff 376451.Oct 1 2021, 1:54 AM
nicolasvasilache accepted this revision.Oct 1 2021, 6:01 AM

Awesome, thank you @gysit !

This revision is now accepted and ready to land.Oct 1 2021, 6:01 AM
gysit updated this revision to Diff 376503.Oct 1 2021, 6:28 AM

Rebase.

Harbormaster completed remote builds in B126707: Diff 376503.Oct 1 2021, 6:28 AM
Closed by commit rGbf2884974584: [mlir][linalg] Retire PoolingMaxOp/PoolingMinOp/PoolingSumOp. (authored by gysit). · Explain WhyOct 1 2021, 6:52 AM
This revision was automatically updated to reflect the committed changes.
gysit added a commit: rGbf2884974584: [mlir][linalg] Retire PoolingMaxOp/PoolingMinOp/PoolingSumOp..

Revision Contents

PathSize
mlir/
include/
mlir/
Dialect/
Linalg/
IR/
3 lines
83 lines
lib/
Dialect/
Linalg/
IR/
55 lines
Transforms/
117 lines
test/
Dialect/
Linalg/
23 lines
11 lines
402 lines
42 lines

Diff 376510

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.h

Show All 30 Lines
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
namespace mlir { namespace mlir {
namespace linalg { namespace linalg {
class ConvOp; class ConvOp;
class LinalgOp; class LinalgOp;
class PoolingMaxOp;
class PoolingMinOp;
class PoolingSumOp;
// TOFO: allow an extra ValueRange to specify an indexing and allow // TOFO: allow an extra ValueRange to specify an indexing and allow
// non-hyperrectangular shapes. // non-hyperrectangular shapes.
using LoopRangeBuilder = using LoopRangeBuilder =
std::function<SmallVector<Range, 4>(ImplicitLocOpBuilder)>; std::function<SmallVector<Range, 4>(ImplicitLocOpBuilder)>;
/// Provide a very simple inference procedure to build the loop ranges from the /// Provide a very simple inference procedure to build the loop ranges from the
/// op and its operands. This only works with permutation affine maps and /// op and its operands. This only works with permutation affine maps and
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

Show First 20 Lines • Show All 411 Lines • ▼ Show 20 Lines let extraClassDeclaration = commonUtils # [{
} }
}]; }];
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
let hasFolder = 1; let hasFolder = 1;
} }
// Only support buffer semantics.
class SingleInputPoolingBase_Op<string mnemonic>
: PoolingBase_Op<mnemonic, []> {
let description = [{
A base class for single input pooling function.
TODO: Figure out a better way to handle window dimensions, i.e., eliminate
the fake memref.
The window dimensions are specified by argument `windowDims`. The i-th
dimension in the shape of `windowDims` denotes the size of the window along
dimension i. For example, if the window size is 2x3, then a memref<2x3>
should be passed to the operation as `windowDims`.
}];
let arguments = (ins AnyStridedMemRef:$input,
AnyStridedMemRef:$windowDims,
AnyStridedMemRef:$output,
OptionalAttr<I64ArrayAttr>:$strides,
OptionalAttr<I64ArrayAttr>:$dilations,
OptionalAttr<I64ElementsAttr>:$padding);
let extraClassDeclaration = commonUtils# [{
ValueRange inputs() { return getOperands().slice(0, 2); }
ValueRange outputs() { return getOperands().take_back(); }
ArrayAttr iterator_types() {
// Outer parallel loops are always the number of output dimensions.
int64_t nPar = getRank(getOutputOperand(0));
// The window loops has the same number loops with output dimensions.
unsigned nWin = nPar;
SmallVector<StringRef, 8> iters(nPar, getParallelIteratorTypeName());
iters.reserve(nPar + nWin);
iters.append(nWin, getWindowIteratorTypeName());
return Builder(getContext()).getStrArrayAttr(iters);
}
ArrayAttr indexing_maps() {
MLIRContext *context = getContext();
auto nPar = getNumParallelLoops();
auto nWin = getNumWindowLoops();
assert(nWin > 0 && "expected at least one window dimension");
unsigned idx = 0;
auto outputDims = makeAffineDimExprs(nPar, idx, context);
auto windowDims = makeAffineDimExprs(nWin, idx, context);
// Construct the weighedSum expression.
auto inputDims =
weightedPoolingInputIndex(*this, outputDims, windowDims);
return Builder(getContext()).getAffineMapArrayAttr({
// input
AffineMap::get(idx, 0, inputDims, context),
// windowDims
AffineMap::get(idx, 0, windowDims, context),
// output
AffineMap::get(idx, 0, outputDims, context)});
}
}];
let verifier = [{ return ::verify(*this); }];
let hasFolder = 1;
}
def PoolingMaxOp: SingleInputPoolingBase_Op<"pooling_max"> {
let description = [{
Takes max op as pooling operation, i.e., it samples the maximum value in the
window.
}];
}
def PoolingMinOp: SingleInputPoolingBase_Op<"pooling_min"> {
let description = [{
Takes min op as pooling operation, i.e., it samples the minimum value in the
window.
}];
}
def PoolingSumOp: SingleInputPoolingBase_Op<"pooling_sum"> {
let description = [{
Takes add op as pooling operation, i.e., it accumulates the values in the
window.
}];
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Generic Linalg ops. // Generic Linalg ops.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def GenericOp : LinalgStructuredBase_Op<"generic", [ def GenericOp : LinalgStructuredBase_Op<"generic", [
AttrSizedOperandSegments, AttrSizedOperandSegments,
DeclareOpInterfaceMethods<MemoryEffectsOpInterface>, DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
SingleBlockImplicitTerminator<"YieldOp">]> { SingleBlockImplicitTerminator<"YieldOp">]> {
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

Show First 20 Lines • Show All 2,632 Lines • ▼ Show 20 Linesstatic LogicalResult verify(ConvOp op) {
if (auto dilations = op.dilations()) { if (auto dilations = op.dilations()) {
if (failed(verifyStrideOrDilation(op, dilations->getValue(), if (failed(verifyStrideOrDilation(op, dilations->getValue(),
/*isStride=*/false))) /*isStride=*/false)))
return failure(); return failure();
} }
return success(); return success();
} }
template <typename PoolingOp>
static LogicalResult verifySingleInputPoolingOp(PoolingOp op) {
auto inputType = op.input().getType().template cast<MemRefType>();
auto outputType = op.output().getType().template cast<MemRefType>();
if (outputType.getElementType() != inputType.getElementType())
return op.emitOpError("expects memref elemental types to match");
auto windowDimsType = op.windowDims().getType().template cast<MemRefType>();
if (outputType.getRank() != inputType.getRank() ||
outputType.getRank() != windowDimsType.getRank())
return op.emitOpError("expects memref ranks to match");
if (auto strides = op.strides()) {
if (failed(verifyStrideOrDilation(op, strides->getValue(),
/*isStride=*/true)))
return failure();
}
if (auto dilations = op.dilations()) {
if (failed(verifyStrideOrDilation(op, dilations->getValue(),
/*isStride=*/false)))
return failure();
}
return success();
}
#define DEFINE_POOLING_OP_GET_EFFECTS(OP_NAME) \
void OP_NAME::getEffects( \
SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> \
&effects) { \
effects.emplace_back(MemoryEffects::Read::get(), input(), \
SideEffects::DefaultResource::get()); \
effects.emplace_back(MemoryEffects::Write::get(), output(), \
SideEffects::DefaultResource::get()); \
}
static LogicalResult verify(PoolingMaxOp op) {
return verifySingleInputPoolingOp(op);
}
static LogicalResult verify(PoolingMinOp op) {
return verifySingleInputPoolingOp(op);
}
static LogicalResult verify(PoolingSumOp op) {
return verifySingleInputPoolingOp(op);
}
DEFINE_POOLING_OP_GET_EFFECTS(PoolingMaxOp)
DEFINE_POOLING_OP_GET_EFFECTS(PoolingMinOp)
DEFINE_POOLING_OP_GET_EFFECTS(PoolingSumOp)
#include "mlir/Dialect/Linalg/IR/LinalgNamedStructuredOps.yamlgen.cpp.inc" #include "mlir/Dialect/Linalg/IR/LinalgNamedStructuredOps.yamlgen.cpp.inc"
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "mlir/Dialect/Linalg/IR/LinalgOps.cpp.inc" #include "mlir/Dialect/Linalg/IR/LinalgOps.cpp.inc"
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc" #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
#define INSTANTIATE_WEIGHTED_POOLING_INPUT_INDEX(OP_TYPE) \ #define INSTANTIATE_WEIGHTED_POOLING_INPUT_INDEX(OP_TYPE) \
template SmallVector<AffineExpr, 4> \ template SmallVector<AffineExpr, 4> \
mlir::linalg::weightedPoolingInputIndex<OP_TYPE>( \ mlir::linalg::weightedPoolingInputIndex<OP_TYPE>( \
OP_TYPE op, ArrayRef<AffineExpr> outputDims, \ OP_TYPE op, ArrayRef<AffineExpr> outputDims, \
ArrayRef<AffineExpr> windowDims); ArrayRef<AffineExpr> windowDims);
INSTANTIATE_WEIGHTED_POOLING_INPUT_INDEX(ConvOp) INSTANTIATE_WEIGHTED_POOLING_INPUT_INDEX(ConvOp)
INSTANTIATE_WEIGHTED_POOLING_INPUT_INDEX(PoolingMaxOp)
INSTANTIATE_WEIGHTED_POOLING_INPUT_INDEX(PoolingMinOp)
INSTANTIATE_WEIGHTED_POOLING_INPUT_INDEX(PoolingSumOp)
SmallVector<AffineExpr, 4> mlir::linalg::concat(ArrayRef<AffineExpr> a, SmallVector<AffineExpr, 4> mlir::linalg::concat(ArrayRef<AffineExpr> a,
ArrayRef<AffineExpr> b) { ArrayRef<AffineExpr> b) {
auto rangeA = llvm::make_range(a.begin(), a.end()); auto rangeA = llvm::make_range(a.begin(), a.end());
auto rangeB = llvm::make_range(b.begin(), b.end()); auto rangeB = llvm::make_range(b.begin(), b.end());
auto concatRanges = llvm::concat<const AffineExpr>(rangeA, rangeB); auto concatRanges = llvm::concat<const AffineExpr>(rangeA, rangeB);
return llvm::to_vector<4>(concatRanges); return llvm::to_vector<4>(concatRanges);
} }
▲ Show 20 Lines • Show All 440 Lines • ▼ Show 20 Lines
#define LINALGOP_FOLDERS(XXX) \ #define LINALGOP_FOLDERS(XXX) \
LogicalResult XXX::fold(ArrayRef<Attribute>, \ LogicalResult XXX::fold(ArrayRef<Attribute>, \
SmallVectorImpl<OpFoldResult> &) { \ SmallVectorImpl<OpFoldResult> &) { \
return foldMemRefCast(*this); \ return foldMemRefCast(*this); \
} }
LINALGOP_FOLDERS(ConvOp) LINALGOP_FOLDERS(ConvOp)
LINALGOP_FOLDERS(PoolingMaxOp)
LINALGOP_FOLDERS(PoolingMinOp)
LINALGOP_FOLDERS(PoolingSumOp)
LINALGOP_FOLDERS(CopyOp) LINALGOP_FOLDERS(CopyOp)
LINALGOP_FOLDERS(FillOp) LINALGOP_FOLDERS(FillOp)
LINALGOP_FOLDERS(GenericOp) LINALGOP_FOLDERS(GenericOp)
// All named ops canonicalizers and folders are auto-generated in the // All named ops canonicalizers and folders are auto-generated in the
// .cpp.inc. // .cpp.inc.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// LinalgDialect // LinalgDialect
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void LinalgDialect::getCanonicalizationPatterns( void LinalgDialect::getCanonicalizationPatterns(
RewritePatternSet &results) const { RewritePatternSet &results) const {
results.add<EraseDeadLinalgOp, FoldTensorCastOp, SimplifyDepthwiseConvOp, results.add<EraseDeadLinalgOp, FoldTensorCastOp, SimplifyDepthwiseConvOp,
SimplifyDepthwiseConvQOp>(getContext()); SimplifyDepthwiseConvQOp>(getContext());
} }

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

Show First 20 Lines • Show All 203 Lines • ▼ Show 20 Lines if (conds.empty())
return readInput; return readInput;
return b.create<SelectOp>(loc, conds.back(), padValue, readInput); return b.create<SelectOp>(loc, conds.back(), padValue, readInput);
} }
namespace { namespace {
/// The padding value for a given Op depends on the semantics of the Op. /// The padding value for a given Op depends on the semantics of the Op.
/// The identity value for ConvOp and PoolingSumOp is 0, for PoolingMaxOp is /// The identity value for ConvOp is 0.
/// -inf or minInt and for PoolingMinOp is inf or maxInt.
template <typename OpType> Attribute getPadValueAttr(Type type) { template <typename OpType> Attribute getPadValueAttr(Type type) {
llvm_unreachable("Unexpected op type for getPadValueAttr"); llvm_unreachable("Unexpected op type for getPadValueAttr");
return {}; return {};
} }
template <> Attribute getPadValueAttr<PoolingMaxOp>(Type type) {
if (auto floatType = type.dyn_cast<FloatType>()) {
return OpBuilder(type.getContext())
.getFloatAttr(floatType, APFloat::getInf(floatType.getFloatSemantics(),
/*Negative*/ true));
}
if (auto intType = type.dyn_cast<IntegerType>()) {
unsigned width = intType.getWidth();
// The select instruction used to lower the PoolingMin uses a signed
// comparison, use a signed constant irrespective of the signedness of the
// integer type.
return OpBuilder(type.getContext())
.getIntegerAttr(intType, APInt::getSignedMinValue(width));
}
llvm_unreachable("Unsupported data type for PoolingMaxOp");
return {};
}
template <> Attribute getPadValueAttr<PoolingMinOp>(Type type) {
if (auto floatType = type.dyn_cast<FloatType>()) {
return OpBuilder(type.getContext())
.getFloatAttr(floatType,
APFloat::getInf(floatType.getFloatSemantics()));
}
if (auto intType = type.dyn_cast<IntegerType>()) {
unsigned width = intType.getWidth();
// The select instruction used to lower the PoolingMin uses a signed
// comparison, use a signed constant irrespective of the signedness of the
// integer type.
return OpBuilder(type.getContext())
.getIntegerAttr(intType, APInt::getSignedMaxValue(width));
}
llvm_unreachable("Unsupported data type for PoolingMinOp");
return {};
}
template <> Attribute getPadValueAttr<PoolingSumOp>(Type type) {
return OpBuilder(type.getContext()).getZeroAttr(type);
}
template <> Attribute getPadValueAttr<ConvOp>(Type type) { template <> Attribute getPadValueAttr<ConvOp>(Type type) {
return OpBuilder(type.getContext()).getZeroAttr(type); return OpBuilder(type.getContext()).getZeroAttr(type);
} }
} // namespace } // namespace
/// Returns true is `convOp` has a non-zero padding. /// Returns true is `convOp` has a non-zero padding.
static bool hasPadding(ConvOp convOp) { static bool hasPadding(ConvOp convOp) {
Show All 39 Lines if (hasPadding(convOp)) {
Value filterVal = b.create<LoadOpTy>(loc, filter, fIdx); Value filterVal = b.create<LoadOpTy>(loc, filter, fIdx);
Value mulVal = ArithBuilder(b, loc).mul(filterVal, inputVal); Value mulVal = ArithBuilder(b, loc).mul(filterVal, inputVal);
Value outputVal = b.create<LoadOpTy>(loc, output, oIdx); Value outputVal = b.create<LoadOpTy>(loc, output, oIdx);
Value addVal = ArithBuilder(b, loc).add(mulVal, outputVal); Value addVal = ArithBuilder(b, loc).add(mulVal, outputVal);
b.create<StoreOpTy>(loc, addVal, output, oIdx); b.create<StoreOpTy>(loc, addVal, output, oIdx);
} }
} }
template <typename PoolingOp> static bool hasPadding(PoolingOp poolingOp) {
for (unsigned i = 0, e = poolingOp.getNumWindowLoops(); i < e; ++i) {
if (poolingOp.getLowPad(i) > 0 || poolingOp.getHighPad(i) > 0)
return true;
}
return false;
}
template <typename LoadOpTy, typename StoreOpTy, typename PoolingOp>
static Value getPoolingInput(OpBuilder &b, Location loc, PoolingOp op,
ArrayRef<Value> inputIndices) {
if (hasPadding(op)) {
Type type =
op.input().getType().template cast<MemRefType>().getElementType();
Value padValue =
b.create<ConstantOp>(loc, type, getPadValueAttr<PoolingOp>(type));
return getPaddedInput(b, loc, op.input(), inputIndices,
/*Pad every dimension*/ {}, padValue);
}
return b.create<LoadOpTy>(loc, op.input(), inputIndices);
}
template <typename LoadOpTy, typename StoreOpTy, typename OpType>
void emitPoolingMinMaxScalarImplementation(OpBuilder &b, Location loc,
ArrayRef<Value> allIvs, OpType op) {
InputAndOutputIndices indices = getInputAndOutputIndices(b, loc, allIvs, op);
Value lhs = b.create<LoadOpTy>(loc, op.output(), indices.outputs);
Value rhs = getPoolingInput<LoadOpTy, StoreOpTy>(b, loc, op, indices.inputs);
Value value = llvm::TypeSwitch<Operation *, Value>(op)
.Case([&](PoolingMinOp poolingOp) {
return ArithBuilder(b, loc).select(
ArithBuilder(b, loc).slt(lhs, rhs), lhs, rhs);
})
.Case([&](PoolingMaxOp poolingOp) {
return ArithBuilder(b, loc).select(
ArithBuilder(b, loc).sgt(lhs, rhs), lhs, rhs);
})
.Default([&](auto) { return Value(); });
b.create<StoreOpTy>(loc, value, op.output(), indices.outputs);
}
template <typename LoadOpTy, typename StoreOpTy>
static void emitScalarImplementation(OpBuilder &b, Location loc,
ArrayRef<Value> allIvs, PoolingMaxOp op) {
emitPoolingMinMaxScalarImplementation<LoadOpTy, StoreOpTy, PoolingMaxOp>(
b, loc, allIvs, op);
}
template <typename LoadOpTy, typename StoreOpTy>
static void emitScalarImplementation(OpBuilder &b, Location loc,
ArrayRef<Value> allIvs, PoolingMinOp op) {
emitPoolingMinMaxScalarImplementation<LoadOpTy, StoreOpTy, PoolingMinOp>(
b, loc, allIvs, op);
}
template <typename LoadOpTy, typename StoreOpTy>
static void emitScalarImplementation(OpBuilder &b, Location loc,
ArrayRef<Value> allIvs, PoolingSumOp op) {
auto indices = getInputAndOutputIndices(b, loc, allIvs, op);
Value inputVal =
getPoolingInput<LoadOpTy, StoreOpTy>(b, loc, op, indices.inputs);
Value outputVal = b.create<LoadOpTy>(loc, op.output(), indices.outputs);
Value added = ArithBuilder(b, loc).add(outputVal, inputVal);
b.create<StoreOpTy>(loc, added, op.output(), indices.outputs);
}
/// Replace the index operations in the body of the loop nest by the matching /// Replace the index operations in the body of the loop nest by the matching
/// induction variables. /// induction variables.
static void replaceIndexOpsByInductionVariables(LinalgOp linalgOp, static void replaceIndexOpsByInductionVariables(LinalgOp linalgOp,
PatternRewriter &rewriter, PatternRewriter &rewriter,
ArrayRef<Operation *> loopOps) { ArrayRef<Operation *> loopOps) {
// Extract the induction variables of the loop nest from outer to inner. // Extract the induction variables of the loop nest from outer to inner.
SmallVector<Value> allIvs; SmallVector<Value> allIvs;
for (Operation *loopOp : loopOps) { for (Operation *loopOp : loopOps) {
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linesstatic Optional<LinalgLoops> linalgOpToLoopsImpl(PatternRewriter &rewriter,
GenerateLoopNest<LoopTy>::doit( GenerateLoopNest<LoopTy>::doit(
rewriter, linalgOp.getLoc(), loopRanges, linalgOp, iteratorTypes, rewriter, linalgOp.getLoc(), loopRanges, linalgOp, iteratorTypes,
[&](OpBuilder &b, Location loc, ValueRange ivs, [&](OpBuilder &b, Location loc, ValueRange ivs,
ValueRange operandValuesToUse) -> scf::ValueVector { ValueRange operandValuesToUse) -> scf::ValueVector {
assert(operandValuesToUse == linalgOp->getOperands() && assert(operandValuesToUse == linalgOp->getOperands() &&
"expect operands are captured and not passed by loop argument"); "expect operands are captured and not passed by loop argument");
allIvs.append(ivs.begin(), ivs.end()); allIvs.append(ivs.begin(), ivs.end());
llvm::TypeSwitch<Operation *>(linalgOp) llvm::TypeSwitch<Operation *>(linalgOp)
.Case<ConvOp, PoolingMaxOp, PoolingMinOp, PoolingSumOp, LinalgOp>( .Case<ConvOp, LinalgOp>([&](auto op) {
[&](auto op) { emitScalarImplementation<LoadOpTy, StoreOpTy>(b, loc, allIvs, op);
emitScalarImplementation<LoadOpTy, StoreOpTy>(b, loc, allIvs,
op);
}) })
.Default([&](Operation *op) { assert(false && "unexpected op"); }); .Default([&](Operation *op) { assert(false && "unexpected op"); });
return scf::ValueVector{}; return scf::ValueVector{};
}); });
// Number of loop ops might be different from the number of ivs since some // Number of loop ops might be different from the number of ivs since some
// loops like affine.parallel and scf.parallel have multiple ivs. // loops like affine.parallel and scf.parallel have multiple ivs.
SetVector<Operation *> loopSet; SetVector<Operation *> loopSet;
for (Value iv : allIvs) { for (Value iv : allIvs) {
if (!iv) if (!iv)
▲ Show 20 Lines • Show All 338 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/affine.mlir

Show First 20 Lines • Show All 120 Lines • ▼ Show 20 Lines
// CHECK: affine.for %[[k:.*]] = {{.*}}0 to %[[K]] { // CHECK: affine.for %[[k:.*]] = {{.*}}0 to %[[K]] {
// CHECK: %[[va:.*]] = affine.load %[[mA]][%[[b]], %[[m]], %[[k]]] : memref<?x?x?xf32> // CHECK: %[[va:.*]] = affine.load %[[mA]][%[[b]], %[[m]], %[[k]]] : memref<?x?x?xf32>
// CHECK: %[[vb:.*]] = affine.load %[[mB]][%[[b]], %[[k]], %[[n]]] : memref<?x?x?xf32> // CHECK: %[[vb:.*]] = affine.load %[[mB]][%[[b]], %[[k]], %[[n]]] : memref<?x?x?xf32>
// CHECK: %[[vc:.*]] = affine.load %[[mC]][%[[b]], %[[m]], %[[n]]] : memref<?x?x?xf32> // CHECK: %[[vc:.*]] = affine.load %[[mC]][%[[b]], %[[m]], %[[n]]] : memref<?x?x?xf32>
// CHECK: %[[inc:.*]] = mulf %[[va]], %[[vb]] : f32 // CHECK: %[[inc:.*]] = mulf %[[va]], %[[vb]] : f32
// CHECK: %[[res:.*]] = addf %[[vc]], %[[inc]] : f32 // CHECK: %[[res:.*]] = addf %[[vc]], %[[inc]] : f32
// CHECK: affine.store %[[res]], %[[mC]][%[[b]], %[[m]], %[[n]]] : memref<?x?x?xf32> // CHECK: affine.store %[[res]], %[[mC]][%[[b]], %[[m]], %[[n]]] : memref<?x?x?xf32>
// CHECK-LABEL: func @pooling_max_min
func @pooling_max_min(%arg0: memref<?x?xf32>,
%arg1: memref<?x?xi32>,
%arg2: memref<?x?xf32>) {
linalg.pooling_max(%arg0, %arg1, %arg2) { strides = [2, 1] }:
memref<?x?xf32>, memref<?x?xi32>, memref<?x?xf32>
linalg.pooling_min(%arg0, %arg1, %arg2) { strides = [2, 1] }:
memref<?x?xf32>, memref<?x?xi32>, memref<?x?xf32>
return
}
// This is a basic check to make sure the right load/stores are used. loops.mlir
// checks for the rest.
// CHECK: affine.load
// CHECK-NEXT: affine.load
// CHECK-NEXT: cmpf
// CHECK-NEXT: select
// CHECK-NEXT: affine.store
// The min pooling body.
// CHECK: affine.load
// CHECK-NEXT: affine.load
// CHECK-NEXT: cmpf
// CHECK-NEXT: select
// CHECK-NEXT: affine.store

mlir/test/Dialect/Linalg/invalid.mlir

Show First 20 Lines • Show All 302 Lines • ▼ Show 20 Lines
// ----- // -----
// expected-error @+1 {{expected valid keyword}} // expected-error @+1 {{expected valid keyword}}
!invalid_type = type !linalg<"?"> !invalid_type = type !linalg<"?">
// ----- // -----
func @pooling_rank_mismatch(%arg0: memref<?x?x?xf32>,
%arg1: memref<2x3xf32>,
%arg2: memref<?x?x?xf32>) {
// expected-error @+1 {{expected operand rank (2) to match the result rank of indexing_map #1 (3)}}
linalg.pooling_max(%arg0, %arg1, %arg2) {strides = [2, 1, 2]}:
memref<?x?x?xf32>, memref<2x3xf32>, memref<?x?x?xf32>
return
}
// -----
func @named_ops(%a3: memref<?x?x?xf32>, %b3: memref<?x?xf32>, %c3: memref<?x?x?xf32>) { func @named_ops(%a3: memref<?x?x?xf32>, %b3: memref<?x?xf32>, %c3: memref<?x?x?xf32>) {
// expected-error @+1 {{expected operand rank (2) to match the result rank of indexing_map #1 (3)}} // expected-error @+1 {{expected operand rank (2) to match the result rank of indexing_map #1 (3)}}
linalg.batch_matmul ins(%a3, %b3: memref<?x?x?xf32>, memref<?x?xf32>) linalg.batch_matmul ins(%a3, %b3: memref<?x?x?xf32>, memref<?x?xf32>)
outs(%c3 : memref<?x?x?xf32>) outs(%c3 : memref<?x?x?xf32>)
return return
} }
// ----- // -----
▲ Show 20 Lines • Show All 363 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/loops.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops | FileCheck %s // RUN: mlir-opt %s -convert-linalg-to-loops | FileCheck %s
// RUN: mlir-opt %s -convert-linalg-to-parallel-loops | FileCheck --check-prefix=CHECKPARALLEL %s // RUN: mlir-opt %s -convert-linalg-to-parallel-loops | FileCheck --check-prefix=CHECKPARALLEL %s
// Test that we can lower all the way to LLVM without crashing, don't check results here. // Test that we can lower all the way to LLVM without crashing, don't check results here.
// RUN: mlir-opt %s -convert-linalg-to-loops -convert-linalg-to-llvm -o=/dev/null 2>&1 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-linalg-to-llvm -o=/dev/null 2>&1
// CHECK-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> // CHECK-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> // CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> // CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)>
// CHECK-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)> // CHECK-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)>
// CHECK-DAG: #[[$clampMinMap:.*]] = affine_map<(d0) -> (d0, 0)> // CHECK-DAG: #[[$clampMinMap:.*]] = affine_map<(d0) -> (d0, 0)>
// CHECK-DAG: #[[$stride1Dilation1:.*]] = affine_map<(d0, d1) -> (d0 + d1)> // CHECK-DAG: #[[$stride1Dilation1:.*]] = affine_map<(d0, d1) -> (d0 + d1)>
// CHECK-DAG: #[[$stride2Dilation1:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)> // CHECK-DAG: #[[$stride2Dilation1:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)>
// CHECK-DAG: #[[$stride2Dilation4:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1 * 4)> // CHECK-DAG: #[[$stride2Dilation4:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1 * 4)>
// CHECK-DAG: #[[$stride3Dilation5:.*]] = affine_map<(d0, d1) -> (d0 * 3 + d1 * 5)> // CHECK-DAG: #[[$stride3Dilation5:.*]] = affine_map<(d0, d1) -> (d0 * 3 + d1 * 5)>
// CHECK-DAG: #[[$stride1Dilation1Padding1:.*]] = affine_map<(d0, d1) -> (d0 + d1 - 1)>
// CHECK-DAG: #[[$stride1Dilation1Padding2:.*]] = affine_map<(d0, d1) -> (d0 + d1 - 2)>
// CHECKPARALLEL-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> // CHECKPARALLEL-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
// CHECKPARALLEL-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> // CHECKPARALLEL-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
// CHECKPARALLEL-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> // CHECKPARALLEL-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)>
// CHECKPARALLEL-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)> // CHECKPARALLEL-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)>
// CHECKPARALLEL-DAG: #[[$clampMinMap:.*]] = affine_map<(d0) -> (d0, 0)> // CHECKPARALLEL-DAG: #[[$clampMinMap:.*]] = affine_map<(d0) -> (d0, 0)>
// CHECKPARALLEL-DAG: #[[$stride1Dilation1:.*]] = affine_map<(d0, d1) -> (d0 + d1)> // CHECKPARALLEL-DAG: #[[$stride1Dilation1:.*]] = affine_map<(d0, d1) -> (d0 + d1)>
// CHECKPARALLEL-DAG: #[[$stride2Dilation1:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)> // CHECKPARALLEL-DAG: #[[$stride2Dilation1:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)>
// CHECKPARALLEL-DAG: #[[$stride2Dilation4:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1 * 4)> // CHECKPARALLEL-DAG: #[[$stride2Dilation4:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1 * 4)>
// CHECKPARALLEL-DAG: #[[$stride3Dilation5:.*]] = affine_map<(d0, d1) -> (d0 * 3 + d1 * 5)> // CHECKPARALLEL-DAG: #[[$stride3Dilation5:.*]] = affine_map<(d0, d1) -> (d0 * 3 + d1 * 5)>
// CHECKPARALLEL-DAG: #[[$stride1Dilation1Padding1:.*]] = affine_map<(d0, d1) -> (d0 + d1 - 1)>
// CHECKPARALLEL-DAG: #[[$stride1Dilation1Padding2:.*]] = affine_map<(d0, d1) -> (d0 + d1 - 2)>
func @matmul(%arg0: memref<?xi8>, %M: index, %N: index, %K: index) { func @matmul(%arg0: memref<?xi8>, %M: index, %N: index, %K: index) {
%c0 = constant 0 : index %c0 = constant 0 : index
%c1 = constant 1 : index %c1 = constant 1 : index
%A = memref.view %arg0[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32> %A = memref.view %arg0[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32>
%B = memref.view %arg0[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32> %B = memref.view %arg0[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32>
%C = memref.view %arg0[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32> %C = memref.view %arg0[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
linalg.matmul ins(%A, %B: memref<?x?xf32>, memref<?x?xf32>) linalg.matmul ins(%A, %B: memref<?x?xf32>, memref<?x?xf32>)
▲ Show 20 Lines • Show All 381 Lines • ▼ Show 20 Lines
// CHECKPARALLEL: memref.load %{{.*}}[%{{.*}}, %[[IDX]], %[[IDY]], %{{.*}}] : memref<?x?x?x?xf32> // CHECKPARALLEL: memref.load %{{.*}}[%{{.*}}, %[[IDX]], %[[IDY]], %{{.*}}] : memref<?x?x?x?xf32>
// CHECKPARALLEL: select %{{.*}}, // CHECKPARALLEL: select %{{.*}},
// CHECKPARALLEL: memref.load {{.*}} : memref<?x?x?x?xf32> // CHECKPARALLEL: memref.load {{.*}} : memref<?x?x?x?xf32>
// CHECKPARALLEL: mulf // CHECKPARALLEL: mulf
// CHECKPARALLEL: memref.load {{.*}} : memref<?x?x?x?xf32> // CHECKPARALLEL: memref.load {{.*}} : memref<?x?x?x?xf32>
// CHECKPARALLEL: addf // CHECKPARALLEL: addf
// CHECKPARALLEL: store %{{.*}}, {{.*}} : memref<?x?x?x?xf32> // CHECKPARALLEL: store %{{.*}}, {{.*}} : memref<?x?x?x?xf32>
func @pooling_max(%arg0: memref<?x?xf32>,
%arg1: memref<?x?xi32>,
%arg2: memref<?x?xf32>) {
linalg.pooling_max(%arg0, %arg1, %arg2) { strides = [2, 1] }:
memref<?x?xf32>, memref<?x?xi32>, memref<?x?xf32>
return
}
// CHECK-LABEL: func @pooling_max
// CHECK: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECK: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECK: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xf32>
// CHECK: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xf32>
// CHECK: scf.for {{.*}} to %[[OX]]
// CHECK: scf.for {{.*}} to %[[OY]]
// CHECK: scf.for {{.*}} to %[[WX]]
// CHECK: scf.for {{.*}} to %[[WY]]
// CHECK: %[[IX:.*]] = affine.apply #[[$stride2Dilation1]]
// CHECK: %[[IY:.*]] = affine.apply #[[$stride1Dilation1]]
// CHECK: memref.load {{.*}} : memref<?x?xf32>
// CHECK: memref.load %{{.*}}[%[[IX]], %[[IY]]] : memref<?x?xf32>
// CHECK: %[[RES:.*]] = select %{{.*}},
// CHECK: store %[[RES]], {{.*}} : memref<?x?xf32>
// CHECKPARALLEL-LABEL: func @pooling_max
// CHECKPARALLEL: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECKPARALLEL: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECKPARALLEL: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xf32>
// CHECKPARALLEL: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xf32>
// CHECKPARALLEL: scf.parallel {{.*}} to (%[[OX]], %[[OY]])
// CHECKPARALLEL: scf.for {{.*}} to %[[WX]]
// CHECKPARALLEL: scf.for {{.*}} to %[[WY]]
// CHECKPARALLEL: %[[IX:.*]] = affine.apply #[[$stride2Dilation1]]
// CHECKPARALLEL: %[[IY:.*]] = affine.apply #[[$stride1Dilation1]]
// CHECKPARALLEL: memref.load {{.*}} : memref<?x?xf32>
// CHECKPARALLEL: memref.load %{{.*}}[%[[IX]], %[[IY]]] : memref<?x?xf32>
// CHECKPARALLEL: %[[RES:.*]] = select %{{.*}},
// CHECKPARALLEL: store %[[RES]], {{.*}} : memref<?x?xf32>
func @pooling_max_padding(%arg0: memref<?x?xf32>,
%arg1: memref<?x?xi32>,
%arg2: memref<?x?xf32>) {
linalg.pooling_max(%arg0, %arg1, %arg2) { padding = dense<[[2, 2], [1, 1]]> : tensor<2x2xi64> } :
memref<?x?xf32>, memref<?x?xi32>, memref<?x?xf32>
return
}
// CHECK-LABEL: func @pooling_max_padding
// CHECK: %[[PAD:.*]] = constant 0xFF800000 : f32
// CHECK: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECK: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECK: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xf32>
// CHECK: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xf32>
// CHECK: scf.for {{.*}} to %[[OX]]
// CHECK: scf.for {{.*}} to %[[OY]]
// CHECK: scf.for {{.*}} to %[[WX]]
// CHECK: scf.for {{.*}} to %[[WY]]
// CHECK: %[[IX:.*]] = affine.apply #[[$stride1Dilation1Padding2]]
// CHECK: %[[IY:.*]] = affine.apply #[[$stride1Dilation1Padding1]]
// CHECK: %[[RHS:.*]] = memref.load {{.*}} : memref<?x?xf32>
// CHECK: %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[IX]])
// CHECK: %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[IY]])
// CHECK: %[[LHS:.*]] = memref.load %{{.*}}[%[[IDX]], %[[IDY]]] : memref<?x?xf32>
// CHECK: %[[SEL:.*]] = select %{{.*}}, %[[PAD]], %[[LHS]] : f32
// CHECK: %[[CMP:.*]] = cmpf ogt, %[[RHS]], %[[SEL]] : f32
// CHECK: %[[RES:.*]] = select %{{.*}}, %[[RHS]], %[[SEL]] : f32
// CHECK: store %[[RES]], {{.*}} : memref<?x?xf32>
// CHECKPARALLEL-LABEL: func @pooling_max_padding
// CHECKPARALLEL: %[[PAD:.*]] = constant 0xFF800000 : f32
// CHECKPARALLEL: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECKPARALLEL: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECKPARALLEL: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xf32>
// CHECKPARALLEL: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xf32>
// CHECKPARALLEL: scf.parallel {{.*}} to (%[[OX]], %[[OY]])
// CHECKPARALLEL: scf.for {{.*}} to %[[WX]]
// CHECKPARALLEL: scf.for {{.*}} to %[[WY]]
// CHECKPARALLEL: %[[IX:.*]] = affine.apply #[[$stride1Dilation1Padding2]]
// CHECKPARALLEL: %[[IY:.*]] = affine.apply #[[$stride1Dilation1Padding1]]
// CHECKPARALLEL: %[[RHS:.*]] = memref.load {{.*}} : memref<?x?xf32>
// CHECKPARALLEL: %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[IX]])
// CHECKPARALLEL: %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[IY]])
// CHECKPARALLEL: %[[LHS:.*]] = memref.load %{{.*}}[%[[IDX]], %[[IDY]]] : memref<?x?xf32>
// CHECKPARALLEL: %[[SEL:.*]] = select %{{.*}}, %[[PAD]], %[[LHS]] : f32
// CHECKPARALLEL: %[[CMP:.*]] = cmpf ogt, %[[RHS]], %[[SEL]] : f32
// CHECKPARALLEL: %[[RES:.*]] = select %{{.*}}, %[[RHS]], %[[SEL]] : f32
// CHECKPARALLEL: store %[[RES]], {{.*}} : memref<?x?xf32>
func @pooling_max_padding_i32(%arg0: memref<?x?xi32>,
%arg1: memref<?x?xi32>,
%arg2: memref<?x?xi32>) {
linalg.pooling_max(%arg0, %arg1, %arg2) { padding = dense<[[2, 2], [1, 1]]> : tensor<2x2xi64> } :
memref<?x?xi32>, memref<?x?xi32>, memref<?x?xi32>
return
}
// CHECK-LABEL: func @pooling_max_padding_i32
// CHECK: %[[PAD:.*]] = constant -2147483648 : i32
// CHECK: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECK: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECK: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xi32>
// CHECK: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xi32>
// CHECK: scf.for {{.*}} to %[[OX]]
// CHECK: scf.for {{.*}} to %[[OY]]
// CHECK: scf.for {{.*}} to %[[WX]]
// CHECK: scf.for {{.*}} to %[[WY]]
// CHECK: %[[IX:.*]] = affine.apply #[[$stride1Dilation1Padding2]]
// CHECK: %[[IY:.*]] = affine.apply #[[$stride1Dilation1Padding1]]
// CHECK: %[[RHS:.*]] = memref.load {{.*}} : memref<?x?xi32>
// CHECK: %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[IX]])
// CHECK: %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[IY]])
// CHECK: %[[LHS:.*]] = memref.load %{{.*}}[%[[IDX]], %[[IDY]]] : memref<?x?xi32>
// CHECK: %[[SEL:.*]] = select %{{.*}}, %[[PAD]], %[[LHS]] : i32
// CHECK: %[[CMP:.*]] = cmpi sgt, %[[RHS]], %[[SEL]] : i32
// CHECK: %[[RES:.*]] = select %{{.*}}, %[[RHS]], %[[SEL]] : i32
// CHECK: store %[[RES]], {{.*}} : memref<?x?xi32>
// CHECKPARALLEL-LABEL: func @pooling_max_padding_i32
// CHECKPARALLEL: %[[PAD:.*]] = constant -2147483648 : i32
// CHECKPARALLEL: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECKPARALLEL: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECKPARALLEL: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xi32>
// CHECKPARALLEL: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xi32>
// CHECKPARALLEL: scf.parallel {{.*}} to (%[[OX]], %[[OY]])
// CHECKPARALLEL: scf.for {{.*}} to %[[WX]]
// CHECKPARALLEL: scf.for {{.*}} to %[[WY]]
// CHECKPARALLEL: %[[IX:.*]] = affine.apply #[[$stride1Dilation1Padding2]]
// CHECKPARALLEL: %[[IY:.*]] = affine.apply #[[$stride1Dilation1Padding1]]
// CHECKPARALLEL: %[[RHS:.*]] = memref.load {{.*}} : memref<?x?xi32>
// CHECKPARALLEL: %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[IX]])
// CHECKPARALLEL: %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[IY]])
// CHECKPARALLEL: %[[LHS:.*]] = memref.load %{{.*}}[%[[IDX]], %[[IDY]]] : memref<?x?xi32>
// CHECKPARALLEL: %[[SEL:.*]] = select %{{.*}}, %[[PAD]], %[[LHS]] : i32
// CHECKPARALLEL: %[[CMP:.*]] = cmpi sgt, %[[RHS]], %[[SEL]] : i32
// CHECKPARALLEL: %[[RES:.*]] = select %{{.*}}, %[[RHS]], %[[SEL]] : i32
// CHECKPARALLEL: store %[[RES]], {{.*}} : memref<?x?xi32>
func @pooling_min(%arg0: memref<?x?xf32>,
%arg1: memref<?x?xi32>,
%arg2: memref<?x?xf32>) {
linalg.pooling_min(%arg0, %arg1, %arg2) { strides = [2, 1] }:
memref<?x?xf32>, memref<?x?xi32>, memref<?x?xf32>
return
}
// CHECK-LABEL: func @pooling_min
// CHECK: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECK: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECK: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xf32>
// CHECK: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xf32>
// CHECK: scf.for {{.*}} to %[[OX]]
// CHECK: scf.for {{.*}} to %[[OY]]
// CHECK: scf.for {{.*}} to %[[WX]]
// CHECK: scf.for {{.*}} to %[[WY]]
// CHECK: %[[IX:.*]] = affine.apply #[[$stride2Dilation1]]
// CHECK: %[[IY:.*]] = affine.apply #[[$stride1Dilation1]]
// CHECK: memref.load {{.*}} : memref<?x?xf32>
// CHECK: memref.load %{{.*}}[%[[IX]], %[[IY]]] : memref<?x?xf32>
// CHECK: %[[RES:.*]] = select %{{.*}},
// CHECK: store %[[RES]], {{.*}} : memref<?x?xf32>
// CHECKPARALLEL-LABEL: func @pooling_min
// CHECKPARALLEL: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECKPARALLEL: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECKPARALLEL: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xf32>
// CHECKPARALLEL: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xf32>
// CHECKPARALLEL: scf.parallel {{.*}} to (%[[OX]], %[[OY]])
// CHECKPARALLEL: scf.for {{.*}} to %[[WX]]
// CHECKPARALLEL: scf.for {{.*}} to %[[WY]]
// CHECKPARALLEL: %[[IX:.*]] = affine.apply #[[$stride2Dilation1]]
// CHECKPARALLEL: %[[IY:.*]] = affine.apply #[[$stride1Dilation1]]
// CHECKPARALLEL: memref.load {{.*}} : memref<?x?xf32>
// CHECKPARALLEL: memref.load %{{.*}}[%[[IX]], %[[IY]]] : memref<?x?xf32>
// CHECKPARALLEL: %[[RES:.*]] = select %{{.*}},
// CHECKPARALLEL: store %[[RES]], {{.*}} : memref<?x?xf32>
func @pooling_min_padding(%arg0: memref<?x?xf32>,
%arg1: memref<?x?xi32>,
%arg2: memref<?x?xf32>) {
linalg.pooling_min(%arg0, %arg1, %arg2) { padding = dense<[[2, 2], [1, 1]]> : tensor<2x2xi64> } :
memref<?x?xf32>, memref<?x?xi32>, memref<?x?xf32>
return
}
// CHECK-LABEL: func @pooling_min_padding
// CHECK: %[[PAD:.*]] = constant 0x7F800000 : f32
// CHECK: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECK: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECK: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xf32>
// CHECK: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xf32>
// CHECK: scf.for {{.*}} to %[[OX]]
// CHECK: scf.for {{.*}} to %[[OY]]
// CHECK: scf.for {{.*}} to %[[WX]]
// CHECK: scf.for {{.*}} to %[[WY]]
// CHECK: %[[IX:.*]] = affine.apply #[[$stride1Dilation1Padding2]]
// CHECK: %[[IY:.*]] = affine.apply #[[$stride1Dilation1Padding1]]
// CHECK: %[[RHS:.*]] = memref.load {{.*}} : memref<?x?xf32>
// CHECK: %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[IX]])
// CHECK: %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[IY]])
// CHECK: %[[LHS:.*]] = memref.load %{{.*}}[%[[IDX]], %[[IDY]]] : memref<?x?xf32>
// CHECK: %[[SEL:.*]] = select %{{.*}}, %[[PAD]], %[[LHS]] : f32
// CHECK: %[[CMP:.*]] = cmpf olt, %[[RHS]], %[[SEL]] : f32
// CHECK: %[[RES:.*]] = select %{{.*}}, %[[RHS]], %[[SEL]] : f32
// CHECK: store %[[RES]], {{.*}} : memref<?x?xf32>
// CHECKPARALLEL-LABEL: func @pooling_min_padding
// CHECKPARALLEL: %[[PAD:.*]] = constant 0x7F800000 : f32
// CHECKPARALLEL: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECKPARALLEL: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECKPARALLEL: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xf32>
// CHECKPARALLEL: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xf32>
// CHECKPARALLEL: scf.parallel {{.*}} to (%[[OX]], %[[OY]])
// CHECKPARALLEL: scf.for {{.*}} to %[[WX]]
// CHECKPARALLEL: scf.for {{.*}} to %[[WY]]
// CHECKPARALLEL: %[[IX:.*]] = affine.apply #[[$stride1Dilation1Padding2]]
// CHECKPARALLEL: %[[IY:.*]] = affine.apply #[[$stride1Dilation1Padding1]]
// CHECKPARALLEL: %[[RHS:.*]] = memref.load {{.*}} : memref<?x?xf32>
// CHECKPARALLEL: %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[IX]])
// CHECKPARALLEL: %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[IY]])
// CHECKPARALLEL: %[[LHS:.*]] = memref.load %{{.*}}[%[[IDX]], %[[IDY]]] : memref<?x?xf32>
// CHECKPARALLEL: %[[SEL:.*]] = select %{{.*}}, %[[PAD]], %[[LHS]] : f32
// CHECKPARALLEL: %[[CMP:.*]] = cmpf olt, %[[RHS]], %[[SEL]] : f32
// CHECKPARALLEL: %[[RES:.*]] = select %{{.*}}, %[[RHS]], %[[SEL]] : f32
// CHECKPARALLEL: store %[[RES]], {{.*}} : memref<?x?xf32>
func @pooling_min_padding_i32(%arg0: memref<?x?xi32>,
%arg1: memref<?x?xi32>,
%arg2: memref<?x?xi32>) {
linalg.pooling_min(%arg0, %arg1, %arg2) { padding = dense<[[2, 2], [1, 1]]> : tensor<2x2xi64> } :
memref<?x?xi32>, memref<?x?xi32>, memref<?x?xi32>
return
}
// CHECK-LABEL: func @pooling_min_padding_i32
// CHECK: %[[PAD:.*]] = constant 2147483647 : i32
// CHECK: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECK: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECK: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xi32>
// CHECK: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xi32>
// CHECK: scf.for {{.*}} to %[[OX]]
// CHECK: scf.for {{.*}} to %[[OY]]
// CHECK: scf.for {{.*}} to %[[WX]]
// CHECK: scf.for {{.*}} to %[[WY]]
// CHECK: %[[IX:.*]] = affine.apply #[[$stride1Dilation1Padding2]]
// CHECK: %[[IY:.*]] = affine.apply #[[$stride1Dilation1Padding1]]
// CHECK: %[[RHS:.*]] = memref.load {{.*}} : memref<?x?xi32>
// CHECK: %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[IX]])
// CHECK: %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[IY]])
// CHECK: %[[LHS:.*]] = memref.load %{{.*}}[%[[IDX]], %[[IDY]]] : memref<?x?xi32>
// CHECK: %[[SEL:.*]] = select %{{.*}}, %[[PAD]], %[[LHS]] : i32
// CHECK: %[[CMP:.*]] = cmpi slt, %[[RHS]], %[[SEL]] : i32
// CHECK: %[[RES:.*]] = select %{{.*}}, %[[RHS]], %[[SEL]] : i32
// CHECK: store %[[RES]], {{.*}} : memref<?x?xi32>
// CHECKPARALLEL-LABEL: func @pooling_min_padding_i32
// CHECKPARALLEL: %[[PAD:.*]] = constant 2147483647 : i32
// CHECKPARALLEL: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECKPARALLEL: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECKPARALLEL: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xi32>
// CHECKPARALLEL: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xi32>
// CHECKPARALLEL: scf.parallel {{.*}} to (%[[OX]], %[[OY]])
// CHECKPARALLEL: scf.for {{.*}} to %[[WX]]
// CHECKPARALLEL: scf.for {{.*}} to %[[WY]]
// CHECKPARALLEL: %[[IX:.*]] = affine.apply #[[$stride1Dilation1Padding2]]
// CHECKPARALLEL: %[[IY:.*]] = affine.apply #[[$stride1Dilation1Padding1]]
// CHECKPARALLEL: %[[RHS:.*]] = memref.load {{.*}} : memref<?x?xi32>
// CHECKPARALLEL: %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[IX]])
// CHECKPARALLEL: %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[IY]])
// CHECKPARALLEL: %[[LHS:.*]] = memref.load %{{.*}}[%[[IDX]], %[[IDY]]] : memref<?x?xi32>
// CHECKPARALLEL: %[[SEL:.*]] = select %{{.*}}, %[[PAD]], %[[LHS]] : i32
// CHECKPARALLEL: %[[CMP:.*]] = cmpi slt, %[[RHS]], %[[SEL]] : i32
// CHECKPARALLEL: %[[RES:.*]] = select %{{.*}}, %[[RHS]], %[[SEL]] : i32
// CHECKPARALLEL: store %[[RES]], {{.*}} : memref<?x?xi32>
func @pooling_sum(%arg0: memref<?x?xf32>,
%arg1: memref<?x?xi32>,
%arg2: memref<?x?xf32>) {
linalg.pooling_sum(%arg0, %arg1, %arg2) { strides = [2, 1] }:
memref<?x?xf32>, memref<?x?xi32>, memref<?x?xf32>
return
}
// CHECK-LABEL: func @pooling_sum
// CHECK: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECK: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECK: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xf32>
// CHECK: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xf32>
// CHECK: scf.for {{.*}} to %[[OX]]
// CHECK: scf.for {{.*}} to %[[OY]]
// CHECK: scf.for {{.*}} to %[[WX]]
// CHECK: scf.for {{.*}} to %[[WY]]
// CHECK: %[[IX:.*]] = affine.apply #[[$stride2Dilation1]]
// CHECK: %[[IY:.*]] = affine.apply #[[$stride1Dilation1]]
// CHECK: %[[RHS:.*]] = memref.load %{{.*}}[%[[IX]], %[[IY]]] : memref<?x?xf32>
// CHECK: %[[LHS:.*]] = memref.load {{.*}} : memref<?x?xf32>
// CHECK: %[[RES:.*]] = addf %[[LHS]], %[[RHS]] : f32
// CHECK: store %[[RES]], {{.*}} : memref<?x?xf32>
// CHECKPARALLEL-LABEL: func @pooling_sum
// CHECKPARALLEL: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECKPARALLEL: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECKPARALLEL: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xf32>
// CHECKPARALLEL: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xf32>
// CHECKPARALLEL: scf.parallel {{.*}} to (%[[OX]], %[[OY]])
// CHECKPARALLEL: scf.for {{.*}} to %[[WX]]
// CHECKPARALLEL: scf.for {{.*}} to %[[WY]]
// CHECKPARALLEL: %[[IX:.*]] = affine.apply #[[$stride2Dilation1]]
// CHECKPARALLEL: %[[IY:.*]] = affine.apply #[[$stride1Dilation1]]
// CHECKPARALLEL: %[[RHS:.*]] = memref.load %{{.*}}[%[[IX]], %[[IY]]] : memref<?x?xf32>
// CHECKPARALLEL: %[[LHS:.*]] = memref.load {{.*}} : memref<?x?xf32>
// CHECKPARALLEL: %[[RES:.*]] = addf %[[LHS]], %[[RHS]] : f32
// CHECKPARALLEL: store %[[RES]], {{.*}} : memref<?x?xf32>
func @pooling_sum_padding(%arg0: memref<?x?xf32>,
%arg1: memref<?x?xi32>,
%arg2: memref<?x?xf32>) {
linalg.pooling_sum(%arg0, %arg1, %arg2) { padding = dense<[[2, 2], [1, 1]]> : tensor<2x2xi64> } :
memref<?x?xf32>, memref<?x?xi32>, memref<?x?xf32>
return
}
// CHECK-LABEL: func @pooling_sum_padding
// CHECK: %[[PAD:.*]] = constant 0.000000e+00 : f32
// CHECK: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECK: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECK: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xf32>
// CHECK: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xf32>
// CHECK: scf.for {{.*}} to %[[OX]]
// CHECK: scf.for {{.*}} to %[[OY]]
// CHECK: scf.for {{.*}} to %[[WX]]
// CHECK: scf.for {{.*}} to %[[WY]]
// CHECK: %[[IX:.*]] = affine.apply #[[$stride1Dilation1Padding2]]
// CHECK: %[[IY:.*]] = affine.apply #[[$stride1Dilation1Padding1]]
// CHECK: %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[IX]])
// CHECK: %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[IY]])
// CHECK: %[[LHS:.*]] = memref.load %{{.*}}[%[[IDX]], %[[IDY]]] : memref<?x?xf32>
// CHECK: %[[SEL:.*]] = select %{{.*}}, %[[PAD]], %[[LHS]] : f32
// CHECK: %[[RHS:.*]] = memref.load {{.*}} : memref<?x?xf32>
// CHECK: %[[RES:.*]] = addf %[[RHS]], %[[SEL]] : f32
// CHECK: store %[[RES]], {{.*}} : memref<?x?xf32>
// CHECKPARALLEL-LABEL: func @pooling_sum_padding
// CHECKPARALLEL: %[[PAD:.*]] = constant 0.000000e+00 : f32
// CHECKPARALLEL: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECKPARALLEL: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECKPARALLEL: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xf32>
// CHECKPARALLEL: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xf32>
// CHECKPARALLEL: scf.parallel {{.*}} to (%[[OX]], %[[OY]])
// CHECKPARALLEL: scf.for {{.*}} to %[[WX]]
// CHECKPARALLEL: scf.for {{.*}} to %[[WY]]
// CHECKPARALLEL: %[[IX:.*]] = affine.apply #[[$stride1Dilation1Padding2]]
// CHECKPARALLEL: %[[IY:.*]] = affine.apply #[[$stride1Dilation1Padding1]]
// CHECKPARALLEL: %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[IX]])
// CHECKPARALLEL: %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[IY]])
// CHECKPARALLEL: %[[LHS:.*]] = memref.load %{{.*}}[%[[IDX]], %[[IDY]]] : memref<?x?xf32>
// CHECKPARALLEL: %[[SEL:.*]] = select %{{.*}}, %[[PAD]], %[[LHS]] : f32
// CHECKPARALLEL: %[[RHS:.*]] = memref.load {{.*}} : memref<?x?xf32>
// CHECKPARALLEL: %[[RES:.*]] = addf %[[RHS]], %[[SEL]] : f32
// CHECKPARALLEL: store %[[RES]], {{.*}} : memref<?x?xf32>
func @pooling_sum_padding_i32(%arg0: memref<?x?xi32>,
%arg1: memref<?x?xi32>,
%arg2: memref<?x?xi32>) {
linalg.pooling_sum(%arg0, %arg1, %arg2) { padding = dense<[[2, 2], [1, 1]]> : tensor<2x2xi64> } :
memref<?x?xi32>, memref<?x?xi32>, memref<?x?xi32>
return
}
// CHECK-LABEL: func @pooling_sum_padding_i32
// CHECK: %[[PAD:.*]] = constant 0 : i32
// CHECK: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECK: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECK: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xi32>
// CHECK: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xi32>
// CHECK: scf.for {{.*}} to %[[OX]]
// CHECK: scf.for {{.*}} to %[[OY]]
// CHECK: scf.for {{.*}} to %[[WX]]
// CHECK: scf.for {{.*}} to %[[WY]]
// CHECK: %[[IX:.*]] = affine.apply #[[$stride1Dilation1Padding2]]
// CHECK: %[[IY:.*]] = affine.apply #[[$stride1Dilation1Padding1]]
// CHECK: %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[IX]])
// CHECK: %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[IY]])
// CHECK: %[[LHS:.*]] = memref.load %{{.*}}[%[[IDX]], %[[IDY]]] : memref<?x?xi32>
// CHECK: %[[SEL:.*]] = select %{{.*}}, %[[PAD]], %[[LHS]] : i32
// CHECK: %[[RHS:.*]] = memref.load {{.*}} : memref<?x?xi32>
// CHECK: %[[RES:.*]] = addi %[[RHS]], %[[SEL]] : i32
// CHECK: store %[[RES]], {{.*}} : memref<?x?xi32>
// CHECKPARALLEL-LABEL: func @pooling_sum_padding_i32
// CHECKPARALLEL: %[[PAD:.*]] = constant 0 : i32
// CHECKPARALLEL: %[[WX:.*]] = memref.dim %arg1, %c0 : memref<?x?xi32>
// CHECKPARALLEL: %[[WY:.*]] = memref.dim %arg1, %c1 : memref<?x?xi32>
// CHECKPARALLEL: %[[OX:.*]] = memref.dim %arg2, %c0 : memref<?x?xi32>
// CHECKPARALLEL: %[[OY:.*]] = memref.dim %arg2, %c1 : memref<?x?xi32>
// CHECKPARALLEL: scf.parallel {{.*}} to (%[[OX]], %[[OY]])
// CHECKPARALLEL: scf.for {{.*}} to %[[WX]]
// CHECKPARALLEL: scf.for {{.*}} to %[[WY]]
// CHECKPARALLEL: %[[IX:.*]] = affine.apply #[[$stride1Dilation1Padding2]]
// CHECKPARALLEL: %[[IY:.*]] = affine.apply #[[$stride1Dilation1Padding1]]
// CHECKPARALLEL: %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[IX]])
// CHECKPARALLEL: %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[IY]])
// CHECKPARALLEL: %[[LHS:.*]] = memref.load %{{.*}}[%[[IDX]], %[[IDY]]] : memref<?x?xi32>
// CHECKPARALLEL: %[[SEL:.*]] = select %{{.*}}, %[[PAD]], %[[LHS]] : i32
// CHECKPARALLEL: %[[RHS:.*]] = memref.load {{.*}} : memref<?x?xi32>
// CHECKPARALLEL: %[[RES:.*]] = addi %[[RHS]], %[[SEL]] : i32
// CHECKPARALLEL: store %[[RES]], {{.*}} : memref<?x?xi32>
#accesses = [ #accesses = [
affine_map<(i, j, k) -> (i, j)>, affine_map<(i, j, k) -> (i, j)>,
affine_map<(i, j, k) -> (i, j, k)>, affine_map<(i, j, k) -> (i, j, k)>,
affine_map<(i, j, k) -> (i, k, j)> affine_map<(i, j, k) -> (i, k, j)>
] ]
#trait2 = { #trait2 = {
args_in = 1, args_in = 1,
args_out = 2, args_out = 2,
▲ Show 20 Lines • Show All 611 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/roundtrip.mlir

Show First 20 Lines • Show All 263 Lines • ▼ Show 20 Lines
// CHECK-SAME: [0, 1], [1, 1]]> : tensor<2x2xi64>, // CHECK-SAME: [0, 1], [1, 1]]> : tensor<2x2xi64>,
// CHECK-SAME: strides = [1, 1]} : // CHECK-SAME: strides = [1, 1]} :
// CHECK-SAME: memref<?x?x?x?xf32>, // CHECK-SAME: memref<?x?x?x?xf32>,
// CHECK-SAME: memref<?x?x?x?xf32>, // CHECK-SAME: memref<?x?x?x?xf32>,
// CHECK-SAME: memref<?x?x?x?xf32> // CHECK-SAME: memref<?x?x?x?xf32>
// ----- // -----
func @pooling_max(%arg0: memref<?x?x?xf32>,
%arg1: memref<?x?x?xi32>,
%arg2: memref<?x?x?xf32>) {
linalg.pooling_max(%arg0, %arg1, %arg2) {strides = [2, 1, 2]}:
memref<?x?x?xf32>, memref<?x?x?xi32>, memref<?x?x?xf32>
return
}
// CHECK-LABEL: func @pooling_max
// CHECK: linalg.pooling_max(%{{.*}}, %{{.*}}, %{{.*}})
// CHECK-SAME: {strides = [2, 1, 2]}
// CHECK-SAME: memref<?x?x?xf32>, memref<?x?x?xi32>, memref<?x?x?xf32>
// -----
func @pooling_min(%arg0: memref<?x?x?xf32>,
%arg1: memref<?x?x?xi32>,
%arg2: memref<?x?x?xf32>) {
linalg.pooling_min(%arg0, %arg1, %arg2) {strides = [2, 1, 2]}:
memref<?x?x?xf32>, memref<?x?x?xi32>, memref<?x?x?xf32>
return
}
// CHECK-LABEL: func @pooling_min
// CHECK: linalg.pooling_min(%{{.*}}, %{{.*}}, %{{.*}})
// CHECK-SAME: {strides = [2, 1, 2]}
// CHECK-SAME: memref<?x?x?xf32>, memref<?x?x?xi32>, memref<?x?x?xf32>
// -----
func @pooling_sum(%arg0: memref<?x?x?xf32>,
%arg1: memref<?x?x?xi32>,
%arg2: memref<?x?x?xf32>) {
linalg.pooling_sum(%arg0, %arg1, %arg2) {strides = [2, 1, 2]}:
memref<?x?x?xf32>, memref<?x?x?xi32>, memref<?x?x?xf32>
return
}
// CHECK-LABEL: func @pooling_sum
// CHECK: linalg.pooling_sum(%{{.*}}, %{{.*}}, %{{.*}})
// CHECK-SAME: {strides = [2, 1, 2]}
// CHECK-SAME: memref<?x?x?xf32>, memref<?x?x?xi32>, memref<?x?x?xf32>
// -----
#accesses_0 = [ #accesses_0 = [
affine_map<(i, j, k) -> (j, i)>, affine_map<(i, j, k) -> (j, i)>,
affine_map<(i, j, k) -> ()>, affine_map<(i, j, k) -> ()>,
affine_map<(i, j, k) -> (i, k, i + j)> affine_map<(i, j, k) -> (i, k, i + j)>
] ]
#trait_0 = { #trait_0 = {
indexing_maps = #accesses_0, indexing_maps = #accesses_0,
▲ Show 20 Lines • Show All 442 Lines • Show Last 20 Lines