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