This is an archive of the discontinued LLVM Phabricator instance.

Differential D139963

[mlir][tosa] Add broadcasting case for tosa.resize to linalg implementation
ClosedPublic

Authored by rsuderman on Dec 13 2022, 12:38 PM.

Details

Reviewers
jpienaar
NatashaKnk
Commits
rGb5a1de9c983d: [mlir][tosa] Add broadcasting case for tosa.resize to linalg implementation
Summary

When lowering tosa.resize it is possible there is an unary input dimension.
Lowering to a new tosa.resize and explicit broadcast simplifies the
tosa.resize operation to avoid recomputing the identical broadcasted values.

This change reworks the broadcast optimization reuse the tosa.resize generic
implementation.

Diff Detail

Event Timeline

rsuderman created this revision.Dec 13 2022, 12:38 PM
Herald added a project: Restricted Project. · View Herald TranscriptDec 13 2022, 12:38 PM
Herald added subscribers: hanchung, Moerafaat, zero9178 and 26 others. · View Herald Transcript
rsuderman requested review of this revision.Dec 13 2022, 12:38 PM
Herald added a project: Restricted Project. · View Herald TranscriptDec 13 2022, 12:38 PM
Herald added subscribers: • pcwang-thead, limo1996, stephenneuendorffer, nicolasvasilache. · View Herald Transcript
rsuderman edited the summary of this revision. (Show Details)Dec 13 2022, 12:40 PM
rsuderman added a reviewer: jpienaar.
Harbormaster completed remote builds in B202929: Diff 482596.Dec 13 2022, 1:33 PM
rsuderman added a reviewer: NatashaKnk.Dec 15 2022, 10:59 AM
jpienaar added inline comments.Dec 16 2022, 10:58 AM
mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp
1431

s/a a /a/

1442

Is ranked verified? Else lets check and return (I know practically things will fail, but if not verified to not be true I'd rather not have an assert here)

2329

Are the benefits here really required? (it would seem these actually make up orthogonal lowerings and so we should be able to guard them such so that we don't rely on benefits here - or just have it be one that dispatches to different rewrite calls).

rsuderman updated this revision to Diff 486066.Jan 3 2023, 1:35 PM

Fixed comment, included RankedTensorType check.

rsuderman marked 3 inline comments as done.Jan 3 2023, 1:39 PM
rsuderman added inline comments.
mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp
2329

I believe they are. We want to handle all of the broadcasting cases before applying the generic converter, otherwise we may generate the generic case and miss the performance improvements of the ending broadcast.

jpienaar accepted this revision.Jan 3 2023, 2:05 PM
This revision is now accepted and ready to land.Jan 3 2023, 2:05 PM
This revision was landed with ongoing or failed builds.Jan 3 2023, 2:30 PM
Closed by commit rGb5a1de9c983d: [mlir][tosa] Add broadcasting case for tosa.resize to linalg implementation (authored by rsuderman). · Explain Why
This revision was automatically updated to reflect the committed changes.
rsuderman marked an inline comment as done.
rsuderman added a commit: rGb5a1de9c983d: [mlir][tosa] Add broadcasting case for tosa.resize to linalg implementation.
Harbormaster completed remote builds in B205521: Diff 486066.Jan 3 2023, 2:46 PM

Revision Contents

PathSize
mlir/
lib/
Conversion/
TosaToLinalg/
174 lines
test/
Conversion/
TosaToLinalg/
174 lines

Diff 486089

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

Show First 20 Lines • Show All 1,323 Lines • ▼ Show 20 Lines auto linalgOp = rewriter.create<linalg::GenericOp>(
nestedBuilder.create<linalg::YieldOp>(loc, value); nestedBuilder.create<linalg::YieldOp>(loc, value);
}); });
rewriter.replaceOp(op, linalgOp->getResults()); rewriter.replaceOp(op, linalgOp->getResults());
return success(); return success();
} }
}; };
// Handle the case where the resize operation is a regular broadcast. We // Handle the resize case where the input is a 1x1 image. This case
// perform this part separately to avoid generating Extract operations which // can entirely avoiding having extract operations which target much
// are difficult to vectorize / optimize. // more difficult to optimize away.
class BroadcastResizeConverter : public OpRewritePattern<tosa::ResizeOp> { class ResizeUnaryConverter : public OpRewritePattern<tosa::ResizeOp> {
public: public:
using OpRewritePattern<tosa::ResizeOp>::OpRewritePattern; using OpRewritePattern<tosa::ResizeOp>::OpRewritePattern;
LogicalResult matchAndRewrite(tosa::ResizeOp op, LogicalResult matchAndRewrite(tosa::ResizeOp op,
PatternRewriter &rewriter) const final { PatternRewriter &rewriter) const final {
Location loc = op.getLoc(); Location loc = op.getLoc();
ImplicitLocOpBuilder builder(loc, rewriter); ImplicitLocOpBuilder builder(loc, rewriter);
auto input = op.getInput(); auto input = op.getInput();
auto inputTy = input.getType().cast<RankedTensorType>(); auto inputTy = input.getType().cast<RankedTensorType>();
auto resultTy = op.getType().cast<RankedTensorType>(); auto resultTy = op.getType().cast<RankedTensorType>();
const bool isBilinear = op.getMode() == "BILINEAR";
auto imageH = inputTy.getDimSize(1); auto inputH = inputTy.getDimSize(1);
auto imageW = inputTy.getDimSize(2); auto inputW = inputTy.getDimSize(2);
auto outputH = resultTy.getDimSize(1);
auto outputW = resultTy.getDimSize(2);
if (imageH != 1 || imageW != 1) { if (inputH != 1 || inputW != 1 || outputH != 1 || outputW != 1)
return rewriter.notifyMatchFailure( return rewriter.notifyMatchFailure(
op, "tosa.resize is not a pure broadcast operation"); op, "tosa.resize is not a pure 1x1->1x1 image operation");
}
// TODO(suderman): These string values should be declared the TOSA dialect. // TODO(suderman): These string values should be declared the TOSA dialect.
if (op.getMode() != "NEAREST_NEIGHBOR" && op.getMode() != "BILINEAR") if (op.getMode() != "NEAREST_NEIGHBOR" && op.getMode() != "BILINEAR")
return rewriter.notifyMatchFailure( return rewriter.notifyMatchFailure(
op, "tosa.resize mode should be NEAREST_NEIGHBOR or BILINEAR"); op, "tosa.resize mode should be NEAREST_NEIGHBOR or BILINEAR");
const bool isBilinear = op.getMode() == "BILINEAR"; if (inputTy == resultTy) {
rewriter.replaceOp(op, input);
return success();
}
SmallVector<int32_t> scale; SmallVector<int32_t> scale;
getValuesFromIntArrayAttribute(op.getScale(), scale); getValuesFromIntArrayAttribute(op.getScale(), scale);
// Collapse the 1 dimensions away. // Collapse the unit width and height away.
SmallVector<ReassociationExprs, 4> collapseMap(2); SmallVector<ReassociationExprs, 4> reassociationMap(2);
collapseMap[0].push_back(builder.getAffineDimExpr(0)); reassociationMap[0].push_back(builder.getAffineDimExpr(0));
collapseMap[1].push_back(builder.getAffineDimExpr(1)); reassociationMap[1].push_back(builder.getAffineDimExpr(1));
collapseMap[1].push_back(builder.getAffineDimExpr(2)); reassociationMap[1].push_back(builder.getAffineDimExpr(2));
collapseMap[1].push_back(builder.getAffineDimExpr(3)); reassociationMap[1].push_back(builder.getAffineDimExpr(3));
auto collapseTy = auto collapseTy =
RankedTensorType::get({inputTy.getDimSize(0), inputTy.getDimSize(3)}, RankedTensorType::get({inputTy.getDimSize(0), inputTy.getDimSize(3)},
inputTy.getElementType()); inputTy.getElementType());
Value collapse = Value collapse = builder.create<tensor::CollapseShapeOp>(collapseTy, input,
builder.create<tensor::CollapseShapeOp>(collapseTy, input, collapseMap); reassociationMap);
// Broadcast input to the output shape. // Get any dynamic shapes that appear in the input format.
llvm::SmallVector<Value> outputDynSize; llvm::SmallVector<Value> outputDynSize;
if (inputTy.isDynamicDim(0)) if (inputTy.isDynamicDim(0))
outputDynSize.push_back(builder.create<tensor::DimOp>(input, 0)); outputDynSize.push_back(builder.create<tensor::DimOp>(input, 0));
if (inputTy.isDynamicDim(3)) if (inputTy.isDynamicDim(3))
outputDynSize.push_back(builder.create<tensor::DimOp>(input, 3)); outputDynSize.push_back(builder.create<tensor::DimOp>(input, 3));
llvm::SmallVector<AffineExpr> inputExprs{ // Generate the elementwise operation for casting scaling the input value.
rewriter.getAffineDimExpr(0), auto genericTy = collapseTy.clone(resultTy.getElementType());
rewriter.getAffineDimExpr(3),
};
auto inputMap = AffineMap::get(/*dimCount=*/4, /*symbolCount=*/0,
inputExprs, builder.getContext());
auto resultMap = rewriter.getMultiDimIdentityMap(resultTy.getRank());
SmallVector<utils::IteratorType> iterators(4,
utils::IteratorType::parallel);
Value empty = builder.create<tensor::EmptyOp>( Value empty = builder.create<tensor::EmptyOp>(
resultTy.getShape(), resultTy.getElementType(), outputDynSize); genericTy.getShape(), resultTy.getElementType(), outputDynSize);
auto genericMap = rewriter.getMultiDimIdentityMap(genericTy.getRank());
SmallVector<utils::IteratorType> iterators(genericTy.getRank(),
utils::IteratorType::parallel);
auto generic = builder.create<linalg::GenericOp>( auto generic = builder.create<linalg::GenericOp>(
resultTy, ValueRange{collapse}, ValueRange{empty}, genericTy, ValueRange{collapse}, ValueRange{empty},
ArrayRef<AffineMap>{inputMap, resultMap}, iterators, ArrayRef<AffineMap>{genericMap, genericMap}, iterators,
[=](OpBuilder &b, Location loc, ValueRange args) { [=](OpBuilder &b, Location loc, ValueRange args) {
Value value = args[0]; Value value = args[0];
// This is the quantized case. // This is the quantized case.
if (inputTy.getElementType() != resultTy.getElementType()) { if (inputTy.getElementType() != resultTy.getElementType()) {
value = value =
b.create<arith::ExtSIOp>(loc, resultTy.getElementType(), value); b.create<arith::ExtSIOp>(loc, resultTy.getElementType(), value);
if (isBilinear && scale[0] != 0) { if (isBilinear && scale[0] != 0) {
Value scaleY = b.create<arith::ConstantOp>( Value scaleY = b.create<arith::ConstantOp>(
loc, b.getI32IntegerAttr(scale[0])); loc, b.getI32IntegerAttr(scale[0]));
value = b.create<arith::MulIOp>(loc, value, scaleY); value = b.create<arith::MulIOp>(loc, value, scaleY);
} }
if (isBilinear && scale[2] != 0) { if (isBilinear && scale[2] != 0) {
Value scaleX = b.create<arith::ConstantOp>( Value scaleX = b.create<arith::ConstantOp>(
loc, b.getI32IntegerAttr(scale[2])); loc, b.getI32IntegerAttr(scale[2]));
value = b.create<arith::MulIOp>(loc, value, scaleX); value = b.create<arith::MulIOp>(loc, value, scaleX);
} }
} }
b.create<linalg::YieldOp>(loc, value); b.create<linalg::YieldOp>(loc, value);
}); });
rewriter.replaceOp(op, generic.getResult(0)); rewriter.replaceOpWithNewOp<tensor::ExpandShapeOp>(
op, resultTy, generic.getResults()[0], reassociationMap);
return success();
}
};
// TOSA resize with width or height of 1 may be broadcasted to a wider
// dimension. This is done by materializing a new tosa.resize without
jpienaarUnsubmitted
Done
ReplyInline Actions

s/a a /a/

jpienaar: s/a a /a/
// the broadcasting behavior, and an explicit broadcast afterwards.
class MaterializeResizeBroadcast : public OpRewritePattern<tosa::ResizeOp> {
public:
using OpRewritePattern<tosa::ResizeOp>::OpRewritePattern;
LogicalResult matchAndRewrite(tosa::ResizeOp op,
PatternRewriter &rewriter) const final {
Location loc = op.getLoc();
ImplicitLocOpBuilder builder(loc, rewriter);
auto input = op.getInput();
auto inputTy = input.getType().dyn_cast<RankedTensorType>();
jpienaarUnsubmitted
Done
ReplyInline Actions

Is ranked verified? Else lets check and return (I know practically things will fail, but if not verified to not be true I'd rather not have an assert here)

jpienaar: Is ranked verified? Else lets check and return (I know practically things will fail, but if not…
auto resultTy = op.getType().dyn_cast<RankedTensorType>();
if (!inputTy || !resultTy)
return rewriter.notifyMatchFailure(op,
"requires ranked input/output types");
auto batch = inputTy.getDimSize(0);
auto channels = inputTy.getDimSize(3);
auto inputH = inputTy.getDimSize(1);
auto inputW = inputTy.getDimSize(2);
auto outputH = resultTy.getDimSize(1);
auto outputW = resultTy.getDimSize(2);
if ((inputH != 1 || outputH == 1) && (inputW != 1 || outputW == 1))
return rewriter.notifyMatchFailure(
op, "tosa.resize has no broadcasting behavior");
// For any dimension that is broadcastable we generate a width of 1
// on the output.
llvm::SmallVector<int64_t> resizeShape;
resizeShape.push_back(batch);
resizeShape.push_back(inputH == 1 ? 1 : outputH);
resizeShape.push_back(inputW == 1 ? 1 : outputW);
resizeShape.push_back(channels);
auto resizeTy = resultTy.clone(resizeShape);
auto resize =
builder.create<tosa::ResizeOp>(resizeTy, input, op->getAttrs());
// Collapse an unit result dims.
SmallVector<ReassociationExprs, 4> reassociationMap(2);
reassociationMap[0].push_back(builder.getAffineDimExpr(0));
reassociationMap.back().push_back(builder.getAffineDimExpr(1));
if (inputH != 1)
reassociationMap.push_back({});
reassociationMap.back().push_back(builder.getAffineDimExpr(2));
if (inputW != 1)
reassociationMap.push_back({});
reassociationMap.back().push_back(builder.getAffineDimExpr(3));
llvm::SmallVector<int64_t> collapseShape{batch};
if (inputH != 1)
collapseShape.push_back(outputH);
if (inputW != 1)
collapseShape.push_back(outputW);
collapseShape.push_back(channels);
auto collapseTy = resultTy.clone(collapseShape);
Value collapse = builder.create<tensor::CollapseShapeOp>(collapseTy, resize,
reassociationMap);
// Broadcast the collapsed shape to the output result.
llvm::SmallVector<Value> outputDynSize;
if (inputTy.isDynamicDim(0))
outputDynSize.push_back(builder.create<tensor::DimOp>(input, 0));
if (inputTy.isDynamicDim(3))
outputDynSize.push_back(builder.create<tensor::DimOp>(input, 3));
SmallVector<utils::IteratorType> iterators(resultTy.getRank(),
utils::IteratorType::parallel);
Value empty = builder.create<tensor::EmptyOp>(
resultTy.getShape(), resultTy.getElementType(), outputDynSize);
SmallVector<AffineExpr, 4> inputExprs{rewriter.getAffineDimExpr(0)};
if (inputH != 1)
inputExprs.push_back(rewriter.getAffineDimExpr(1));
if (inputW != 1)
inputExprs.push_back(rewriter.getAffineDimExpr(2));
inputExprs.push_back(rewriter.getAffineDimExpr(3));
auto inputMap = AffineMap::get(resultTy.getRank(), /*symbolCount=*/0,
inputExprs, rewriter.getContext());
auto outputMap = rewriter.getMultiDimIdentityMap(resultTy.getRank());
rewriter.replaceOpWithNewOp<linalg::GenericOp>(
op, resultTy, ValueRange{collapse}, ValueRange{empty},
ArrayRef<AffineMap>{inputMap, outputMap}, iterators,
[=](OpBuilder &b, Location loc, ValueRange args) {
Value value = args[0];
b.create<linalg::YieldOp>(loc, value);
});
return success(); return success();
} }
}; };
class GenericResizeConverter : public OpRewritePattern<tosa::ResizeOp> { class GenericResizeConverter : public OpRewritePattern<tosa::ResizeOp> {
public: public:
using OpRewritePattern<tosa::ResizeOp>::OpRewritePattern; using OpRewritePattern<tosa::ResizeOp>::OpRewritePattern;
▲ Show 20 Lines • Show All 786 Lines • ▼ Show 20 Lines
} // namespace } // namespace
void mlir::tosa::populateTosaToLinalgConversionPatterns( void mlir::tosa::populateTosaToLinalgConversionPatterns(
RewritePatternSet *patterns) { RewritePatternSet *patterns) {
// We have multiple resize coverters to handle degenerate cases. // We have multiple resize coverters to handle degenerate cases.
patterns->add<GenericResizeConverter>(patterns->getContext(), patterns->add<GenericResizeConverter>(patterns->getContext(),
/*benefit=*/100); /*benefit=*/100);
patterns->add<BroadcastResizeConverter>(patterns->getContext(), patterns->add<ResizeUnaryConverter>(patterns->getContext(),
/*benefit=*/200); /*benefit=*/200);
patterns->add<MaterializeResizeBroadcast>(patterns->getContext(),
jpienaarUnsubmitted
Done
ReplyInline Actions

Are the benefits here really required? (it would seem these actually make up orthogonal lowerings and so we should be able to guard them such so that we don't rely on benefits here - or just have it be one that dispatches to different rewrite calls).

jpienaar: Are the benefits here really required? (it would seem these actually make up orthogonal…
rsudermanAuthorUnsubmitted
Done
ReplyInline Actions

I believe they are. We want to handle all of the broadcasting cases before applying the generic converter, otherwise we may generate the generic case and miss the performance improvements of the ending broadcast.

rsuderman: I believe they are. We want to handle all of the broadcasting cases before applying the generic…
/*benefit=*/300);
patterns->add< patterns->add<
// clang-format off // clang-format off
PointwiseConverter<tosa::AddOp>, PointwiseConverter<tosa::AddOp>,
PointwiseConverter<tosa::SubOp>, PointwiseConverter<tosa::SubOp>,
PointwiseConverter<tosa::MulOp>, PointwiseConverter<tosa::MulOp>,
PointwiseConverter<tosa::DivOp>, PointwiseConverter<tosa::DivOp>,
PointwiseConverter<tosa::NegateOp>, PointwiseConverter<tosa::NegateOp>,
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

mlir/test/Conversion/TosaToLinalg/tosa-to-linalg-resize.mlir

// RUN: mlir-opt --split-input-file -pass-pipeline="builtin.module(func.func(tosa-to-linalg))" %s -o -| FileCheck %s // RUN: mlir-opt --split-input-file -pass-pipeline="builtin.module(func.func(tosa-to-linalg))" %s -o -| FileCheck %s
// CHECK: #map = affine_map<(d0, d1, d2, d3) -> (d0, d3)> // CHECK-LABEL: @unary_resize_nearest_fp
// CHECK: #map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> func.func @unary_resize_nearest_fp(%arg0 : tensor<3x1x1x7xf32>) -> tensor<3x1x1x7xf32> {
// CHECK-LABEL: @broadcast_resize_nearest_fp %resize = "tosa.resize"(%arg0) {mode = "NEAREST_NEIGHBOR", scale = [2, 2, 1, 1], offset = [0, 0], border = [0, 0]} : (tensor<3x1x1x7xf32>) -> tensor<3x1x1x7xf32>
func.func @broadcast_resize_nearest_fp(%arg0 : tensor<3x1x1x7xf32>) -> tensor<3x15x13x7xf32> { // CHECK: return %arg0
// CHECK: %[[COLLAPSE:.+]] = tensor.collapse_shape %arg0 return %resize : tensor<3x1x1x7xf32>
// CHECK-SAME{literal}: [[0], [1, 2, 3]]
// CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<3x15x13x7xf32>
// CHECK: %[[GENERIC:.+]] = linalg.generic
// CHECK-SAME: indexing_maps = [#map, #map1]
// CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "parallel"]}
// CHECK-SAME: ins(%[[COLLAPSE]] : tensor<3x7xf32>)
// CHECK-SAME: outs(%[[EMPTY]] : tensor<3x15x13x7xf32>)
// CHECK-NEXT: ^bb0(%[[IN:.+]]: f32, %[[OUT:.+]]: f32):
// CHECK: linalg.yield %[[IN]]
%resize = "tosa.resize"(%arg0) {mode = "NEAREST_NEIGHBOR", scale = [2, 2, 1, 1], offset = [0, 0], border = [0, 0]} : (tensor<3x1x1x7xf32>) -> tensor<3x15x13x7xf32>
// CHECK: return %[[GENERIC]]
return %resize : tensor<3x15x13x7xf32>
} }
// ----- // -----
// CHECK: #map = affine_map<(d0, d1, d2, d3) -> (d0, d3)> // CHECK-LABEL: @unary_resize_bilinear_fp
// CHECK: #map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> func.func @unary_resize_bilinear_fp(%arg0 : tensor<3x1x1x7xf32>) -> tensor<3x1x1x7xf32> {
// CHECK-LABEL: @broadcast_resize_bilinear_fp %resize = "tosa.resize"(%arg0) {mode = "BILINEAR", scale = [2, 2, 1, 1], offset = [0, 0], border = [0, 0]} : (tensor<3x1x1x7xf32>) -> tensor<3x1x1x7xf32>
func.func @broadcast_resize_bilinear_fp(%arg0 : tensor<3x1x1x7xf32>) -> tensor<3x15x13x7xf32> { // CHECK: return %arg0
// CHECK: %[[COLLAPSE:.+]] = tensor.collapse_shape %arg0 return %resize : tensor<3x1x1x7xf32>
// CHECK-SAME{literal}: [[0], [1, 2, 3]] }
// CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<3x15x13x7xf32>
// CHECK: %[[GENERIC:.+]] = linalg.generic
// CHECK-SAME: indexing_maps = [#map, #map1]
// CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "parallel"]}
// CHECK-SAME: ins(%[[COLLAPSE]] : tensor<3x7xf32>)
// CHECK-SAME: outs(%[[EMPTY]] : tensor<3x15x13x7xf32>)
// CHECK-NEXT: ^bb0(%[[IN:.+]]: f32, %[[OUT:.+]]: f32):
// CHECK: linalg.yield %[[IN]]
%resize = "tosa.resize"(%arg0) {mode = "BILINEAR", scale = [2, 2, 1, 1], offset = [0, 0], border = [0, 0]} : (tensor<3x1x1x7xf32>) -> tensor<3x15x13x7xf32>
// CHECK: return %[[GENERIC]] // -----
return %resize : tensor<3x15x13x7xf32>
// CHECK-LABEL: @unary_resize_nearest_i8
func.func @unary_resize_nearest_i8(%arg0 : tensor<3x1x1x7xi8>) -> tensor<3x1x1x7xi8> {
%resize = "tosa.resize"(%arg0) {mode = "NEAREST_NEIGHBOR", scale = [2, 1, 3, 1], offset = [0, 0], border = [0, 0]} : (tensor<3x1x1x7xi8>) -> tensor<3x1x1x7xi8>
// CHECK: return %arg0
return %resize : tensor<3x1x1x7xi8>
} }
// ----- // -----
// CHECK: #map = affine_map<(d0, d1, d2, d3) -> (d0, d3)> // CHECK-LABEL: @broadcast_resize_nearest_f32
// CHECK: #map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> func.func @broadcast_resize_nearest_f32(%arg0 : tensor<3x1x1x7xf32>) -> tensor<3x1x5x7xf32> {
// CHECK-LABEL: @broadcast_resize_nearest_i8
func.func @broadcast_resize_nearest_i8(%arg0 : tensor<3x1x1x7xi8>) -> tensor<3x15x13x7xi8> {
// CHECK: %[[COLLAPSE:.+]] = tensor.collapse_shape %arg0 // CHECK: %[[COLLAPSE:.+]] = tensor.collapse_shape %arg0
// CHECK-SAME{literal}: [[0], [1, 2, 3]] // CHECK-NEXT{literal}: [[0], [1, 2, 3]] : tensor<3x1x1x7xf32> into tensor<3x7xf32>
// CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<3x15x13x7xi8> // CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<3x1x5x7xf32>
// CHECK: %[[GENERIC:.+]] = linalg.generic // CHECK: %[[GENERIC:.+]] = linalg.generic
// CHECK-SAME: indexing_maps = [#map, #map1] // CHECK-SAME: indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]}
// CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "parallel"]} // CHECK-SAME: ins(%[[COLLAPSE]] : tensor<3x7xf32>) outs(%[[EMPTY]] : tensor<3x1x5x7xf32>)
// CHECK-SAME: ins(%[[COLLAPSE]] : tensor<3x7xi8>) // CHECK: ^bb0(%[[IN:.+]]: f32, %[[OUT:.+]]: f32):
// CHECK-SAME: outs(%[[EMPTY]] : tensor<3x15x13x7xi8>) // CHECK: linalg.yield %[[IN]] : f32
// CHECK-NEXT: ^bb0(%[[IN:.+]]: i8, %[[OUT:.+]]: i8): %resize = "tosa.resize"(%arg0) {mode = "NEAREST_NEIGHBOR", scale = [2, 1, 3, 1], offset = [0, 0], border = [0, 0]} : (tensor<3x1x1x7xf32>) -> tensor<3x1x5x7xf32>
// CHECK: linalg.yield %[[IN]]
%resize = "tosa.resize"(%arg0) {mode = "NEAREST_NEIGHBOR", scale = [2, 2, 1, 1], offset = [0, 0], border = [0, 0]} : (tensor<3x1x1x7xi8>) -> tensor<3x15x13x7xi8>
// CHECK: return %[[GENERIC]] // CHECK: return %[[GENERIC]]
return %resize : tensor<3x15x13x7xi8> return %resize : tensor<3x1x5x7xf32>
} }
// ----- // -----
// CHECK: #map = affine_map<(d0, d1, d2, d3) -> (d0, d3)> // CHECK-LABEL: @broadcast_resize_bilinear_i8
// CHECK: #map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> func.func @broadcast_resize_bilinear_i8(%arg0 : tensor<3x1x1x7xi8>) -> tensor<3x4x5x7xi32> {
// CHECK-LABEL: @broadcast_resize_nearest_i32
func.func @broadcast_resize_nearest_i32(%arg0 : tensor<3x1x1x7xi8>) -> tensor<3x15x13x7xi32> {
// CHECK: %[[COLLAPSE:.+]] = tensor.collapse_shape %arg0 // CHECK: %[[COLLAPSE:.+]] = tensor.collapse_shape %arg0
// CHECK-SAME{literal}: [[0], [1, 2, 3]] // CHECK-SAME{literal}: [[0], [1, 2, 3]] : tensor<3x1x1x7xi8> into tensor<3x7xi8>
// CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<3x15x13x7xi32> // CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<3x7xi32>
// CHECK: %[[GENERIC:.+]] = linalg.generic // CHECK: %[[RESIZE:.+]] = linalg.generic
// CHECK-SAME: indexing_maps = [#map, #map1] // CHECK-SAME: {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]}
// CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "parallel"]} // CHECK-SAME: ins(%[[COLLAPSE]] : tensor<3x7xi8>) outs(%[[EMPTY]] : tensor<3x7xi32>)
// CHECK-SAME: ins(%[[COLLAPSE]] : tensor<3x7xi8>) // CHECK: ^bb0(%[[IN:.+]]: i8, %[[OUT:.+]]: i32):
// CHECK-SAME: outs(%[[EMPTY]] : tensor<3x15x13x7xi32>)
// CHECK-NEXT: ^bb0(%[[IN:.+]]: i8, %[[OUT:.+]]: i32):
// CHECK: %[[EXT:.+]] = arith.extsi %[[IN]] : i8 to i32 // CHECK: %[[EXT:.+]] = arith.extsi %[[IN]] : i8 to i32
// CHECK: linalg.yield %[[EXT]] // CHECK-DAG: %[[C2:.+]] = arith.constant 2 : i32
%resize = "tosa.resize"(%arg0) {mode = "NEAREST_NEIGHBOR", scale = [2, 2, 1, 1], offset = [0, 0], border = [0, 0]} : (tensor<3x1x1x7xi8>) -> tensor<3x15x13x7xi32> // CHECK: %[[MUL:.+]] = arith.muli %[[EXT]], %[[C2]] : i32
// CHECK-DAG: %[[C3:.+]] = arith.constant 3 : i32
// CHECK: %[[OUT:.+]] = arith.muli %[[MUL]], %[[C3]] : i32
// CHECK: linalg.yield %[[OUT]] : i32
// CHECK: } -> tensor<3x7xi32>
// CHECK: %[[EXPAND:.+]] = tensor.expand_shape %1
// CHECK-SAME{literal}: [[0], [1, 2, 3]] : tensor<3x7xi32> into tensor<3x1x1x7xi32>
// CHECK: %[[COLLAPSE:.+]] = tensor.collapse_shape %expanded
// CHECK-SAME{literal}:[[0], [1, 2, 3]] : tensor<3x1x1x7xi32> into tensor<3x7xi32>
// CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<3x4x5x7xi32>
// CHECK: %[[BROADCAST:.+]] = linalg.generic
// CHECK-SAME: indexing_maps = [#map1, #map2], iterator_types = ["parallel", "parallel", "parallel", "parallel"]}
// CHECK-SAME: ins(%[[COLLAPSE]] : tensor<3x7xi32>) outs(%[[EMPTY]] : tensor<3x4x5x7xi32>) {
// CHECK: ^bb0(%[[IN:.+]]: i32, %[[OUT:.+]]: i32):
// CHECK: linalg.yield %[[IN]] : i32
%resize = "tosa.resize"(%arg0) {mode = "BILINEAR", scale = [2, 1, 3, 1], offset = [0, 0], border = [0, 0]} : (tensor<3x1x1x7xi8>) -> tensor<3x4x5x7xi32>
// CHECK: return %[[GENERIC]] // CHECK: return %[[BROADCAST]]
return %resize : tensor<3x15x13x7xi32> return %resize : tensor<3x4x5x7xi32>
} }
// ----- // -----
// CHECK: #map = affine_map<(d0, d1, d2, d3) -> (d0, d3)> // CHECK-LABEL: @unary_resize_bilinear_i32
// CHECK: #map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> func.func @unary_resize_bilinear_i32(%arg0 : tensor<3x1x1x7xi8>) -> tensor<3x1x1x7xi32> {
// CHECK-LABEL: @broadcast_resize_bilinear_i32
func.func @broadcast_resize_bilinear_i32(%arg0 : tensor<3x1x1x7xi8>) -> tensor<3x15x13x7xi32> {
// CHECK: %[[COLLAPSE:.+]] = tensor.collapse_shape %arg0 // CHECK: %[[COLLAPSE:.+]] = tensor.collapse_shape %arg0
// CHECK-SAME{literal}: [[0], [1, 2, 3]] // CHECK-SAME{literal}: [[0], [1, 2, 3]] : tensor<3x1x1x7xi8> into tensor<3x7xi8>
// CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<3x15x13x7xi32> // CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<3x7xi32>
// CHECK: %[[GENERIC:.+]] = linalg.generic // CHECK: %[[GENERIC:.+]] = linalg.generic
// CHECK-SAME: indexing_maps = [#map, #map1] // CHECK-SAME: indexing_maps = [#map, #map]
// CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "parallel"]} // CHECK-SAME: iterator_types = ["parallel", "parallel"]}
// CHECK-SAME: ins(%[[COLLAPSE]] : tensor<3x7xi8>) // CHECK-SAME: ins(%[[COLLAPSE]] : tensor<3x7xi8>) outs(%[[EMPTY]] : tensor<3x7xi32>) {
// CHECK-SAME: outs(%[[EMPTY]] : tensor<3x15x13x7xi32>) // CHECK: ^bb0(%[[IN:.+]]: i8, %[[OUT:.+]]: i32):
// CHECK-NEXT: ^bb0(%[[IN:.+]]: i8, %[[OUT:.+]]: i32):
// CHECK: %[[EXT:.+]] = arith.extsi %[[IN]] : i8 to i32 // CHECK: %[[EXT:.+]] = arith.extsi %[[IN]] : i8 to i32
// CHECK-DAG: %[[C2:.+]] = arith.constant 2 : i32 // CHECK-DAG: %[[C2:.+]] = arith.constant 2 : i32
// CHECK: %[[MUL1:.+]] = arith.muli %[[EXT]], %[[C2]] : i32 // CHECK: %[[MUL0:.+]] = arith.muli %[[EXT]], %[[C2]] : i32
// CHECK-DAG: %[[C1:.+]] = arith.constant 1 : i32 // CHECK-DAG: %[[C1:.+]] = arith.constant 2 : i32
// CHECK: %[[MUL2:.+]] = arith.muli %[[MUL1]], %[[C1]] : i32 // CHECK: %4 = arith.muli %3, %[[C1]] : i32
// CHECK: linalg.yield %[[MUL2]] // CHECK: linalg.yield %4 : i32
%resize = "tosa.resize"(%arg0) {mode = "BILINEAR", scale = [2, 2, 1, 1], offset = [0, 0], border = [0, 0]} : (tensor<3x1x1x7xi8>) -> tensor<3x15x13x7xi32> // CHECK: } -> tensor<3x7xi32>
// CHECK: %[[EXPAND:.+]] = tensor.expand_shape %[[GENERIC:.+]]
// CHECK-SAME{literal} [[0], [1, 2, 3]] : tensor<3x7xi32> into tensor<3x1x1x7xi32>
%resize = "tosa.resize"(%arg0) {mode = "BILINEAR", scale = [2, 1, 2, 1], offset = [0, 0], border = [0, 0]} : (tensor<3x1x1x7xi8>) -> tensor<3x1x1x7xi32>
// CHECK: return %[[GENERIC]] // CHECK: return %[[EXPAND]]
return %resize : tensor<3x15x13x7xi32> return %resize : tensor<3x1x1x7xi32>
} }
// ----- // -----
// CHECK-LABEL: @resize_nearest_int // CHECK-LABEL: @resize_nearest_int
func.func @resize_nearest_int(%arg0: tensor<1x15x13x1xi8>) -> () { func.func @resize_nearest_int(%arg0: tensor<1x15x13x1xi8>) -> () {
// CHECK: %[[INIT:.+]] = tensor.empty() : tensor<1x23x179x1xi8> // CHECK: %[[INIT:.+]] = tensor.empty() : tensor<1x23x179x1xi8>
// CHECK: %[[GENERIC:.+]] = linalg.generic // CHECK: %[[GENERIC:.+]] = linalg.generic
▲ Show 20 Lines • Show All 417 Lines • Show Last 20 Lines