MLIR  19.0.0git
GreedyPatternRewriteDriver.h
Go to the documentation of this file.
1 //===- GreedyPatternRewriteDriver.h - Greedy Pattern Driver -----*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file declares methods for applying a set of patterns greedily, choosing
10 // the patterns with the highest local benefit, until a fixed point is reached.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef MLIR_TRANSFORMS_GREEDYPATTERNREWRITEDRIVER_H_
15 #define MLIR_TRANSFORMS_GREEDYPATTERNREWRITEDRIVER_H_
16 
18 
19 namespace mlir {
20 
21 /// This enum controls which ops are put on the worklist during a greedy
22 /// pattern rewrite.
24  /// No restrictions wrt. which ops are processed.
25  AnyOp,
26  /// Only pre-existing and newly created ops are processed.
28  /// Only pre-existing ops are processed.
30 };
31 
33  /// Disable region control-flow simplification.
34  Disabled,
35  /// Run the normal simplification (e.g. dead args elimination).
36  Normal,
37  /// Run extra simplificiations (e.g. block merging), these can be
38  /// more costly or have some tradeoffs associated.
40 };
41 
42 /// This class allows control over how the GreedyPatternRewriteDriver works.
44 public:
45  /// This specifies the order of initial traversal that populates the rewriters
46  /// worklist. When set to true, it walks the operations top-down, which is
47  /// generally more efficient in compile time. When set to false, its initial
48  /// traversal of the region tree is bottom up on each block, which may match
49  /// larger patterns when given an ambiguous pattern set.
50  ///
51  /// Note: Only applicable when simplifying entire regions.
52  bool useTopDownTraversal = false;
53 
54  /// Perform control flow optimizations to the region tree after applying all
55  /// patterns.
56  ///
57  /// Note: Only applicable when simplifying entire regions.
60 
61  /// This specifies the maximum number of times the rewriter will iterate
62  /// between applying patterns and simplifying regions. Use `kNoLimit` to
63  /// disable this iteration limit.
64  ///
65  /// Note: Only applicable when simplifying entire regions.
66  int64_t maxIterations = 10;
67 
68  /// This specifies the maximum number of rewrites within an iteration. Use
69  /// `kNoLimit` to disable this limit.
71 
72  static constexpr int64_t kNoLimit = -1;
73 
74  /// Only ops within the scope are added to the worklist. If no scope is
75  /// specified, the closest enclosing region around the initial list of ops
76  /// (or the specified region, depending on which greedy rewrite entry point
77  /// is used) is used as a scope.
78  Region *scope = nullptr;
79 
80  /// Strict mode can restrict the ops that are added to the worklist during
81  /// the rewrite.
82  ///
83  /// * GreedyRewriteStrictness::AnyOp: No ops are excluded.
84  /// * GreedyRewriteStrictness::ExistingAndNewOps: Only pre-existing ops (that
85  /// were on the worklist at the very beginning) and newly created ops are
86  /// enqueued. All other ops are excluded.
87  /// * GreedyRewriteStrictness::ExistingOps: Only pre-existing ops (that were
88  /// were on the worklist at the very beginning) enqueued. All other ops are
89  /// excluded.
91 
92  /// An optional listener that should be notified about IR modifications.
94 };
95 
96 //===----------------------------------------------------------------------===//
97 // applyPatternsGreedily
98 //===----------------------------------------------------------------------===//
99 
100 /// Rewrite ops in the given region, which must be isolated from above, by
101 /// repeatedly applying the highest benefit patterns in a greedy worklist
102 /// driven manner until a fixpoint is reached.
103 ///
104 /// The greedy rewrite may prematurely stop after a maximum number of
105 /// iterations, which can be configured in the configuration parameter.
106 ///
107 /// Also performs folding and simple dead-code elimination before attempting to
108 /// match any of the provided patterns.
109 ///
110 /// A region scope can be set in the configuration parameter. By default, the
111 /// scope is set to the specified region. Only in-scope ops are added to the
112 /// worklist and only in-scope ops are allowed to be modified by the patterns.
113 ///
114 /// Returns "success" if the iterative process converged (i.e., fixpoint was
115 /// reached) and no more patterns can be matched within the region. `changed`
116 /// is set to "true" if the IR was modified at all.
117 ///
118 /// Note: This method does not apply patterns to the region's parent operation.
119 LogicalResult
121  const FrozenRewritePatternSet &patterns,
123  bool *changed = nullptr);
124 
125 /// Rewrite ops nested under the given operation, which must be isolated from
126 /// above, by repeatedly applying the highest benefit patterns in a greedy
127 /// worklist driven manner until a fixpoint is reached.
128 ///
129 /// The greedy rewrite may prematurely stop after a maximum number of
130 /// iterations, which can be configured in the configuration parameter.
131 ///
132 /// Also performs folding and simple dead-code elimination before attempting to
133 /// match any of the provided patterns.
134 ///
135 /// This overload runs a separate greedy rewrite for each region of the
136 /// specified op. A region scope can be set in the configuration parameter. By
137 /// default, the scope is set to the region of the current greedy rewrite. Only
138 /// in-scope ops are added to the worklist and only in-scope ops and the
139 /// specified op itself are allowed to be modified by the patterns.
140 ///
141 /// Note: The specified op may be modified, but it may not be removed by the
142 /// patterns.
143 ///
144 /// Returns "success" if the iterative process converged (i.e., fixpoint was
145 /// reached) and no more patterns can be matched within the region. `changed`
146 /// is set to "true" if the IR was modified at all.
147 ///
148 /// Note: This method does not apply patterns to the given operation itself.
149 inline LogicalResult
151  const FrozenRewritePatternSet &patterns,
153  bool *changed = nullptr) {
154  bool anyRegionChanged = false;
155  bool failed = false;
156  for (Region &region : op->getRegions()) {
157  bool regionChanged;
158  failed |=
159  applyPatternsAndFoldGreedily(region, patterns, config, &regionChanged)
160  .failed();
161  anyRegionChanged |= regionChanged;
162  }
163  if (changed)
164  *changed = anyRegionChanged;
165  return failure(failed);
166 }
167 
168 /// Rewrite the specified ops by repeatedly applying the highest benefit
169 /// patterns in a greedy worklist driven manner until a fixpoint is reached.
170 ///
171 /// The greedy rewrite may prematurely stop after a maximum number of
172 /// iterations, which can be configured in the configuration parameter.
173 ///
174 /// Also performs folding and simple dead-code elimination before attempting to
175 /// match any of the provided patterns.
176 ///
177 /// Newly created ops and other pre-existing ops that use results of rewritten
178 /// ops or supply operands to such ops are also processed, unless such ops are
179 /// excluded via `config.strictMode`. Any other ops remain unmodified (i.e.,
180 /// regardless of `strictMode`).
181 ///
182 /// In addition to strictness, a region scope can be specified. Only ops within
183 /// the scope are simplified. This is similar to `applyPatternsAndFoldGreedily`,
184 /// where only ops within the given region/op are simplified by default. If no
185 /// scope is specified, it is assumed to be the first common enclosing region of
186 /// the given ops.
187 ///
188 /// Note that ops in `ops` could be erased as result of folding, becoming dead,
189 /// or via pattern rewrites. If more far reaching simplification is desired,
190 /// `applyPatternsAndFoldGreedily` should be used.
191 ///
192 /// Returns "success" if the iterative process converged (i.e., fixpoint was
193 /// reached) and no more patterns can be matched. `changed` is set to "true" if
194 /// the IR was modified at all. `allOpsErased` is set to "true" if all ops in
195 /// `ops` were erased.
196 LogicalResult
197 applyOpPatternsAndFold(ArrayRef<Operation *> ops,
198  const FrozenRewritePatternSet &patterns,
199  GreedyRewriteConfig config = GreedyRewriteConfig(),
200  bool *changed = nullptr, bool *allErased = nullptr);
201 
202 } // namespace mlir
203 
204 #endif // MLIR_TRANSFORMS_GREEDYPATTERNREWRITEDRIVER_H_
This class represents a frozen set of patterns that can be processed by a pattern applicator.
This class allows control over how the GreedyPatternRewriteDriver works.
static constexpr int64_t kNoLimit
GreedyRewriteStrictness strictMode
Strict mode can restrict the ops that are added to the worklist during the rewrite.
int64_t maxIterations
This specifies the maximum number of times the rewriter will iterate between applying patterns and si...
Region * scope
Only ops within the scope are added to the worklist.
bool useTopDownTraversal
This specifies the order of initial traversal that populates the rewriters worklist.
RewriterBase::Listener * listener
An optional listener that should be notified about IR modifications.
int64_t maxNumRewrites
This specifies the maximum number of rewrites within an iteration.
GreedySimplifyRegionLevel enableRegionSimplification
Perform control flow optimizations to the region tree after applying all patterns.
Operation is the basic unit of execution within MLIR.
Definition: Operation.h:88
MutableArrayRef< Region > getRegions()
Returns the regions held by this operation.
Definition: Operation.h:672
This class contains a list of basic blocks and a link to the parent operation it is attached to.
Definition: Region.h:26
Include the generated interface declarations.
LogicalResult applyOpPatternsAndFold(ArrayRef< Operation * > ops, const FrozenRewritePatternSet &patterns, GreedyRewriteConfig config=GreedyRewriteConfig(), bool *changed=nullptr, bool *allErased=nullptr)
Rewrite the specified ops by repeatedly applying the highest benefit patterns in a greedy worklist dr...
@ Aggressive
Run extra simplificiations (e.g.
@ Normal
Run the normal simplification (e.g. dead args elimination).
@ Disabled
Disable region control-flow simplification.
LogicalResult applyPatternsAndFoldGreedily(Region &region, const FrozenRewritePatternSet &patterns, GreedyRewriteConfig config=GreedyRewriteConfig(), bool *changed=nullptr)
Rewrite ops in the given region, which must be isolated from above, by repeatedly applying the highes...
GreedyRewriteStrictness
This enum controls which ops are put on the worklist during a greedy pattern rewrite.
@ ExistingOps
Only pre-existing ops are processed.
@ ExistingAndNewOps
Only pre-existing and newly created ops are processed.
@ AnyOp
No restrictions wrt. which ops are processed.