MLIR  21.0.0git
Passes.h
Go to the documentation of this file.
1 //===- Passes.h - Pass Entrypoints ------------------------------*- 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 header file defines a set of transforms specific for the AffineOps
10 // dialect.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef MLIR_DIALECT_AFFINE_PASSES_H
15 #define MLIR_DIALECT_AFFINE_PASSES_H
16 
18 #include "mlir/Pass/Pass.h"
19 #include <limits>
20 
21 namespace mlir {
22 
23 namespace func {
24 class FuncOp;
25 } // namespace func
26 namespace memref {
27 class MemRefDialect;
28 } // namespace memref
29 
30 namespace affine {
31 class AffineForOp;
32 
33 /// Fusion mode to attempt. The default mode `Greedy` does both
34 /// producer-consumer and sibling fusion.
36 
37 #define GEN_PASS_DECL
38 #include "mlir/Dialect/Affine/Passes.h.inc"
39 
40 /// Creates a simplification pass for affine structures (maps and sets). In
41 /// addition, this pass also normalizes memrefs to have the trivial (identity)
42 /// layout map.
43 std::unique_ptr<OperationPass<func::FuncOp>>
45 
46 /// Creates a loop invariant code motion pass that hoists loop invariant
47 /// operations out of affine loops.
48 std::unique_ptr<OperationPass<func::FuncOp>>
50 
51 /// Creates a pass to convert all parallel affine.for's into 1-d affine.parallel
52 /// ops.
53 std::unique_ptr<OperationPass<func::FuncOp>> createAffineParallelizePass();
54 
55 /// Creates a pass that converts some memref operators to affine operators.
56 std::unique_ptr<OperationPass<func::FuncOp>> createRaiseMemrefToAffine();
57 
58 /// Apply normalization transformations to affine loop-like ops. If
59 /// `promoteSingleIter` is true, single iteration loops are promoted (i.e., the
60 /// loop is replaced by its loop body).
61 std::unique_ptr<OperationPass<func::FuncOp>>
62 createAffineLoopNormalizePass(bool promoteSingleIter = false);
63 
64 /// Performs packing (or explicit copying) of accessed memref regions into
65 /// buffers in the specified faster memory space through either pointwise copies
66 /// or DMA operations.
67 std::unique_ptr<OperationPass<func::FuncOp>> createAffineDataCopyGenerationPass(
68  unsigned slowMemorySpace, unsigned fastMemorySpace,
69  unsigned tagMemorySpace = 0, int minDmaTransferSize = 1024,
70  uint64_t fastMemCapacityBytes = std::numeric_limits<uint64_t>::max());
71 /// Overload relying on pass options for initialization.
72 std::unique_ptr<OperationPass<func::FuncOp>>
74 
75 /// Creates a pass to replace affine memref accesses by scalars using store to
76 /// load forwarding and redundant load elimination; consequently also eliminate
77 /// dead allocs.
78 std::unique_ptr<OperationPass<func::FuncOp>>
80 
81 /// Creates a pass that transforms perfectly nested loops with independent
82 /// bounds into a single loop.
83 std::unique_ptr<OperationPass<func::FuncOp>> createLoopCoalescingPass();
84 
85 /// Creates a loop fusion pass which fuses affine loop nests at the top-level of
86 /// the operation the pass is created on according to the type of fusion
87 /// specified in `fusionMode`. Buffers of size less than or equal to
88 /// `localBufSizeThreshold` are promoted to memory space `fastMemorySpace`.
89 std::unique_ptr<Pass>
90 createLoopFusionPass(unsigned fastMemorySpace = 0,
91  uint64_t localBufSizeThreshold = 0,
92  bool maximalFusion = false,
93  enum FusionMode fusionMode = FusionMode::Greedy);
94 
95 /// Creates a pass to perform tiling on loop nests.
96 std::unique_ptr<OperationPass<func::FuncOp>>
97 createLoopTilingPass(uint64_t cacheSizeBytes);
98 /// Overload relying on pass options for initialization.
99 std::unique_ptr<OperationPass<func::FuncOp>> createLoopTilingPass();
100 
101 /// Creates a loop unrolling pass with the provided parameters.
102 /// 'getUnrollFactor' is a function callback for clients to supply a function
103 /// that computes an unroll factor - the callback takes precedence over unroll
104 /// factors supplied through other means. If -1 is passed as the unrollFactor
105 /// and no callback is provided, anything passed from the command-line (if at
106 /// all) or the default unroll factor is used (LoopUnroll:kDefaultUnrollFactor).
107 std::unique_ptr<InterfacePass<FunctionOpInterface>> createLoopUnrollPass(
108  int unrollFactor = -1, bool unrollUpToFactor = false,
109  bool unrollFull = false,
110  const std::function<unsigned(AffineForOp)> &getUnrollFactor = nullptr);
111 
112 /// Creates a loop unroll jam pass to unroll jam by the specified factor. A
113 /// factor of -1 lets the pass use the default factor or the one on the command
114 /// line if provided.
115 std::unique_ptr<InterfacePass<FunctionOpInterface>>
116 createLoopUnrollAndJamPass(int unrollJamFactor = -1);
117 
118 /// Creates a pass to pipeline explicit movement of data across levels of the
119 /// memory hierarchy.
120 std::unique_ptr<OperationPass<func::FuncOp>> createPipelineDataTransferPass();
121 
122 /// Creates a pass to expand affine index operations into more fundamental
123 /// operations (not necessarily restricted to Affine dialect).
124 std::unique_ptr<Pass> createAffineExpandIndexOpsPass();
125 
126 /// Creates a pass to expand affine index operations into affine.apply
127 /// operations.
128 std::unique_ptr<Pass> createAffineExpandIndexOpsAsAffinePass();
129 
130 //===----------------------------------------------------------------------===//
131 // Registration
132 //===----------------------------------------------------------------------===//
133 
134 /// Generate the code for registering passes.
135 #define GEN_PASS_REGISTRATION
136 #include "mlir/Dialect/Affine/Passes.h.inc"
137 
138 } // namespace affine
139 } // namespace mlir
140 
141 #endif // MLIR_DIALECT_AFFINE_PASSES_H
static Value max(ImplicitLocOpBuilder &builder, Value value, Value bound)
std::unique_ptr< OperationPass< func::FuncOp > > createAffineScalarReplacementPass()
Creates a pass to replace affine memref accesses by scalars using store to load forwarding and redund...
std::unique_ptr< OperationPass< func::FuncOp > > createAffineLoopInvariantCodeMotionPass()
Creates a loop invariant code motion pass that hoists loop invariant operations out of affine loops.
std::unique_ptr< OperationPass< func::FuncOp > > createLoopCoalescingPass()
Creates a pass that transforms perfectly nested loops with independent bounds into a single loop.
std::unique_ptr< OperationPass< func::FuncOp > > createAffineLoopNormalizePass(bool promoteSingleIter=false)
Apply normalization transformations to affine loop-like ops.
std::unique_ptr< OperationPass< func::FuncOp > > createAffineDataCopyGenerationPass(unsigned slowMemorySpace, unsigned fastMemorySpace, unsigned tagMemorySpace=0, int minDmaTransferSize=1024, uint64_t fastMemCapacityBytes=std::numeric_limits< uint64_t >::max())
Performs packing (or explicit copying) of accessed memref regions into buffers in the specified faste...
std::unique_ptr< Pass > createLoopFusionPass(unsigned fastMemorySpace=0, uint64_t localBufSizeThreshold=0, bool maximalFusion=false, enum FusionMode fusionMode=FusionMode::Greedy)
Creates a loop fusion pass which fuses affine loop nests at the top-level of the operation the pass i...
FusionMode
Fusion mode to attempt.
Definition: Passes.h:35
@ ProducerConsumer
Definition: Passes.h:35
std::unique_ptr< OperationPass< func::FuncOp > > createRaiseMemrefToAffine()
Creates a pass that converts some memref operators to affine operators.
std::unique_ptr< OperationPass< func::FuncOp > > createLoopTilingPass(uint64_t cacheSizeBytes)
Creates a pass to perform tiling on loop nests.
Definition: LoopTiling.cpp:68
std::unique_ptr< Pass > createAffineExpandIndexOpsPass()
Creates a pass to expand affine index operations into more fundamental operations (not necessarily re...
std::unique_ptr< OperationPass< func::FuncOp > > createAffineParallelizePass()
Creates a pass to convert all parallel affine.for's into 1-d affine.parallel ops.
std::unique_ptr< OperationPass< func::FuncOp > > createSimplifyAffineStructuresPass()
Creates a simplification pass for affine structures (maps and sets).
std::unique_ptr< OperationPass< func::FuncOp > > createPipelineDataTransferPass()
Creates a pass to pipeline explicit movement of data across levels of the memory hierarchy.
std::unique_ptr< InterfacePass< FunctionOpInterface > > createLoopUnrollAndJamPass(int unrollJamFactor=-1)
Creates a loop unroll jam pass to unroll jam by the specified factor.
std::unique_ptr< Pass > createAffineExpandIndexOpsAsAffinePass()
Creates a pass to expand affine index operations into affine.apply operations.
std::unique_ptr< InterfacePass< FunctionOpInterface > > createLoopUnrollPass(int unrollFactor=-1, bool unrollUpToFactor=false, bool unrollFull=false, const std::function< unsigned(AffineForOp)> &getUnrollFactor=nullptr)
Creates a loop unrolling pass with the provided parameters.
Definition: LoopUnroll.cpp:149
Include the generated interface declarations.