2. From Tensor Operations to Matrix Engines: Designing an MLIR Lowering Pipeline for GPU-Specific LLVM IR — Akshay K, Mriganka Bezbaruah
3. Stop Writing Boilerplate C++ for Every PDL Check: Reusable Getters & Checkers for MLIR Patterns — Sumit Agarwal
4. Automating CI Failure Triage in LLVM Using Large Language Models — Haowei Wu
5. Value Forwarding in MLIR: Control-Flow Interfaces and Canonicalizations You Get for Free — Matthias Springer
1. Extensions All the Way Down: Building a Runtime Extension System for The Triton MLIR-Based AI Compiler — Corbin Robeck
Domain-specific AI languages and compilers are intentionally narrow in scope, and their development teams are often much smaller than those behind traditional compiler backends. This creates a challenge in AI compiler stacks where a zoo of custom DSL operations, model-specific optimization passes, and hardware-specific lowering strategies may be valuable to a small set of sophisticated users, such as AI researchers and low-level performance engineers, but too narrow to belong in the core compiler. This tension has grown more acute as optimizations have become more workload specific and, increasingly, AI agent generated: some passes are valuable only for a single model, hardware target, or kernel, and many are effectively disposable, too narrow to upstream yet very expensive to maintain. This talk describes the design and implementation of a multi-level runtime extension system built into the Triton MLIR-based AI compiler. We cover Python facing custom operations that lower to out of tree MLIR operations and dialects, dynamic insertion and selective enabling of passes in a multi-level pipeline, compatibility with upstream evolution, JIT kernel cache behavior when the compiler pipeline changes underneath identical kernel code, and how this modularly can act as bridge to agent-driven optimization loops by reducing the risk of agent generate passes destabilizing the entire toolchain core.
2. From Tensor Operations to Matrix Engines: Designing an MLIR Lowering Pipeline for GPU-Specific LLVM IR — Akshay K, Mriganka Bezbaruah
Modern GPUs accelerate AI workloads by combining conventional Performance Cores with specialized Matrix Cores, creating complex compilation challenges around execution-unit mapping and data movement. This talk presents a production-oriented, MLIR-based lowering pipeline that transforms high-level tensor operations into GPU-specific LLVM IR for these heterogeneous architectures. A key focus is the intricacies of layout lowering, demonstrating how delaying physical layout decisions enables cleaner optimization and minimizes unnecessary memory movement. Attendees will gain practical insights into the engineering trade-offs, abstractions, and step-by-step transformations required to effectively orchestrate computation, tiling, and layout reconciliation across modern matrix-accelerated GPUs.
3. Stop Writing Boilerplate C++ for Every PDL Check: Reusable Getters & Checkers for MLIR Patterns — Sumit Agarwal
Writing pattern matchers in MLIR's PDL is powerful, but even the simplest semantic check — "is this attribute in this set?", "is it within a range?", "for tensor<?x16xf32> , is dim 1 divisible by 16?" — or "what is the operand's rank?", "is the element type fp16?" — forces you to hand-write C++ native constraint, register it by string name, and repeat for every variation.
We removed that boilerplate with a small, reusable library of operations — `get_attr`, `check_attr_eq` / `in_set` / `in_range` / `divisible_by`, and type/shape getters like `get_dim`, `get_rank`, and `get_datatype` — that lower to PDL's `apply_native_constraint`. Pattern authors now express constraints as readable one-liners, while the messy cross-dialect attribute and type comparisons live in one place. This talk shows the design, how it leans on PDL's recently added result-returning constraints, and why we think a version of it belongs upstream in MLIR.
4. Automating CI Failure Triage in LLVM Using Large Language Models — Haowei Wu
While Large Language Models (LLMs) are widely used to automate software engineering tasks, their application in continuous integration (CI) infrastructure remains underserved. To address the heavy operational burden of manually triaging continuous integration failures on downstream LLVM builders, we developed an automated pipeline that monitors failures, aggregates diagnostic logs, and leverages LLMs to pinpoint culprit commits from the associated blamelist. Upon identification, the system automatically generates a diagnostic report in our issue tracker and alerts the on-call engineer for verification. Utilizing publicly available models, this pipeline achieves a 90% accuracy rate in culprit identification, significantly reducing manual triage efforts.
5. Value Forwarding in MLIR: Control-Flow Interfaces and Canonicalizations You Get for Free — Matthias Springer
When control flow branches between blocks or regions in MLIR, values can be forwarded along those edges, a behavior modeled by the BranchOpInterface and RegionBranchOpInterface. This talk gives a from-scratch, example-driven introduction to these frequently-misunderstood interfaces, then shows what you get once an op implements them correctly: a set of fully generic canonicalizations (removing dead forwarded values, deduplicating forwarded values, inlining single-trip regions) that work for any region-based op and that replaced hundreds of lines of hand-written SCF dialect code. This talk suits both beginners who want to finally understand these interfaces and advanced engineers looking for a blueprint for generic, interface-driven transformations.