MLIR  17.0.0git
Bufferize.h
Go to the documentation of this file.
1 //===- Bufferize.h - Bufferization Utilities --------------------*- 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 // We use the term "bufferize" to mean conversion from tensor types to
10 // memref types.
11 //
12 // Generally speaking, for each op that operates on tensor types, the
13 // `BufferizableOpInterface` needs to be implemented. This file contains the
14 // bufferization driver that is responsible for bufferizing the ops in the right
15 // order, etc.
16 //
17 //===----------------------------------------------------------------------===//
18 
19 #ifndef MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_BUFFERIZE_H
20 #define MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_BUFFERIZE_H
21 
23 
24 namespace mlir {
25 namespace bufferization {
26 
27 class AnalysisState;
28 struct BufferizationOptions;
29 class OpFilter;
30 
31 /// Bufferization statistics for debugging. These can be printed after running
32 /// the OneShotBufferizePass with `-mlir-pass-statistics`. See the pass
33 /// definition for more details.
35  int64_t numBufferAlloc = 0;
36  int64_t numBufferDealloc = 0;
37  int64_t numTensorInPlace = 0;
38  int64_t numTensorOutOfPlace = 0;
39 };
40 
41 /// A helper type converter class that automatically populates the relevant
42 /// materializations and type conversions for bufferization.
44 public:
46 };
47 
48 /// Marks ops used by bufferization for type conversion materializations as
49 /// "legal" in the given ConversionTarget.
50 ///
51 /// This function should be called by all bufferization passes using
52 /// BufferizeTypeConverter so that materializations work properly. One exception
53 /// is bufferization passes doing "full" conversions, where it can be desirable
54 /// for even the materializations to remain illegal so that they are eliminated,
55 /// such as via the patterns in
56 /// populateEliminateBufferizeMaterializationsPatterns.
58 
59 /// Populate patterns to eliminate bufferize materializations.
60 ///
61 /// In particular, these are the tensor_load/buffer_cast ops.
63  BufferizeTypeConverter &typeConverter, RewritePatternSet &patterns);
64 
65 /// Bufferize `op` and its nested ops that implement `BufferizableOpInterface`.
66 /// If `copyBeforeWrite`, buffers are duplicated and copied before any tensor
67 /// use that bufferizes to a memory write.
68 ///
69 /// Note: In the general case, it unsafe to run with `copyBeforeWrite = false`
70 /// because read-after-write conflicts may materialize during bufferization.
71 /// `copyBeforeWrite = false` is safe only if the input IR is guaranteed to
72 /// *not* require any out-of-place bufferization.
73 ///
74 /// Note: This function bufferizes ops without utilizing analysis results. It
75 /// can be used to implement partial bufferization passes.
77  bool copyBeforeWrite = true,
78  const OpFilter *opFilter = nullptr,
79  BufferizationStatistics *statistics = nullptr);
80 
82 
83 } // namespace bufferization
84 } // namespace mlir
85 
86 #endif // MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_BUFFERIZE_H
static llvm::ManagedStatic< PassManagerOptions > options
This class describes a specific conversion target.
Operation is the basic unit of execution within MLIR.
Definition: Operation.h:75
Type conversion class.
A helper type converter class that automatically populates the relevant materializations and type con...
Definition: Bufferize.h:43
BufferizeTypeConverter()
Registers conversions into BufferizeTypeConverter.
Definition: Bufferize.cpp:52
void populateEliminateBufferizeMaterializationsPatterns(BufferizeTypeConverter &typeConverter, RewritePatternSet &patterns)
Populate patterns to eliminate bufferize materializations.
Definition: Bufferize.cpp:129
void populateBufferizeMaterializationLegality(ConversionTarget &target)
Marks ops used by bufferization for type conversion materializations as "legal" in the given Conversi...
Definition: Bufferize.cpp:92
LogicalResult bufferizeOp(Operation *op, const BufferizationOptions &options, bool copyBeforeWrite=true, const OpFilter *opFilter=nullptr, BufferizationStatistics *statistics=nullptr)
Bufferize op and its nested ops that implement BufferizableOpInterface.
Definition: Bufferize.cpp:427
BufferizationOptions getPartialBufferizationOptions()
Definition: Bufferize.cpp:544
This header declares functions that assit transformations in the MemRef dialect.
This class represents an efficient way to signal success or failure.
Definition: LogicalResult.h:26
Options for BufferizableOpInterface-based bufferization.
Bufferization statistics for debugging.
Definition: Bufferize.h:34