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>Chapter 5: Partial Lowering to Lower-Level Dialects for Optimization - 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/Tutorials/Toy/Ch-5/><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>Chapter 5: Partial Lowering to Lower-Level Dialects for Optimization</h1><nav id=TableOfContents><ul><li><a href=#conversion-target>Conversion Target</a></li><li><a href=#conversion-patterns>Conversion Patterns</a></li><li><a href=#partial-lowering>Partial Lowering</a><ul><li><a href=#design-considerations-with-partial-lowering>Design Considerations With Partial Lowering</a></li></ul></li><li><a href=#complete-toy-example>Complete Toy Example</a></li><li><a href=#taking-advantage-of-affine-optimization>Taking Advantage of Affine Optimization</a></li></ul></nav>At this point, we are eager to generate actual code and see our Toy language take life. We will use LLVM to generate code, but just showing the LLVM builder interface here wouldn’t be very exciting. Instead, we will show how to perform progressive lowering through a mix of dialects coexisting in the same function.To make it more interesting, in this chapter we will consider that we want to reuse existing optimizations implemented in a dialect optimizing affine transformations: <code>Affine</code>. This dialect is tailored to the computation-heavy part of the program and is limited: it doesn’t support representing our <code>toy.print</code> builtin, for instance, neither should it! Instead, we can target <code>Affine</code> for the computation heavy part of Toy, and in the <a href=/docs/Tutorials/Toy/Ch-6/>next chapter</a> directly target the <code>LLVM IR</code> dialect for lowering <code>print</code>. As part of this lowering, we will be lowering from the <a href=/docs/Dialects/Builtin/#rankedtensortype>TensorType</a> that <code>Toy</code> operates on to the <a href=/docs/Dialects/Builtin/#memreftype>MemRefType</a> that is indexed via an affine loop-nest. Tensors represent an abstract value-typed sequence of data, meaning that they don’t live in any memory. MemRefs, on the other hand, represent lower level buffer access, as they are concrete references to a region of memory.<h1 id=dialect-conversions>Dialect Conversions</h1>MLIR has many different dialects, so it is important to have a unified framework for <a href=/getting_started/Glossary/#conversion>converting</a> between them. This is where the <code>DialectConversion</code> framework comes into play. This framework allows for transforming a set of illegal operations to a set of legal ones. To use this framework, we need to provide two things (and an optional third):<ul><li>A <a href=/docs/DialectConversion/#conversion-target>Conversion Target</a><ul><li>This is the formal specification of what operations or dialects are legal for the conversion. Operations that aren’t legal will require rewrite patterns to perform <a href=/getting_started/Glossary/#legalization>legalization</a>.</li></ul></li><li>A set of <a href=/docs/DialectConversion/#rewrite-pattern-specification>Rewrite Patterns</a><ul><li>This is the set of <a href=/docs/Tutorials/QuickstartRewrites/>patterns</a> used to convert illegal operations into a set of zero or more legal ones.</li></ul></li><li>Optionally, a <a href=/docs/DialectConversion/#type-conversion>Type Converter</a>.<ul><li>If provided, this is used to convert the types of block arguments. We won’t be needing this for our conversion.</li></ul></li></ul><h2 id=conversion-target>Conversion Target <a class=headline-hash href=#conversion-target>¶</a></h2>For our purposes, we want to convert the compute-intensive <code>Toy</code> operations into a combination of operations from the <code>Affine</code>, <code>Arith</code>, <code>Func</code>, and <code>MemRef</code> dialects for further optimization. To start off the lowering, we first define our conversion target:<div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++>void ToyToAffineLoweringPass::runOnOperation() { // The first thing to define is the conversion target. This will define the // final target for this lowering. mlir::ConversionTarget target(getContext()); // We define the specific operations, or dialects, that are legal targets for // this lowering. In our case, we are lowering to a combination of the // `Affine`, `Arith`, `Func`, and `MemRef` dialects. target.addLegalDialect<affine::AffineDialect, arith::ArithDialect, func::FuncDialect, memref::MemRefDialect>(); // We also define the Toy dialect as Illegal so that the conversion will fail // if any of these operations are *not* converted. Given that we actually want // a partial lowering, we explicitly mark the Toy operations that don't want // to lower, `toy.print`, as *legal*. `toy.print` will still need its operands // to be updated though (as we convert from TensorType to MemRefType), so we // only treat it as `legal` if its operands are legal. target.addIllegalDialect<ToyDialect>(); target.addDynamicallyLegalOp<toy::PrintOp>([](toy::PrintOp op) { return llvm::none_of(op->getOperandTypes(), [](Type type) { return type.isa<TensorType>(); }); }); ... } </code></pre></div>Above, we first set the toy dialect to illegal, and then the print operation as legal. We could have done this the other way around. Individual operations always take precedence over the (more generic) dialect definitions, so the order doesn’t matter. See <code>ConversionTarget::getOpInfo</code> for the details.<h2 id=conversion-patterns>Conversion Patterns <a class=headline-hash href=#conversion-patterns>¶</a></h2>After the conversion target has been defined, we can define how to convert the illegal operations into legal ones. Similarly to the canonicalization framework introduced in <a href=/docs/Tutorials/Toy/Ch-3/>chapter 3</a>, the <a href=/docs/DialectConversion/><code>DialectConversion</code> framework</a> also uses <a href=/docs/Tutorials/QuickstartRewrites/>RewritePatterns</a> to perform the conversion logic. These patterns may be the <code>RewritePatterns</code> seen before or a new type of pattern specific to the conversion framework <code>ConversionPattern</code>. <code>ConversionPatterns</code> are different from traditional <code>RewritePatterns</code> in that they accept an additional <code>operands</code> parameter containing operands that have been remapped/replaced. This is used when dealing with type conversions, as the pattern will want to operate on values of the new type but match against the old. For our lowering, this invariant will be useful as it translates from the <a href=/docs/Dialects/Builtin/#rankedtensortype>TensorType</a> currently being operated on to the <a href=/docs/Dialects/Builtin/#memreftype>MemRefType</a>. Let’s look at a snippet of lowering the <code>toy.transpose</code> operation:<div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++>/// Lower the `toy.transpose` operation to an affine loop nest. struct TransposeOpLowering : public mlir::ConversionPattern { TransposeOpLowering(mlir::MLIRContext *ctx) : mlir::ConversionPattern(TransposeOp::getOperationName(), 1, ctx) {} /// Match and rewrite the given `toy.transpose` operation, with the given /// operands that have been remapped from `tensor<...>` to `memref<...>`. llvm::LogicalResult matchAndRewrite(mlir::Operation *op, ArrayRef<mlir::Value> operands, mlir::ConversionPatternRewriter &rewriter) const final { auto loc = op->getLoc(); // Call to a helper function that will lower the current operation to a set // of affine loops. We provide a functor that operates on the remapped // operands, as well as the loop induction variables for the inner most // loop body. lowerOpToLoops( op, operands, rewriter, [loc](mlir::PatternRewriter &rewriter, ArrayRef<mlir::Value> memRefOperands, ArrayRef<mlir::Value> loopIvs) { // Generate an adaptor for the remapped operands of the TransposeOp. // This allows for using the nice named accessors that are generated // by the ODS. This adaptor is automatically provided by the ODS // framework. TransposeOpAdaptor transposeAdaptor(memRefOperands); mlir::Value input = transposeAdaptor.input(); // Transpose the elements by generating a load from the reverse // indices. SmallVector<mlir::Value, 2> reverseIvs(llvm::reverse(loopIvs)); return rewriter.create<mlir::AffineLoadOp>(loc, input, reverseIvs); }); return success(); } }; </code></pre></div>Now we can prepare the list of patterns to use during the lowering process:<div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++>void ToyToAffineLoweringPass::runOnOperation() { ... // Now that the conversion target has been defined, we just need to provide // the set of patterns that will lower the Toy operations. mlir::RewritePatternSet patterns(&getContext()); patterns.add<..., TransposeOpLowering>(&getContext()); ... </code></pre></div><h2 id=partial-lowering>Partial Lowering <a class=headline-hash href=#partial-lowering>¶</a></h2>Once the patterns have been defined, we can perform the actual lowering. The <code>DialectConversion</code> framework provides several different modes of lowering, but, for our purposes, we will perform a partial lowering, as we will not convert <code>toy.print</code> at this time.<div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++>void ToyToAffineLoweringPass::runOnOperation() { ... // With the target and rewrite patterns defined, we can now attempt the // conversion. The conversion will signal failure if any of our *illegal* // operations were not converted successfully. if (mlir::failed(mlir::applyPartialConversion(getOperation(), target, patterns))) signalPassFailure(); } </code></pre></div><h3 id=design-considerations-with-partial-lowering>Design Considerations With Partial Lowering <a class=headline-hash href=#design-considerations-with-partial-lowering>¶</a></h3>Before diving into the result of our lowering, this is a good time to discuss potential design considerations when it comes to partial lowering. In our lowering, we transform from a value-type, TensorType, to an allocated (buffer-like) type, MemRefType. However, given that we do not lower the <code>toy.print</code> operation, we need to temporarily bridge these two worlds. There are many ways to go about this, each with their own tradeoffs:<ul><li>Generate <code>load</code> operations from the bufferOne option is to generate <code>load</code> operations from the buffer type to materialize an instance of the value type. This allows for the definition of the <code>toy.print</code> operation to remain unchanged. The downside to this approach is that the optimizations on the <code>affine</code> dialect are limited, because the <code>load</code> will actually involve a full copy that is only visible after our optimizations have been performed.</li><li>Generate a new version of <code>toy.print</code> that operates on the lowered typeAnother option would be to have another, lowered, variant of <code>toy.print</code> that operates on the lowered type. The benefit of this option is that there is no hidden, unnecessary copy to the optimizer. The downside is that another operation definition is needed that may duplicate many aspects of the first. Defining a base class in <a href=/docs/DefiningDialects/Operations/>ODS</a> may simplify this, but you still need to treat these operations separately.</li><li>Update <code>toy.print</code> to allow for operating on the lowered typeA third option is to update the current definition of <code>toy.print</code> to allow for operating the on the lowered type. The benefit of this approach is that it is simple, does not introduce an additional hidden copy, and does not require another operation definition. The downside to this option is that it requires mixing abstraction levels in the <code>Toy</code> dialect.</li></ul>For the sake of simplicity, we will use the third option for this lowering. This involves updating the type constraints on the PrintOp in the operation definition file:<div class=highlight><pre tabindex=0 class=chroma><code class=language-tablegen data-lang=tablegen>def PrintOp : Toy_Op<"print"> { ... // The print operation takes an input tensor to print. // We also allow a F64MemRef to enable interop during partial lowering. let arguments = (ins AnyTypeOf<[F64Tensor, F64MemRef]>:$input); } </code></pre></div><h2 id=complete-toy-example>Complete Toy Example <a class=headline-hash href=#complete-toy-example>¶</a></h2>Let’s take a concrete example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>toy.func @main() { %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64> %2 = toy.transpose(%0 : tensor<2x3xf64>) to tensor<3x2xf64> %3 = toy.mul %2, %2 : tensor<3x2xf64> toy.print %3 : tensor<3x2xf64> toy.return } </code></pre></div>With affine lowering added to our pipeline, we can now generate:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>func.func @main() { %cst = arith.constant 1.000000e+00 : f64 %cst_0 = arith.constant 2.000000e+00 : f64 %cst_1 = arith.constant 3.000000e+00 : f64 %cst_2 = arith.constant 4.000000e+00 : f64 %cst_3 = arith.constant 5.000000e+00 : f64 %cst_4 = arith.constant 6.000000e+00 : f64 // Allocating buffers for the inputs and outputs. %0 = memref.alloc() : memref<3x2xf64> %1 = memref.alloc() : memref<3x2xf64> %2 = memref.alloc() : memref<2x3xf64> // Initialize the input buffer with the constant values. affine.store %cst, %2[0, 0] : memref<2x3xf64> affine.store %cst_0, %2[0, 1] : memref<2x3xf64> affine.store %cst_1, %2[0, 2] : memref<2x3xf64> affine.store %cst_2, %2[1, 0] : memref<2x3xf64> affine.store %cst_3, %2[1, 1] : memref<2x3xf64> affine.store %cst_4, %2[1, 2] : memref<2x3xf64> // Load the transpose value from the input buffer and store it into the // next input buffer. affine.for %arg0 = 0 to 3 { affine.for %arg1 = 0 to 2 { %3 = affine.load %2[%arg1, %arg0] : memref<2x3xf64> affine.store %3, %1[%arg0, %arg1] : memref<3x2xf64> } } // Multiply and store into the output buffer. affine.for %arg0 = 0 to 3 { affine.for %arg1 = 0 to 2 { %3 = affine.load %1[%arg0, %arg1] : memref<3x2xf64> %4 = affine.load %1[%arg0, %arg1] : memref<3x2xf64> %5 = arith.mulf %3, %4 : f64 affine.store %5, %0[%arg0, %arg1] : memref<3x2xf64> } } // Print the value held by the buffer. toy.print %0 : memref<3x2xf64> memref.dealloc %2 : memref<2x3xf64> memref.dealloc %1 : memref<3x2xf64> memref.dealloc %0 : memref<3x2xf64> return } </code></pre></div><h2 id=taking-advantage-of-affine-optimization>Taking Advantage of Affine Optimization <a class=headline-hash href=#taking-advantage-of-affine-optimization>¶</a></h2>Our naive lowering is correct, but it leaves a lot to be desired with regards to efficiency. For example, the lowering of <code>toy.mul</code> has generated some redundant loads. Let’s look at how adding a few existing optimizations to the pipeline can help clean this up. Adding the <code>LoopFusion</code> and <code>AffineScalarReplacement</code> passes to the pipeline gives the following result:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>func.func @main() { %cst = arith.constant 1.000000e+00 : f64 %cst_0 = arith.constant 2.000000e+00 : f64 %cst_1 = arith.constant 3.000000e+00 : f64 %cst_2 = arith.constant 4.000000e+00 : f64 %cst_3 = arith.constant 5.000000e+00 : f64 %cst_4 = arith.constant 6.000000e+00 : f64 // Allocating buffers for the inputs and outputs. %0 = memref.alloc() : memref<3x2xf64> %1 = memref.alloc() : memref<2x3xf64> // Initialize the input buffer with the constant values. affine.store %cst, %1[0, 0] : memref<2x3xf64> affine.store %cst_0, %1[0, 1] : memref<2x3xf64> affine.store %cst_1, %1[0, 2] : memref<2x3xf64> affine.store %cst_2, %1[1, 0] : memref<2x3xf64> affine.store %cst_3, %1[1, 1] : memref<2x3xf64> affine.store %cst_4, %1[1, 2] : memref<2x3xf64> affine.for %arg0 = 0 to 3 { affine.for %arg1 = 0 to 2 { // Load the transpose value from the input buffer. %2 = affine.load %1[%arg1, %arg0] : memref<2x3xf64> // Multiply and store into the output buffer. %3 = arith.mulf %2, %2 : f64 affine.store %3, %0[%arg0, %arg1] : memref<3x2xf64> } } // Print the value held by the buffer. toy.print %0 : memref<3x2xf64> memref.dealloc %1 : memref<2x3xf64> memref.dealloc %0 : memref<3x2xf64> return } </code></pre></div>Here, we can see that a redundant allocation was removed, the two loop nests were fused, and some unnecessary <code>load</code>s were removed. You can build <code>toyc-ch5</code> and try yourself: <code>toyc-ch5 test/Examples/Toy/Ch5/affine-lowering.mlir -emit=mlir-affine</code>. We can also check our optimizations by adding <code>-opt</code>.In this chapter we explored some aspects of partial lowering, with the intent to optimize. In the <a href=/docs/Tutorials/Toy/Ch-6/>next chapter</a> we will continue the discussion about dialect conversion by targeting LLVM for code generation.<div class=edit-meta> </div><nav class=pagination><a class="nav nav-prev" href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-4/ title="Chapter 4: Enabling Generic Transformation with Interfaces"> Prev - Chapter 4: Enabling Generic Transformation with Interfaces</a> <a class="nav nav-next" href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-6/ title="Chapter 6: Lowering to LLVM and CodeGeneration">Next - Chapter 6: Lowering to LLVM and CodeGeneration </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><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="parent 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="parent 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 class=active><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>