CINXE.COM

<!doctype html><html lang=en-us><head><meta charset=utf-8><meta http-equiv=x-ua-compatible content="IE=edge"><meta name=viewport content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no"><title>Ownership-based Buffer Deallocation - MLIR</title><meta name=description content="Multi-Level IR Compiler Framework"><meta name=generator content="Hugo 0.119.0"><link href=https://mlir.llvm.org/index.xml rel=alternate type=application/rss+xml><link rel=canonical href=https://mlir.llvm.org/docs/OwnershipBasedBufferDeallocation/><link rel=stylesheet href=https://mlir.llvm.org/css/theme.css><script src=https://use.fontawesome.com/releases/v5.0.6/js/all.js></script> <link rel=stylesheet href=https://mlir.llvm.org/css/chroma.min.css><script src=https://cdn.jsdelivr.net/npm/jquery@3.3.1/dist/jquery.min.js></script> <script src=https://cdn.jsdelivr.net/npm/jquery.easing@1.4.1/jquery.easing.min.js></script> <script src=https://mlir.llvm.org/js/bundle.js></script> <script type=text/javascript src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script> <script type=text/x-mathjax-config> MathJax.Hub.Config({ tex2jax: { inlineMath: [['$', '$'] ], displayMath: [ ['$$','$$'], ["\\[","\\]"] ] } }); </script><link rel=apple-touch-icon sizes=180x180 href="/apple-touch-icon.png?v=1"><link rel=icon type=image/png sizes=32x32 href="/favicon-32x32.png?v=1"><link rel=icon type=image/png sizes=16x16 href="/favicon-16x16.png?v=1"><link rel=manifest href="/site.webmanifest?v=1"><link rel=mask-icon href="/safari-pinned-tab.svg?v=1" color=#3775e0><link rel="shortcut icon" href="/favicon.ico?v=1"><meta name=msapplication-TileColor content="#2d89ef"><meta name=theme-color content="#ffffff"><link rel=icon href=/favicon.svg type=image/svg+xml sizes=any><style>:root{}</style></head><body><div class=container><header><h1><div><img src=https://mlir.llvm.org//mlir-logo.png width=40px align=absmiddle> MLIR</div></h1>Multi-Level IR Compiler Framework</header><div class=global-menu><nav><ul><li class=parent><a href>Community</a><ul class=sub-menu><li class=child><a href=https://llvm.discourse.group/c/mlir/31>Forums</a></li><li class=child><a href=https://discord.gg/xS7Z362>Chat</a></li></ul></li><li><a href=/getting_started/Debugging/>Debugging Tips</a></li><li><a href=/getting_started/Faq/>FAQ</a></li><li class=parent><a href=https://github.com/llvm/llvm-project/tree/main/mlir>Source</a><ul class=sub-menu><li class=child><a href=/doxygen/>Doxygen</a></li><li class=child><a href=https://github.com/llvm/llvm-project/tree/main/mlir>GitHub</a></li></ul></li><li><a href="https://bugs.llvm.org/buglist.cgi?bug_status=__open__&list_id=177877&order=changeddate%20DESC%2Cpriority%2Cbug_severity&product=MLIR&query_format=specific">Bugs</a></li><li><a href=https://github.com/llvm/mlir-www/tree/main/website/static/LogoAssets>Logo Assets</a></li><li><a href=https://www.youtube.com/MLIRCompiler>Youtube Channel</a></li></ul></nav></div><div class=content-container><main><h1>Ownership-based Buffer Deallocation</h1><nav id=TableOfContents><ul><li><a href=#function-boundary-abi>Function boundary ABI</a></li><li><a href=#inserting-bufferizationdealloc-operations>Inserting <code>bufferization.dealloc</code> operations</a></li><li><a href=#supported-interfaces>Supported interfaces</a></li><li><a href=#limitations>Limitations</a></li><li><a href=#example>Example</a></li><li><a href=#buffer-deallocation-simplification-pass>Buffer Deallocation Simplification Pass</a></li><li><a href=#lower-deallocations-pass>Lower Deallocations Pass</a><ul><li><a href=#generic-lowering>Generic Lowering</a></li><li><a href=#specialized-lowerings>Specialized Lowerings</a></li></ul></li></ul></nav>One-Shot Bufferize does not deallocate any buffers that it allocates. After running One-Shot Bufferize, the resulting IR may have a number of <code>memref.alloc</code> ops, but no <code>memref.dealloc</code> ops. Buffer dellocation is delegated to the <code>-ownership-based-buffer-deallocation</code> pass. This pass supersedes the now deprecated <code>-buffer-deallocation</code> pass, which does not work well with One-Shot Bufferize.On a high level, buffers are “owned” by a basic block. Ownership materializes as an <code>i1</code> SSA value and can be thought of as “responsibility to deallocate”. It is conceptually similar to <code>std::unique_ptr</code> in C++.There are few additional preprocessing and postprocessing passes that should be run together with the ownership-based buffer deallocation pass. The recommended compilation pipeline is as follows:<pre tabindex=0><code>one-shot-bufferize | it's recommended to perform all bufferization here at latest, | <- any allocations inserted after this point have to be handled V manually expand-realloc V ownership-based-buffer-deallocation V canonicalize <- mostly for scf.if simplifications V buffer-deallocation-simplification V <- from this point onwards no tensor values are allowed lower-deallocations V CSE V canonicalize </code></pre>The entire deallocation pipeline (excluding <code>-one-shot-bufferize</code>) is exposed as <code>-buffer-deallocation-pipeline</code>.The ownership-based buffer deallocation pass processes operations implementing <code>FunctionOpInterface</code> one-by-one without analysing the call-graph. This means that there have to be <a href=#function-boundary-abi>some rules</a> on how MemRefs are handled when being passed from one function to another. The rest of the pass revolves heavily around the <code>bufferization.dealloc</code> operation which is inserted at the end of each basic block with appropriate operands and should be optimized using the Buffer Deallocation Simplification pass (<code>--buffer-deallocation-simplification</code>) and the regular canonicalizer (<code>--canonicalize</code>). Lowering the result of the <code>-ownership-based-buffer-deallocation</code> pass directly using <code>--convert-bufferization-to-memref</code> without beforehand optimization is not recommended as it will lead to very inefficient code (the runtime-cost of <code>bufferization.dealloc</code> is <code>O(|memrefs|^2+|memref|*|retained|)</code>).<h2 id=function-boundary-abi>Function boundary ABI <a class=headline-hash href=#function-boundary-abi>¶</a></h2>The Buffer Deallocation pass operates on the level of operations implementing the <code>FunctionOpInterface</code>. Such operations can take MemRefs as arguments, but also return them. To ensure compatibility among all functions (including external ones), some rules have to be enforced:<ul><li>When a MemRef is passed as a function argument, ownership is never acquired. It is always the caller’s responsibility to deallocate such MemRefs.</li><li>Returning a MemRef from a function always passes ownership to the caller, i.e., it is also the caller’s responsibility to deallocate memrefs returned from a called function.</li><li>A function must not return a MemRef with the same allocated base buffer as one of its arguments (in this case a copy has to be created). Note that in this context two subviews of the same buffer that don’t overlap are also considered to alias.</li></ul>For external functions (e.g., library functions written externally in C), the externally provided implementation has to adhere to these rules and they are just assumed by the buffer deallocation pass. Functions on which the deallocation pass is applied and for which the implementation is accessible are modified by the pass such that the ABI is respected (i.e., buffer copies are inserted when necessary).<h2 id=inserting-bufferizationdealloc-operations>Inserting <code>bufferization.dealloc</code> operations <a class=headline-hash href=#inserting-bufferizationdealloc-operations>¶</a></h2><code>bufferization.dealloc</code> and ownership indicators are the main abstractions in the ownership-based buffer deallocation pass. <code>bufferization.dealloc</code> deallocates all given buffers if the respective ownership indicator is set and there is no aliasing buffer in the retain list.<img src=/includes/img/bufferization_dealloc_op.svg alt=branch_example_pre_move><code>bufferization.dealloc</code> operations are unconditionally inserted at the end of each basic block (just before the terminator). The majority of the pass is about finding the correct operands for this operation. There are three variadic operand lists to be populated, the first contains all MemRef values that may need to be deallocated, the second list contains their associated ownership values (of <code>i1</code> type), and the third list contains MemRef values that are still needed at a later point and should thus not be deallocated (e.g., yielded or returned buffers).<code>bufferization.dealloc</code> allows us to deal with any kind of aliasing behavior: it lowers to runtime aliasing checks when not enough information can be collected statically. When enough aliasing information is statically available, operands or the entire op may fold away.OwnershipsTo do so, we use a concept of ownership indicators of memrefs which materialize as an <code>i1</code> value for any SSA value of <code>memref</code> type, indicating whether the basic block in which it was materialized has ownership of this MemRef. Ideally, this is a constant <code>true</code> or <code>false</code>, but might also be a non-constant SSA value. To keep track of those ownership values without immediately materializing them (which might require insertion of <code>bufferization.clone</code> operations or operations checking for aliasing at runtime at positions where we don’t actually need a materialized value), we use the <code>Ownership</code> class. This class represents the ownership in three states forming a lattice on a partial order:<pre tabindex=0><code>forall X in SSA values. uninitialized < unique(X) < unknown forall X, Y in SSA values. unique(X) == unique(Y) iff X and Y always evaluate to the same value unique(X) != unique(Y) otherwise </code></pre>Intuitively, the states have the following meaning:<ul><li>Uninitialized: the ownership is not initialized yet, this is the default state; once an operation is finished processing the ownership of all operation results with MemRef type should not be uninitialized anymore.</li><li>Unique: there is a specific SSA value that can be queried to check ownership without materializing any additional IR</li><li>Unknown: no specific SSA value is available without materializing additional IR, typically this is because two ownerships in ‘Unique’ state would have to be merged manually (e.g., the result of an <code>arith.select</code> either has the ownership of the then or else case depending on the condition value, inserting another <code>arith.select</code> for the ownership values can perform the merge and provide a ‘Unique’ ownership for the result), however, in the general case this ‘Unknown’ state has to be assigned.</li></ul>Implied by the above partial order, the pass combines two ownerships in the following way:<table><thead><tr><th style=text-align:left>Ownership 1</th><th style=text-align:left>Ownership 2</th><th style=text-align:left>Combined Ownership</th></tr></thead><tbody><tr><td style=text-align:left>uninitialized</td><td style=text-align:left>uninitialized</td><td style=text-align:left>uninitialized</td></tr><tr><td style=text-align:left>unique(X)</td><td style=text-align:left>uninitialized</td><td style=text-align:left>unique(X)</td></tr><tr><td style=text-align:left>unique(X)</td><td style=text-align:left>unique(X)</td><td style=text-align:left>unique(X)</td></tr><tr><td style=text-align:left>unique(X)</td><td style=text-align:left>unique(Y)</td><td style=text-align:left>unknown</td></tr><tr><td style=text-align:left>unknown</td><td style=text-align:left>unique</td><td style=text-align:left>unknown</td></tr><tr><td style=text-align:left>unknown</td><td style=text-align:left>uninitialized</td><td style=text-align:left>unknown</td></tr><tr><td style=text-align:left><td colspan=3>+ symmetric cases</td><td></td><td></td></tr></tbody></table>Collecting the list of MemRefs that potentially need to be deallocatedFor a given block, the list of MemRefs that potentially need to be deallocated at the end of that block is computed by keeping track of all values for which the block potentially takes over ownership. This includes MemRefs provided as basic block arguments, interface handlers for operations like <code>memref.alloc</code> and <code>func.call</code>, but also liveness information in regions with multiple basic blocks. More concretely, it is computed by taking the MemRefs in the ‘in’ set of the liveness analysis of the current basic block B, appended by the MemRef block arguments and by the set of MemRefs allocated in B itself (determined by the interface handlers), then subtracted (also determined by the interface handlers) by the set of MemRefs deallocated in B.Note that we don’t have to take the intersection of the liveness ‘in’ set with the ‘out’ set of the predecessor block because a value that is in the ‘in’ set must be defined in an ancestor block that dominates all direct predecessors and thus the ‘in’ set of this block is a subset of the ‘out’ sets of each predecessor.<pre tabindex=0><code>memrefs = filter((liveIn(block) U allocated(block) U arguments(block)) \ deallocated(block), isMemRef) </code></pre>The list of conditions for the second variadic operands list of <code>bufferization.dealloc</code> is computed by querying the stored ownership value for each of the MemRefs collected as described above. The ownership state is updated by the interface handlers while processing the basic block.Collecting the list of MemRefs to retainGiven a basic block B, the list of MemRefs that have to be retained can be different for each successor block S. For the two basic blocks B and S and the values passed via block arguments to the destination block S, we compute the list of MemRefs that have to be retained in B by taking the MemRefs in the successor operand list of the terminator and the MemRefs in the ‘out’ set of the liveness analysis for B intersected with the ‘in’ set of the destination block S.This list of retained values makes sure that we cannot run into use-after-free situations even if no aliasing information is present at compile-time.<pre tabindex=0><code>toRetain = filter(successorOperands + (liveOut(fromBlock) insersect liveIn(toBlock)), isMemRef) </code></pre><h2 id=supported-interfaces>Supported interfaces <a class=headline-hash href=#supported-interfaces>¶</a></h2>The pass uses liveness analysis and a few interfaces:<ul><li><code>FunctionOpInterface</code></li><li><code>CallOpInterface</code></li><li><code>MemoryEffectOpInterface</code></li><li><code>RegionBranchOpInterface</code></li><li><code>RegionBranchTerminatorOpInterface</code></li></ul>Due to insufficient information provided by the interface, it also special-cases on the <code>cf.cond_br</code> operation and makes some assumptions about operations implementing the <code>RegionBranchOpInterface</code> at the moment, but improving the interfaces would allow us to remove those dependencies in the future.<h2 id=limitations>Limitations <a class=headline-hash href=#limitations>¶</a></h2>The Buffer Deallocation pass has some requirements and limitations on the input IR. These are checked in the beginning of the pass and errors are emitted accordingly:<ul><li>The set of interfaces the pass operates on must be implemented (correctly). E.g., if there is an operation present with a nested region, but does not implement the <code>RegionBranchOpInterface</code>, an error is emitted because the pass cannot know the semantics of the nested region (and does not make any default assumptions on it).</li><li>No explicit control-flow loops are present. Currently, only loops using structural-control-flow are supported. However, this limitation could be lifted in the future.</li><li>Deallocation operations should not be present already. The pass should handle them correctly already (at least in most cases), but it’s not supported yet due to insufficient testing.</li><li>Terminators must implement either <code>RegionBranchTerminatorOpInterface</code> or <code>BranchOpInterface</code>, but not both. Terminators with more than one successor are not supported (except <code>cf.cond_br</code>). This is not a fundamental limitation, but there is no use-case justifying the more complex implementation at the moment.</li></ul><h2 id=example>Example <a class=headline-hash href=#example>¶</a></h2>The following example contains a few interesting cases:<ul><li>Basic block arguments are modified to also pass along the ownership indicator, but not for entry blocks, where the function boundary ABI is applied instead.</li><li>The result of <code>arith.select</code> initially has ‘Unknown’ assigned as ownership, but once the <code>bufferization.dealloc</code> operation is inserted it is put in the ‘retained’ list (since it has uses in a later basic block) and thus the ‘Unknown’ ownership can be replaced with a ‘Unique’ ownership using the corresponding result of the dealloc operation.</li><li>The <code>cf.cond_br</code> operation has more than one successor and thus has to insert two <code>bufferization.dealloc</code> operations (one for each successor). While they have the same list of MemRefs to deallocate (because they perform the deallocations for the same block), it must be taken into account that some MemRefs remain live for one branch but not the other (thus set intersection is performed on the live-out of the current block and the live-in of the target block). Also, <code>cf.cond_br</code> supports separate forwarding operands for each successor. To make sure that no MemRef is deallocated twice (because there are two <code>bufferization.dealloc</code> operations with the same MemRefs to deallocate), the condition operands are adjusted to take the branch condition into account. While a generic lowering for such terminator operations could be implemented, a specialized implementation can take all the semantics of this particular operation into account and thus generate a more efficient lowering.</li></ul><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>func.func @example(%memref: memref<?xi8>, %select_cond: i1, %br_cond: i1) { %alloc = memref.alloc() : memref<?xi8> %alloca = memref.alloca() : memref<?xi8> %select = arith.select %select_cond, %alloc, %alloca : memref<?xi8> cf.cond_br %br_cond, ^bb1(%alloc : memref<?xi8>), ^bb1(%memref : memref<?xi8>) ^bb1(%bbarg: memref<?xi8>): test.copy(%bbarg, %select) : (memref<?xi8>, memref<?xi8>) return } </code></pre></div>After running <code>--ownership-based-buffer-deallocation</code>, it looks as follows:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Function boundary ABI: ownership of `%memref` will never be acquired. func.func @example(%memref: memref<?xi8>, %select_cond: i1, %br_cond: i1) { %false = arith.constant false %true = arith.constant true // The ownership of a MemRef defined by the `memref.alloc` operation is always // assigned to be 'true'. %alloc = memref.alloc() : memref<?xi8> // The ownership of a MemRef defined by the `memref.alloca` operation is // always assigned to be 'false'. %alloca = memref.alloca() : memref<?xi8> // The ownership of %select will be the join of the ownership of %alloc and // the ownership of %alloca, i.e., of %true and %false. Because the pass does // not know about the semantics of the `arith.select` operation (unless a // custom handler is implemented), the ownership join will be 'Unknown'. If // the materialized ownership indicator of %select is needed, either a clone // has to be created for which %true is assigned as ownership or the result // of a `bufferization.dealloc` where %select is in the retain list has to be // used. %select = arith.select %select_cond, %alloc, %alloca : memref<?xi8> // We use `memref.extract_strided_metadata` to get the base memref since it is // not allowed to pass arbitrary memrefs to `memref.dealloc`. This property is // already enforced for `bufferization.dealloc` %base_buffer_memref, ... = memref.extract_strided_metadata %memref : memref<?xi8> -> memref<i8>, index, index, index %base_buffer_alloc, ... = memref.extract_strided_metadata %alloc : memref<?xi8> -> memref<i8>, index, index, index %base_buffer_alloca, ... = memref.extract_strided_metadata %alloca : memref<?xi8> -> memref<i8>, index, index, index // The deallocation conditions need to be adjusted to incorporate the branch // condition. In this example, this requires only a single negation, but might // also require multiple arith.andi operations. %not_br_cond = arith.xori %true, %br_cond : i1 // There are two dealloc operations inserted in this basic block, one per // successor. Both have the same list of MemRefs to deallocate and the // conditions only differ by the branch condition conjunct. // Note, however, that the retained list differs. Here, both contain the // %select value because it is used in both successors (since it's the same // block), but the value passed via block argument differs (%memref vs. // %alloc). %10:2 = bufferization.dealloc (%base_buffer_memref, %base_buffer_alloc, %base_buffer_alloca : memref<i8>, memref<i8>, memref<i8>) if (%false, %br_cond, %false) retain (%alloc, %select : memref<?xi8>, memref<?xi8>) %11:2 = bufferization.dealloc (%base_buffer_memref, %base_buffer_alloc, %base_buffer_alloca : memref<i8>, memref<i8>, memref<i8>) if (%false, %not_br_cond, %false) retain (%memref, %select : memref<?xi8>, memref<?xi8>) // Because %select is used in ^bb1 without passing it via block argument, we // need to update it's ownership value here by merging the ownership values // returned by the dealloc operations %new_ownership = arith.select %br_cond, %10#1, %11#1 : i1 // The terminator is modified to pass along the ownership indicator values // with each MemRef value. cf.cond_br %br_cond, ^bb1(%alloc, %10#0 : memref<?xi8>, i1), ^bb1(%memref, %11#0 : memref<?xi8>, i1) // All non-entry basic blocks are modified to have an additional i1 argument for // each MemRef value in the argument list. ^bb1(%13: memref<?xi8>, %14: i1): // 2 preds: ^bb0, ^bb0 test.copy(%13, %select) : (memref<?xi8>, memref<?xi8>) %base_buffer_13, ... = memref.extract_strided_metadata %13 : memref<?xi8> -> memref<i8>, index, index, index %base_buffer_select, ... = memref.extract_strided_metadata %select : memref<?xi8> -> memref<i8>, index, index, index // Here, we don't have a retained list, because the block has no successors // and the return has no operands. bufferization.dealloc (%base_buffer_13, %base_buffer_select : memref<i8>, memref<i8>) if (%14, %new_ownership) return } </code></pre></div><h2 id=buffer-deallocation-simplification-pass>Buffer Deallocation Simplification Pass <a class=headline-hash href=#buffer-deallocation-simplification-pass>¶</a></h2>The <a href=#bufferizationdealloc-bufferizationdeallocop>semantics of the <code>bufferization.dealloc</code> operation</a> provide a lot of opportunities for optimizations which can be conveniently split into patterns using the greedy pattern rewriter. Some of those patterns need access to additional analyses such as an analysis that can determine whether two MemRef values must, may, or never originate from the same buffer allocation. These patterns are collected in the Buffer Deallocation Simplification pass, while patterns that don’t need additional analyses are registered as part of the regular canonicalizer pass. This pass is best run after <code>--ownership-based-buffer-deallocation</code> followed by <code>--canonicalize</code>.The pass applies patterns for the following simplifications:<ul><li>Remove MemRefs from retain list when guaranteed to not alias with any value in the ‘memref’ operand list. This avoids an additional aliasing check with the removed value.</li><li>Split off values in the ‘memref’ list to new <code>bufferization.dealloc</code> operations only containing this value in the ‘memref’ list when it is guaranteed to not alias with any other value in the ‘memref’ list. This avoids at least one aliasing check at runtime and enables using a more efficient lowering for this new <code>bufferization.dealloc</code> operation.</li><li>Remove values from the ‘memref’ operand list when it is guaranteed to alias with at least one value in the ‘retained’ list and may not alias any other value in the ‘retain’ list.</li></ul><h2 id=lower-deallocations-pass>Lower Deallocations Pass <a class=headline-hash href=#lower-deallocations-pass>¶</a></h2>The <code>-lower-deallocations</code> pass transforms all <code>bufferization.dealloc</code> operations to <code>memref.dealloc</code> operations and may also insert operations from the <code>scf</code>, <code>func</code>, and <code>arith</code> dialects to make deallocations conditional and check whether two MemRef values come from the same allocation at runtime (when the <code>buffer-deallocation-simplification</code> pass wasn’t able to determine it statically).The same lowering of the <code>bufferization.dealloc</code> operation is also part of the <code>-convert-bufferization-to-memref</code> conversion pass which also lowers all the other operations of the bufferization dialect.We distinguish multiple cases in this lowering pass to provide an overall more efficient lowering. In the general case, a library function is created to avoid quadratic code size explosion (relative to the number of operands of the dealloc operation). The specialized lowerings aim to avoid this library function because it requires allocating auxiliary MemRefs of index values.<h3 id=generic-lowering>Generic Lowering <a class=headline-hash href=#generic-lowering>¶</a></h3>A library function is generated to avoid code-size blow-up. On a high level, the base-memref of all operands is extracted as an index value and stored into specifically allocated MemRefs and passed to the library function which then determines whether they come from the same original allocation. This information is needed to avoid double-free situations and to correctly retain the MemRef values in the <code>retained</code> list.Dealloc Operation LoweringThis lowering supports all features the dealloc operation has to offer. It computes the base pointer of each memref (as an index), stores it in a new memref helper structure and passes it to the helper function generated in <code>buildDeallocationLibraryFunction</code>. The results are stored in two lists (represented as MemRefs) of booleans passed as arguments. The first list stores whether the corresponding condition should be deallocated, the second list stores the ownership of the retained values which can be used to replace the result values of the <code>bufferization.dealloc</code> operation.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>%0:2 = bufferization.dealloc (%m0, %m1 : memref<2xf32>, memref<5xf32>) if (%cond0, %cond1) retain (%r0, %r1 : memref<1xf32>, memref<2xf32>) </code></pre></div>lowers to (simplified):<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>%c0 = arith.constant 0 : index %c1 = arith.constant 1 : index %dealloc_base_pointer_list = memref.alloc() : memref<2xindex> %cond_list = memref.alloc() : memref<2xi1> %retain_base_pointer_list = memref.alloc() : memref<2xindex> %m0_base_pointer = memref.extract_aligned_pointer_as_index %m0 memref.store %m0_base_pointer, %dealloc_base_pointer_list[%c0] %m1_base_pointer = memref.extract_aligned_pointer_as_index %m1 memref.store %m1_base_pointer, %dealloc_base_pointer_list[%c1] memref.store %cond0, %cond_list[%c0] memref.store %cond1, %cond_list[%c1] %r0_base_pointer = memref.extract_aligned_pointer_as_index %r0 memref.store %r0_base_pointer, %retain_base_pointer_list[%c0] %r1_base_pointer = memref.extract_aligned_pointer_as_index %r1 memref.store %r1_base_pointer, %retain_base_pointer_list[%c1] %dyn_dealloc_base_pointer_list = memref.cast %dealloc_base_pointer_list : memref<2xindex> to memref<?xindex> %dyn_cond_list = memref.cast %cond_list : memref<2xi1> to memref<?xi1> %dyn_retain_base_pointer_list = memref.cast %retain_base_pointer_list : memref<2xindex> to memref<?xindex> %dealloc_cond_out = memref.alloc() : memref<2xi1> %ownership_out = memref.alloc() : memref<2xi1> %dyn_dealloc_cond_out = memref.cast %dealloc_cond_out : memref<2xi1> to memref<?xi1> %dyn_ownership_out = memref.cast %ownership_out : memref<2xi1> to memref<?xi1> call @dealloc_helper(%dyn_dealloc_base_pointer_list, %dyn_retain_base_pointer_list, %dyn_cond_list, %dyn_dealloc_cond_out, %dyn_ownership_out) : (...) %m0_dealloc_cond = memref.load %dyn_dealloc_cond_out[%c0] : memref<2xi1> scf.if %m0_dealloc_cond { memref.dealloc %m0 : memref<2xf32> } %m1_dealloc_cond = memref.load %dyn_dealloc_cond_out[%c1] : memref<2xi1> scf.if %m1_dealloc_cond { memref.dealloc %m1 : memref<5xf32> } %r0_ownership = memref.load %dyn_ownership_out[%c0] : memref<2xi1> %r1_ownership = memref.load %dyn_ownership_out[%c1] : memref<2xi1> memref.dealloc %dealloc_base_pointer_list : memref<2xindex> memref.dealloc %retain_base_pointer_list : memref<2xindex> memref.dealloc %cond_list : memref<2xi1> memref.dealloc %dealloc_cond_out : memref<2xi1> memref.dealloc %ownership_out : memref<2xi1> // replace %0#0 with %r0_ownership // replace %0#1 with %r1_ownership </code></pre></div>Library functionA library function is built per compilation unit that can be called at bufferization dealloc sites to determine whether two MemRefs come from the same allocation and their new ownerships.The generated function takes two MemRefs of indices and three MemRefs of booleans as arguments:<ul><li>The first argument A should contain the result of the extract_aligned_pointer_as_index operation applied to the MemRefs to be deallocated</li><li>The second argument B should contain the result of the extract_aligned_pointer_as_index operation applied to the MemRefs to be retained</li><li>The third argument C should contain the conditions as passed directly to the deallocation operation.</li><li>The fourth argument D is used to pass results to the caller. Those represent the condition under which the MemRef at the corresponding position in A should be deallocated.</li><li>The fifth argument E is used to pass results to the caller. It provides the ownership value corresponding the the MemRef at the same position in B</li></ul>This helper function is supposed to be called once for each <code>bufferization.dealloc</code> operation to determine the deallocation need and new ownership indicator for the retained values, but does not perform the deallocation itself.Generated code:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>func.func @dealloc_helper( %dyn_dealloc_base_pointer_list: memref<?xindex>, %dyn_retain_base_pointer_list: memref<?xindex>, %dyn_cond_list: memref<?xi1>, %dyn_dealloc_cond_out: memref<?xi1>, %dyn_ownership_out: memref<?xi1>) { %c0 = arith.constant 0 : index %c1 = arith.constant 1 : index %true = arith.constant true %false = arith.constant false %num_dealloc_memrefs = memref.dim %dyn_dealloc_base_pointer_list, %c0 %num_retain_memrefs = memref.dim %dyn_retain_base_pointer_list, %c0 // Zero initialize result buffer. scf.for %i = %c0 to %num_retain_memrefs step %c1 { memref.store %false, %dyn_ownership_out[%i] : memref<?xi1> } scf.for %i = %c0 to %num_dealloc_memrefs step %c1 { %dealloc_bp = memref.load %dyn_dealloc_base_pointer_list[%i] %cond = memref.load %dyn_cond_list[%i] // Check for aliasing with retained memrefs. %does_not_alias_retained = scf.for %j = %c0 to %num_retain_memrefs step %c1 iter_args(%does_not_alias_aggregated = %true) -> (i1) { %retain_bp = memref.load %dyn_retain_base_pointer_list[%j] %does_alias = arith.cmpi eq, %retain_bp, %dealloc_bp : index scf.if %does_alias { %curr_ownership = memref.load %dyn_ownership_out[%j] %updated_ownership = arith.ori %curr_ownership, %cond : i1 memref.store %updated_ownership, %dyn_ownership_out[%j] } %does_not_alias = arith.cmpi ne, %retain_bp, %dealloc_bp : index %updated_aggregate = arith.andi %does_not_alias_aggregated, %does_not_alias : i1 scf.yield %updated_aggregate : i1 } // Check for aliasing with dealloc memrefs in the list before the // current one, i.e., // `fix i, forall j < i: check_aliasing(%dyn_dealloc_base_pointer[j], // %dyn_dealloc_base_pointer[i])` %does_not_alias_any = scf.for %j = %c0 to %i step %c1 iter_args(%does_not_alias_agg = %does_not_alias_retained) -> (i1) { %prev_dealloc_bp = memref.load %dyn_dealloc_base_pointer_list[%j] %does_not_alias = arith.cmpi ne, %prev_dealloc_bp, %dealloc_bp %updated_alias_agg = arith.andi %does_not_alias_agg, %does_not_alias scf.yield %updated_alias_agg : i1 } %dealloc_cond = arith.andi %does_not_alias_any, %cond : i1 memref.store %dealloc_cond, %dyn_dealloc_cond_out[%i] : memref<?xi1> } return } </code></pre></div><h3 id=specialized-lowerings>Specialized Lowerings <a class=headline-hash href=#specialized-lowerings>¶</a></h3>Currently, there are two special lowerings for common cases to avoid the library function and thus unnecessary memory load and store operations and function calls:One memref, no retainedLower a simple case without any retained values and a single MemRef. Ideally, static analysis can provide enough information such that the <code>buffer-deallocation-simplification</code> pass is able to split the dealloc operations up into this simple case as much as possible before running this pass.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>bufferization.dealloc (%arg0 : memref<2xf32>) if (%arg1) </code></pre></div>is lowered to<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>scf.if %arg1 { memref.dealloc %arg0 : memref<2xf32> } </code></pre></div>In most cases, the branch condition is either constant ’true’ or ‘false’ and can thus be optimized away entirely by the canonicalizer pass.One memref, arbitrarily many retainedA special case lowering for the deallocation operation with exactly one MemRef, but an arbitrary number of retained values. The size of the code produced by this lowering is linear to the number of retained values.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>%0:2 = bufferization.dealloc (%m : memref<2xf32>) if (%cond) retain (%r0, %r1 : memref<1xf32>, memref<2xf32>) return %0#0, %0#1 : i1, i1 </code></pre></div>is lowered to<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>%m_base_pointer = memref.extract_aligned_pointer_as_index %m %r0_base_pointer = memref.extract_aligned_pointer_as_index %r0 %r0_does_not_alias = arith.cmpi ne, %m_base_pointer, %r0_base_pointer %r1_base_pointer = memref.extract_aligned_pointer_as_index %r1 %r1_does_not_alias = arith.cmpi ne, %m_base_pointer, %r1_base_pointer %not_retained = arith.andi %r0_does_not_alias, %r1_does_not_alias : i1 %should_dealloc = arith.andi %not_retained, %cond : i1 scf.if %should_dealloc { memref.dealloc %m : memref<2xf32> } %true = arith.constant true %r0_does_alias = arith.xori %r0_does_not_alias, %true : i1 %r0_ownership = arith.andi %r0_does_alias, %cond : i1 %r1_does_alias = arith.xori %r1_does_not_alias, %true : i1 %r1_ownership = arith.andi %r1_does_alias, %cond : i1 return %r0_ownership, %r1_ownership : i1, i1 </code></pre></div><div class=edit-meta> </div><nav class=pagination><a class="nav nav-prev" href=https://mlir.llvm.org/docs/Canonicalization/ title="Operation Canonicalization"> Prev - Operation Canonicalization</a> <a class="nav nav-next" href=https://mlir.llvm.org/docs/PassManagement/ title="Pass Infrastructure">Next - Pass Infrastructure </a></nav><footer>Powered by <a href=https://gohugo.io>Hugo</a>. Theme by <a href=https://themes.gohugo.io/hugo-theme-techdoc/>TechDoc</a>. Designed by <a href=https://github.com/thingsym/hugo-theme-techdoc>Thingsym</a>.</footer></main><div class=sidebar><nav class=slide-menu><ul><li><a href=https://mlir.llvm.org/>Home</a></li><li><a href=https://mlir.llvm.org/users/>Users of MLIR</a></li><li><a href=https://mlir.llvm.org/pubs/>MLIR Related Publications</a></li><li><a href=https://mlir.llvm.org/talks/>Talks</a></li><li><a href=https://mlir.llvm.org/deprecation/>Deprecations & Current Refactoring</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/getting_started/>Getting Started+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/getting_started/ReportingIssues/>Reporting Issues</a></li><li><a href=https://mlir.llvm.org/getting_started/Debugging/>Debugging Tips</a></li><li><a href=https://mlir.llvm.org/getting_started/Faq/>FAQ</a></li><li><a href=https://mlir.llvm.org/getting_started/Contributing/>How to Contribute</a></li><li><a href=https://mlir.llvm.org/getting_started/DeveloperGuide/>Developer Guide</a></li><li><a href=https://mlir.llvm.org/getting_started/openprojects/>Open Projects</a></li><li><a href=https://mlir.llvm.org/getting_started/Glossary/>Glossary</a></li><li><a href=https://mlir.llvm.org/getting_started/TestingGuide/>Testing Guide</a></li></ul></li><li class="parent has-sub-menu"><a href=https://mlir.llvm.org/docs/>Code Documentation-</a><ul class=sub-menu><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Bindings/>Bindings+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Bindings/Python/>MLIR Python Bindings</a></li></ul></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Tools/>Tools+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Tools/MLIRLSP/>MLIR : Language Server Protocol</a></li><li><a href=https://mlir.llvm.org/docs/Tools/mlir-reduce/>MLIR Reduce</a></li><li><a href=https://mlir.llvm.org/docs/Tools/mlir-rewrite/>mlir-rewrite</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/QuantPasses/></a></li><li><a href=https://mlir.llvm.org/docs/ActionTracing/>Action: Tracing and Debugging MLIR-based Compilers</a></li><li><a href=https://mlir.llvm.org/docs/BufferDeallocationInternals/>Buffer Deallocation - Internals</a></li><li><a href=https://mlir.llvm.org/docs/Bufferization/>Bufferization</a></li><li><a href=https://mlir.llvm.org/docs/DataLayout/>Data Layout Modeling</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/DefiningDialects/>Defining Dialects+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/DefiningDialects/Constraints/>Constraints</a></li><li><a href=https://mlir.llvm.org/docs/DefiningDialects/AttributesAndTypes/>Defining Dialect Attributes and Types</a></li><li><a href=https://mlir.llvm.org/docs/DefiningDialects/Operations/>Operation Definition Specification (ODS)</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Diagnostics/>Diagnostic Infrastructure</a></li><li><a href=https://mlir.llvm.org/docs/DialectConversion/>Dialect Conversion</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Dialects/>Dialects+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Dialects/DLTITransformOps/></a></li><li><a href=https://mlir.llvm.org/docs/Dialects/OpenACCDialect/>'acc' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Affine/>'affine' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/AMDGPU/>'amdgpu' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/AMX/>'amx' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ArithOps/>'arith' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ArmNeon/>'arm_neon' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ArmSVE/>'arm_sve' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ArmSME/>'ArmSME' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/AsyncDialect/>'async' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/BufferizationOps/>'bufferization' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ControlFlowDialect/>'cf' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ComplexOps/>'complex' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/DLTIDialect/>'dlti' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/EmitC/>'emitc' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Func/>'func' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/GPU/>'gpu' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/IndexOps/>'index' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/IRDL/>'irdl' Dialect</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Dialects/Linalg/>'linalg' Dialect+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Dialects/Linalg/OpDSL/>Linalg OpDSL</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Dialects/LLVM/>'llvm' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MathOps/>'math' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MemRef/>'memref' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Mesh/>'mesh' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MLProgramOps/>'ml_program' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MPI/>'mpi' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/NVGPU/>'nvgpu' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/NVVMDialect/>'nvvm' Dialect</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Dialects/OpenMPDialect/>'omp' Dialect+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Dialects/OpenMPDialect/ODS/>ODS Documentation</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Dialects/PDLInterpOps/>'pdl_interp' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/PDLOps/>'pdl' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/PolynomialDialect/>'polynomial' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/PtrOps/>'ptr' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/QuantDialect/>'quant' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ROCDLDialect/>'rocdl' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/SCFDialect/>'scf' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ShapeDialect/>'shape' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/SparseTensorOps/>'sparse_tensor' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/TensorOps/>'tensor' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/UBOps/>'ub' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/VCIXDialect/>'vcix' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Vector/>'vector' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/X86Vector/>'x86vector' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/XeGPU/>'xegpu' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Builtin/>Builtin Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MatchOpInterfaces/>OpInterface definitions</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/SPIR-V/>SPIR-V Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/TOSA/>Tensor Operator Set Architecture (TOSA) Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Transform/>Transform Dialect</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Interfaces/>Interfaces</a></li><li><a href=https://mlir.llvm.org/docs/TargetLLVMIR/>LLVM IR Target</a></li><li><a href=https://mlir.llvm.org/docs/BytecodeFormat/>MLIR Bytecode Format</a></li><li><a href=https://mlir.llvm.org/docs/CAPI/>MLIR C API</a></li><li><a href=https://mlir.llvm.org/docs/LangRef/>MLIR Language Reference</a></li><li><a href=https://mlir.llvm.org/docs/ReleaseNotes/>MLIR Release Notes</a></li><li><a href=https://mlir.llvm.org/docs/Canonicalization/>Operation Canonicalization</a></li><li class=active><a href=https://mlir.llvm.org/docs/OwnershipBasedBufferDeallocation/>Ownership-based Buffer Deallocation</a></li><li><a href=https://mlir.llvm.org/docs/PassManagement/>Pass Infrastructure</a></li><li><a href=https://mlir.llvm.org/docs/Passes/>Passes</a></li><li><a href=https://mlir.llvm.org/docs/PatternRewriter/>Pattern Rewriting : Generic DAG-to-DAG Rewriting</a></li><li><a href=https://mlir.llvm.org/docs/PDLL/>PDLL - PDL Language</a></li><li><a href=https://mlir.llvm.org/docs/Quantization/>Quantization</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Rationale/>Rationale+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Rationale/RationaleGenericDAGRewriter/>Generic DAG Rewriter Infrastructure Rationale</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/RationaleLinalgDialect/>Linalg Dialect Rationale: The Case For Compiler-Friendly Custom Operations</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/Rationale/>MLIR Rationale</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/MLIRForGraphAlgorithms/>MLIR: Incremental Application to Graph Algorithms in ML Frameworks</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/RationaleSimplifiedPolyhedralForm/>MLIR: The case for a simplified polyhedral form</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/SideEffectsAndSpeculation/>Side Effects & Speculation</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/UsageOfConst/>Usage of 'const' in MLIR, for core IR types</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/ShapeInference/>Shape Inference</a></li><li><a href=https://mlir.llvm.org/docs/SPIRVToLLVMDialectConversion/>SPIR-V Dialect to LLVM Dialect conversion manual</a></li><li><a href=https://mlir.llvm.org/docs/SymbolsAndSymbolTables/>Symbols and Symbol Tables</a></li><li><a href=https://mlir.llvm.org/docs/DeclarativeRewrites/>Table-driven Declarative Rewrite Rule (DRR)</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Traits/>Traits+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Traits/Broadcastable/>The `Broadcastable` Trait</a></li></ul></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Tutorials/>Tutorials+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Tutorials/CreatingADialect/>Creating a Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/QuickstartRewrites/>Quickstart tutorial to adding MLIR graph rewrite</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Tutorials/Toy/>Toy Tutorial+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-1/>Chapter 1: Toy Language and AST</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-2/>Chapter 2: Emitting Basic MLIR</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-3/>Chapter 3: High-level Language-Specific Analysis and Transformation</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-4/>Chapter 4: Enabling Generic Transformation with Interfaces</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-5/>Chapter 5: Partial Lowering to Lower-Level Dialects for Optimization</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-6/>Chapter 6: Lowering to LLVM and CodeGeneration</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-7/>Chapter 7: Adding a Composite Type to Toy</a></li></ul></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Tutorials/transform/>Transform Dialect Tutorial+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch0/>Chapter 0: A Primer on “Structured” Linalg Operations</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch1/>Chapter 1: Combining Existing Transformations</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch2/>Chapter 2: Adding a Simple New Transformation Operation</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch3/>Chapter 3: More than Simple Transform Operations</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch4/>Chapter 4: Matching Payload with Transform Operations</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/ChH/>Chapter H: Reproducing Halide Schedule</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Tutorials/UnderstandingTheIRStructure/>Understanding the IR Structure</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/MlirOpt/>Using `mlir-opt`</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/DataFlowAnalysis/>Writing DataFlow Analyses in MLIR</a></li></ul></li></ul></li></ul></nav><div class=sidebar-footer></div></div></div><a href=# id=backtothetop-fixed class=backtothetop data-backtothetop-duration=600 data-backtothetop-easing=easeOutQuart data-backtothetop-fixed-fadein=1000 data-backtothetop-fixed-fadeout=1000 data-backtothetop-fixed-bottom=10 data-backtothetop-fixed-right=20> </a></div></body></html>