This is an archive of the discontinued LLVM Phabricator instance.

Differential D83123

[MLIR][Shape] Lower `shape.any`
ClosedPublic

Authored by frgossen on Jul 3 2020, 3:13 AM.

Details

Reviewers
herhut
tpopp
Commits
rG9df6afbb5c99: [MLIR][Shape] Lower `shape.any`
Summary

Lower shape.any to its first operand.

Diff Detail

Event Timeline

frgossen created this revision.Jul 3 2020, 3:13 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 3 2020, 3:13 AM
Herald added subscribers: msifontes, jurahul, Kayjukh and 14 others. · View Herald Transcript
Harbormaster completed remote builds in B62826: Diff 275342.Jul 3 2020, 4:17 AM
herhut accepted this revision.Jul 3 2020, 6:26 AM
herhut added inline comments.
mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp
33

Maybe add a comment here that this is a valid interpretation of the any operation, as this is surprising.

This revision is now accepted and ready to land.Jul 3 2020, 6:26 AM
tpopp accepted this revision.Jul 6 2020, 2:46 AM
frgossen updated this revision to Diff 277342.Jul 13 2020, 1:28 AM
frgossen marked an inline comment as done.

Add comment

Closed by commit rG9df6afbb5c99: [MLIR][Shape] Lower `shape.any` (authored by frgossen). · Explain WhyJul 13 2020, 1:30 AM
This revision was automatically updated to reflect the committed changes.
Harbormaster completed remote builds in B63917: Diff 277342.Jul 13 2020, 1:44 AM

Revision Contents

PathSize
mlir/
lib/
Conversion/
ShapeToStandard/
14 lines
1 line
test/
Conversion/
ShapeToStandard/
23 lines

Diff 275342

mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp

Show All 17 Lines
using namespace mlir::shape; using namespace mlir::shape;
namespace { namespace {
/// Generated conversion patterns. /// Generated conversion patterns.
#include "ShapeToStandardPatterns.inc" #include "ShapeToStandardPatterns.inc"
/// Conversion patterns. /// Conversion patterns.
class AnyOpConversion : public OpConversionPattern<AnyOp> {
public:
using OpConversionPattern<AnyOp>::OpConversionPattern;
LogicalResult
matchAndRewrite(AnyOp op, ArrayRef<Value> operands,
ConversionPatternRewriter &rewriter) const override {
AnyOp::Adaptor transformed(operands);
herhutUnsubmitted
Done
ReplyInline Actions

Maybe add a comment here that this is a valid interpretation of the any operation, as this is surprising.

herhut: Maybe add a comment here that this is a valid interpretation of the any operation, as this is…
rewriter.replaceOp(op, {transformed.inputs().front()});
return success();
}
};
template <typename SrcOpTy, typename DstOpTy> template <typename SrcOpTy, typename DstOpTy>
class BinaryOpConversion : public OpConversionPattern<SrcOpTy> { class BinaryOpConversion : public OpConversionPattern<SrcOpTy> {
public: public:
using OpConversionPattern<SrcOpTy>::OpConversionPattern; using OpConversionPattern<SrcOpTy>::OpConversionPattern;
LogicalResult LogicalResult
matchAndRewrite(SrcOpTy op, ArrayRef<Value> operands, matchAndRewrite(SrcOpTy op, ArrayRef<Value> operands,
ConversionPatternRewriter &rewriter) const override { ConversionPatternRewriter &rewriter) const override {
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines
} // namespace } // namespace
void mlir::populateShapeToStandardConversionPatterns( void mlir::populateShapeToStandardConversionPatterns(
OwningRewritePatternList &patterns, MLIRContext *ctx) { OwningRewritePatternList &patterns, MLIRContext *ctx) {
populateWithGenerated(ctx, &patterns); populateWithGenerated(ctx, &patterns);
// clang-format off // clang-format off
patterns.insert< patterns.insert<
AnyOpConversion,
BinaryOpConversion<AddOp, AddIOp>, BinaryOpConversion<AddOp, AddIOp>,
BinaryOpConversion<MulOp, MulIOp>, BinaryOpConversion<MulOp, MulIOp>,
ConstSizeOpConverter, ConstSizeOpConverter,
GetExtentOpConverter, GetExtentOpConverter,
RankOpConverter, RankOpConverter,
ShapeOfOpConversion>(ctx); ShapeOfOpConversion>(ctx);
// clang-format on // clang-format on
} }
std::unique_ptr<OperationPass<ModuleOp>> std::unique_ptr<OperationPass<ModuleOp>>
mlir::createConvertShapeToStandardPass() { mlir::createConvertShapeToStandardPass() {
return std::make_unique<ConvertShapeToStandardPass>(); return std::make_unique<ConvertShapeToStandardPass>();
} }

mlir/lib/Conversion/ShapeToStandard/ShapeToStandardPatterns.td

Show All 12 Lines
// Convert `index_to_size` and `size_to_index` to no-ops as sizes will be // Convert `index_to_size` and `size_to_index` to no-ops as sizes will be
// represented as indices. // represented as indices.
def IndexToSizeOpConversion : Pat< def IndexToSizeOpConversion : Pat<
(Shape_IndexToSizeOp $arg), (Shape_IndexToSizeOp $arg),
(replaceWithValue $arg)>; (replaceWithValue $arg)>;
def SizeToIndexOpConversion : Pat< def SizeToIndexOpConversion : Pat<
(Shape_SizeToIndexOp $arg), (Shape_SizeToIndexOp $arg),
(replaceWithValue $arg)>; (replaceWithValue $arg)>;

mlir/test/Conversion/ShapeToStandard/shape-to-standard.mlir

Show First 20 Lines • Show All 152 Lines • ▼ Show 20 Linesfunc @get_extent_from_extent_tensor(%extents : tensor<?xindex>,
%idx : !shape.size) -> !shape.size { %idx : !shape.size) -> !shape.size {
// CHECK: %[[RESULT:.*]] = extract_element %[[EXTENTS]][%[[IDX]]] : tensor<?xindex> // CHECK: %[[RESULT:.*]] = extract_element %[[EXTENTS]][%[[IDX]]] : tensor<?xindex>
// CHECK: return %[[RESULT]] : index // CHECK: return %[[RESULT]] : index
%shape = shape.from_extent_tensor %extents : tensor<?xindex> %shape = shape.from_extent_tensor %extents : tensor<?xindex>
%result = shape.get_extent %shape, %idx %result = shape.get_extent %shape, %idx
return %result : !shape.size return %result : !shape.size
} }
// -----
// Lower `any` to its first operand.
// CHECK-LABEL: @any_of_three
// CHECK-SAME: (%[[A:.*]]: tensor<?xindex>, %[[B:.*]]: tensor<?xindex>, %[[C:.*]]: tensor<?xindex>) -> tensor<?xindex>
func @any_of_three(%a : !shape.shape, %b : !shape.shape, %c : !shape.shape)
-> !shape.shape {
// CHECK: return %[[A]] : tensor<?xindex>
%result = shape.any %a, %b, %c
return %result : !shape.shape
}
// -----
// Lower `any` to its first operand.
// CHECK-LABEL: @any_of_one
// CHECK-SAME: (%[[A:.*]]: tensor<?xindex>) -> tensor<?xindex>
func @any_of_one(%a : !shape.shape) -> !shape.shape {
// CHECK: return %[[A]] : tensor<?xindex>
%result = shape.any %a
return %result : !shape.shape
}