From ae1651368f5ed243b3cedfe8f743799e5061a8de Mon Sep 17 00:00:00 2001 From: River Riddle Date: Fri, 24 May 2019 10:36:16 -0700 Subject: [PATCH] NFC: Rename DialectConversionPattern to ConversionPattern. -- PiperOrigin-RevId: 249857277 --- .../Linalg1/include/linalg1/ConvertToLLVMDialect.h | 2 +- .../Linalg/Linalg1/lib/ConvertToLLVMDialect.cpp | 19 +++++++--------- .../Linalg/Linalg3/lib/ConvertToLLVMDialect.cpp | 5 ++--- mlir/examples/toy/Ch5/mlir/EarlyLowering.cpp | 6 ++--- mlir/examples/toy/Ch5/mlir/LateLowering.cpp | 26 +++++++++------------- mlir/g3doc/Tutorials/Linalg/LLVMConversion.md | 19 ++++++++-------- mlir/g3doc/Tutorials/Toy/Ch-5.md | 8 +++---- mlir/include/mlir/LLVMIR/LLVMLowering.h | 2 +- mlir/include/mlir/Transforms/DialectConversion.h | 17 +++++++------- .../lib/LLVMIR/Transforms/ConvertToLLVMDialect.cpp | 2 +- mlir/lib/Transforms/DialectConversion.cpp | 8 +++---- 11 files changed, 52 insertions(+), 62 deletions(-) diff --git a/mlir/examples/Linalg/Linalg1/include/linalg1/ConvertToLLVMDialect.h b/mlir/examples/Linalg/Linalg1/include/linalg1/ConvertToLLVMDialect.h index cf5d7ef..8bc80d2 100644 --- a/mlir/examples/Linalg/Linalg1/include/linalg1/ConvertToLLVMDialect.h +++ b/mlir/examples/Linalg/Linalg1/include/linalg1/ConvertToLLVMDialect.h @@ -24,8 +24,8 @@ #include namespace mlir { +class ConversionPattern; class DialectConversion; -class DialectConversionPattern; class MLIRContext; class Module; class RewritePattern; diff --git a/mlir/examples/Linalg/Linalg1/lib/ConvertToLLVMDialect.cpp b/mlir/examples/Linalg/Linalg1/lib/ConvertToLLVMDialect.cpp index b81fc25..9a97ee9 100644 --- a/mlir/examples/Linalg/Linalg1/lib/ConvertToLLVMDialect.cpp +++ b/mlir/examples/Linalg/Linalg1/lib/ConvertToLLVMDialect.cpp @@ -131,11 +131,10 @@ static ArrayAttr makePositionAttr(FuncBuilder &builder, } // RangeOp creates a new range descriptor. -class RangeOpConversion : public DialectConversionPattern { +class RangeOpConversion : public ConversionPattern { public: explicit RangeOpConversion(MLIRContext *context) - : DialectConversionPattern(linalg::RangeOp::getOperationName(), 1, - context) {} + : ConversionPattern(linalg::RangeOp::getOperationName(), 1, context) {} void rewrite(Operation *op, ArrayRef operands, PatternRewriter &rewriter) const override { @@ -158,11 +157,10 @@ public: } }; -class ViewOpConversion : public DialectConversionPattern { +class ViewOpConversion : public ConversionPattern { public: explicit ViewOpConversion(MLIRContext *context) - : DialectConversionPattern(linalg::ViewOp::getOperationName(), 1, - context) {} + : ConversionPattern(linalg::ViewOp::getOperationName(), 1, context) {} void rewrite(Operation *op, ArrayRef operands, PatternRewriter &rewriter) const override { @@ -283,11 +281,10 @@ public: } }; -class SliceOpConversion : public DialectConversionPattern { +class SliceOpConversion : public ConversionPattern { public: explicit SliceOpConversion(MLIRContext *context) - : DialectConversionPattern(linalg::SliceOp::getOperationName(), 1, - context) {} + : ConversionPattern(linalg::SliceOp::getOperationName(), 1, context) {} void rewrite(Operation *op, ArrayRef operands, PatternRewriter &rewriter) const override { @@ -375,10 +372,10 @@ public: // When converting the "some_consumer" operation, don't emit anything and // effectively drop it. -class DropConsumer : public DialectConversionPattern { +class DropConsumer : public ConversionPattern { public: explicit DropConsumer(MLIRContext *context) - : DialectConversionPattern("some_consumer", 1, context) {} + : ConversionPattern("some_consumer", 1, context) {} void rewrite(Operation *op, ArrayRef operands, PatternRewriter &rewriter) const override { diff --git a/mlir/examples/Linalg/Linalg3/lib/ConvertToLLVMDialect.cpp b/mlir/examples/Linalg/Linalg3/lib/ConvertToLLVMDialect.cpp index 4a258f8..adfa1f7 100644 --- a/mlir/examples/Linalg/Linalg3/lib/ConvertToLLVMDialect.cpp +++ b/mlir/examples/Linalg/Linalg3/lib/ConvertToLLVMDialect.cpp @@ -51,11 +51,10 @@ static ArrayAttr makePositionAttr(FuncBuilder &builder, namespace { // Common functionality for Linalg LoadOp and StoreOp conversion to the // LLVM IR Dialect. -template -class LoadStoreOpConversion : public DialectConversionPattern { +template class LoadStoreOpConversion : public ConversionPattern { public: explicit LoadStoreOpConversion(MLIRContext *context) - : DialectConversionPattern(Op::getOperationName(), 1, context) {} + : ConversionPattern(Op::getOperationName(), 1, context) {} using Base = LoadStoreOpConversion; // Compute the pointer to an element of the buffer underlying the view given diff --git a/mlir/examples/toy/Ch5/mlir/EarlyLowering.cpp b/mlir/examples/toy/Ch5/mlir/EarlyLowering.cpp index 72ef800..d38ad4f 100644 --- a/mlir/examples/toy/Ch5/mlir/EarlyLowering.cpp +++ b/mlir/examples/toy/Ch5/mlir/EarlyLowering.cpp @@ -77,14 +77,14 @@ Value *memRefTypeCast(FuncBuilder &builder, Value *val) { /// Lower toy.mul to Linalg `matmul`. /// -/// This class inherit from `DialectConversionPattern` and override `rewrite`, +/// This class inherit from `ConversionPattern` and override `rewrite`, /// similarly to the PatternRewriter introduced in the previous chapter. /// It will be called by the DialectConversion framework (see `LateLowering` /// class below). -class MulOpConversion : public DialectConversionPattern { +class MulOpConversion : public ConversionPattern { public: explicit MulOpConversion(MLIRContext *context) - : DialectConversionPattern(toy::MulOp::getOperationName(), 1, context) {} + : ConversionPattern(toy::MulOp::getOperationName(), 1, context) {} void rewrite(Operation *op, ArrayRef operands, PatternRewriter &rewriter) const override { diff --git a/mlir/examples/toy/Ch5/mlir/LateLowering.cpp b/mlir/examples/toy/Ch5/mlir/LateLowering.cpp index 2837807..13b20b9 100644 --- a/mlir/examples/toy/Ch5/mlir/LateLowering.cpp +++ b/mlir/examples/toy/Ch5/mlir/LateLowering.cpp @@ -77,14 +77,14 @@ Value *memRefTypeCast(FuncBuilder &builder, Value *val) { /// Lower a toy.add to an affine loop nest. /// -/// This class inherit from `DialectConversionPattern` and override `rewrite`, +/// This class inherit from `ConversionPattern` and override `rewrite`, /// similarly to the PatternRewriter introduced in the previous chapter. /// It will be called by the DialectConversion framework (see `LateLowering` /// class below). -class AddOpConversion : public DialectConversionPattern { +class AddOpConversion : public ConversionPattern { public: explicit AddOpConversion(MLIRContext *context) - : DialectConversionPattern(toy::AddOp::getOperationName(), 1, context) {} + : ConversionPattern(toy::AddOp::getOperationName(), 1, context) {} /// Lower the `op` by generating IR using the `rewriter` builder. The builder /// is setup with a new function, the `operands` array has been populated with @@ -126,11 +126,10 @@ public: /// Lowers `toy.print` to a loop nest calling `printf` on every individual /// elements of the array. -class PrintOpConversion : public DialectConversionPattern { +class PrintOpConversion : public ConversionPattern { public: explicit PrintOpConversion(MLIRContext *context) - : DialectConversionPattern(toy::PrintOp::getOperationName(), 1, context) { - } + : ConversionPattern(toy::PrintOp::getOperationName(), 1, context) {} void rewrite(Operation *op, ArrayRef operands, PatternRewriter &rewriter) const override { @@ -225,11 +224,10 @@ private: }; /// Lowers constant to a sequence of store in a buffer. -class ConstantOpConversion : public DialectConversionPattern { +class ConstantOpConversion : public ConversionPattern { public: explicit ConstantOpConversion(MLIRContext *context) - : DialectConversionPattern(toy::ConstantOp::getOperationName(), 1, - context) {} + : ConversionPattern(toy::ConstantOp::getOperationName(), 1, context) {} void rewrite(Operation *op, ArrayRef operands, PatternRewriter &rewriter) const override { @@ -269,11 +267,10 @@ public: }; /// Lower transpose operation to an affine loop nest. -class TransposeOpConversion : public DialectConversionPattern { +class TransposeOpConversion : public ConversionPattern { public: explicit TransposeOpConversion(MLIRContext *context) - : DialectConversionPattern(toy::TransposeOp::getOperationName(), 1, - context) {} + : ConversionPattern(toy::TransposeOp::getOperationName(), 1, context) {} void rewrite(Operation *op, ArrayRef operands, PatternRewriter &rewriter) const override { @@ -302,11 +299,10 @@ public: }; // Lower toy.return to standard return operation. -class ReturnOpConversion : public DialectConversionPattern { +class ReturnOpConversion : public ConversionPattern { public: explicit ReturnOpConversion(MLIRContext *context) - : DialectConversionPattern(toy::ReturnOp::getOperationName(), 1, - context) {} + : ConversionPattern(toy::ReturnOp::getOperationName(), 1, context) {} void rewrite(Operation *op, ArrayRef operands, PatternRewriter &rewriter) const override { diff --git a/mlir/g3doc/Tutorials/Linalg/LLVMConversion.md b/mlir/g3doc/Tutorials/Linalg/LLVMConversion.md index 9f5c552..83a2a31 100644 --- a/mlir/g3doc/Tutorials/Linalg/LLVMConversion.md +++ b/mlir/g3doc/Tutorials/Linalg/LLVMConversion.md @@ -212,11 +212,11 @@ offset, the min/max values or the strides. Their static (constant) dimensions are available directly in the type signature. An operation conversion is defined as special pattern by inheriting from -`mlir::DialectConversionPattern` and by reimplementing the matching and the -rewriting functions: +`mlir::ConversionPattern` and by reimplementing the matching and the rewriting +functions: ```c++ -class ViewOpConversion : public DialectConversionPattern { +class ViewOpConversion : public ConversionPattern { public: // A conversion constructor, may take arbtirary operands but must be able // to obtain an MLIRContext from them to call the parent constructor. @@ -237,15 +237,14 @@ public: } ``` -The `DialectConversionPattern` constructor takes, in addition to the context, -the name of the main operation to be matched and the "benefit" of a match. These -operands are intended to be useful for defining an optimization problem across -multiple possible conversions but are currently ignored by the conversion -framework. +The `ConversionPattern` constructor takes, in addition to the context, the name +of the main operation to be matched and the "benefit" of a match. These operands +are intended to be useful for defining an optimization problem across multiple +possible conversions but are currently ignored by the conversion framework. ```c++ ViewOpConversion::ViewOpConversion(MLIRContext *context) - : DialectConversionPattern(linalg::ViewOp::getOperationName(), 1, context) {} + : ConversionPattern(linalg::ViewOp::getOperationName(), 1, context) {} ``` The matching function can be used, for example, to apply different conversions @@ -621,7 +620,7 @@ class Lowering : public DialectConversion { protected: // Produce a set of operation conversion patterns. This is called once per // conversion. - llvm::DenseSet + llvm::DenseSet initConverter(MLIRContext *context) override { allocator.Reset(); // Call a helper function provided by MLIR to build a set of operation diff --git a/mlir/g3doc/Tutorials/Toy/Ch-5.md b/mlir/g3doc/Tutorials/Toy/Ch-5.md index 37ac637..2461275 100644 --- a/mlir/g3doc/Tutorials/Toy/Ch-5.md +++ b/mlir/g3doc/Tutorials/Toy/Ch-5.md @@ -49,7 +49,7 @@ public: SmallVectorImpl &convertedArgAttrs) { /*...*/ } // This gets called once to set up operation converters. - llvm::DenseSet + llvm::DenseSet initConverters(MLIRContext *context) override { RewriteListBuilder::build(allocator, context); @@ -65,14 +65,14 @@ Individual operation converters are following this pattern: ```c++ /// Lower a toy.add to an affine loop nest. /// -/// This class inherit from `DialectConversionPattern` and override `rewrite`, +/// This class inherit from `ConversionPattern` and override `rewrite`, /// similarly to the PatternRewriter introduced in the previous chapter. /// It will be called by the DialectConversion framework (see `LateLowering` /// class below). -class AddOpConversion : public DialectConversionPattern { +class AddOpConversion : public ConversionPattern { public: explicit AddOpConversion(MLIRContext *context) - : DialectConversionPattern(toy::AddOp::getOperationName(), 1, context) {} + : ConversionPattern(toy::AddOp::getOperationName(), 1, context) {} /// Lower the `op` by generating IR using the `rewriter` builder. The builder /// is setup with a new function, the `operands` array has been populated with diff --git a/mlir/include/mlir/LLVMIR/LLVMLowering.h b/mlir/include/mlir/LLVMIR/LLVMLowering.h index 9947f42..9db282f 100644 --- a/mlir/include/mlir/LLVMIR/LLVMLowering.h +++ b/mlir/include/mlir/LLVMIR/LLVMLowering.h @@ -135,7 +135,7 @@ private: /// Base class for operation conversions targeting the LLVM IR dialect. Provides /// conversion patterns with an access to the containing LLVMLowering for the /// purpose of type conversions. -class LLVMOpLowering : public DialectConversionPattern { +class LLVMOpLowering : public ConversionPattern { public: LLVMOpLowering(StringRef rootOpName, MLIRContext *context, LLVMLowering &lowering); diff --git a/mlir/include/mlir/Transforms/DialectConversion.h b/mlir/include/mlir/Transforms/DialectConversion.h index d1b3318..bbbcd7d 100644 --- a/mlir/include/mlir/Transforms/DialectConversion.h +++ b/mlir/include/mlir/Transforms/DialectConversion.h @@ -36,17 +36,16 @@ class Operation; class Type; class Value; -/// Base class for the dialect conversion patterns that require type changes. -/// Specific conversions must derive this class and implement least one -/// `rewrite` method. +/// Base class for the conversion patterns that require type changes. Specific +/// conversions must derive this class and implement least one `rewrite` method. /// NOTE: These conversion patterns can only be used with the 'apply*' methods /// below. -class DialectConversionPattern : public RewritePattern { +class ConversionPattern : public RewritePattern { public: - /// Construct an DialectConversionPattern. `rootName` must correspond to the + /// Construct an ConversionPattern. `rootName` must correspond to the /// canonical name of the first operation matched by the pattern. - DialectConversionPattern(StringRef rootName, PatternBenefit benefit, - MLIRContext *ctx) + ConversionPattern(StringRef rootName, PatternBenefit benefit, + MLIRContext *ctx) : RewritePattern(rootName, benefit, ctx) {} /// Hook for derived classes to implement matching. Dialect conversion @@ -60,7 +59,7 @@ public: /// operation matched by the pattern, `operands` is a list of rewritten values /// that are passed to this operation, `rewriter` can be used to emit the new /// operations. This function must be reimplemented if the - /// DialectConversionPattern ever needs to replace an operation that does not + /// ConversionPattern ever needs to replace an operation that does not /// have successors. This function should not fail. If some specific cases of /// the operation are not supported, these cases should not be matched. virtual void rewrite(Operation *op, ArrayRef operands, @@ -74,7 +73,7 @@ public: /// of (potentially rewritten) successor blocks, `operands` is a list of lists /// of rewritten values passed to each of the successors, co-indexed with /// `destinations`, `rewriter` can be used to emit the new operations. It must - /// be reimplemented if the DialectConversionPattern ever needs to replace a + /// be reimplemented if the ConversionPattern ever needs to replace a /// terminator operation that has successors. This function should not fail /// the pass. If some specific cases of the operation are not supported, /// these cases should not be matched. diff --git a/mlir/lib/LLVMIR/Transforms/ConvertToLLVMDialect.cpp b/mlir/lib/LLVMIR/Transforms/ConvertToLLVMDialect.cpp index 347280d..acf0be3 100644 --- a/mlir/lib/LLVMIR/Transforms/ConvertToLLVMDialect.cpp +++ b/mlir/lib/LLVMIR/Transforms/ConvertToLLVMDialect.cpp @@ -185,7 +185,7 @@ static Type getMemRefElementPtrType(MemRefType t, LLVMLowering &lowering) { LLVMOpLowering::LLVMOpLowering(StringRef rootOpName, MLIRContext *context, LLVMLowering &lowering_) - : DialectConversionPattern(rootOpName, /*benefit=*/1, context), + : ConversionPattern(rootOpName, /*benefit=*/1, context), lowering(lowering_) {} namespace { diff --git a/mlir/lib/Transforms/DialectConversion.cpp b/mlir/lib/Transforms/DialectConversion.cpp index 3a65295..4428302 100644 --- a/mlir/lib/Transforms/DialectConversion.cpp +++ b/mlir/lib/Transforms/DialectConversion.cpp @@ -90,7 +90,7 @@ constexpr StringLiteral ArgConverter::kCastName; // DialectConversionRewriter //===----------------------------------------------------------------------===// -/// This class implements a pattern rewriter for DialectConversionPattern +/// This class implements a pattern rewriter for ConversionPattern /// patterns. It automatically performs remapping of replaced operation values. struct DialectConversionRewriter final : public PatternRewriter { /// This class represents one requested operation replacement via 'replaceOp'. @@ -182,15 +182,15 @@ struct DialectConversionRewriter final : public PatternRewriter { } // end anonymous namespace //===----------------------------------------------------------------------===// -// DialectConversionPattern +// ConversionPattern //===----------------------------------------------------------------------===// /// Rewrite the IR rooted at the specified operation with the result of this /// pattern. If an unexpected error is encountered (an internal compiler /// error), it is emitted through the normal MLIR diagnostic hooks and the IR is /// left in a valid state. -void DialectConversionPattern::rewrite(Operation *op, - PatternRewriter &rewriter) const { +void ConversionPattern::rewrite(Operation *op, + PatternRewriter &rewriter) const { SmallVector operands; auto &dialectRewriter = static_cast(rewriter); dialectRewriter.remapValues(op->getOperands(), operands); -- 2.7.4