Triton编译器核心：从高级方言到GPU代码生成的完整流程

你是否想过，在追求极致性能的AI计算领域，能否有一种工具，既能让我们像写NumPy一样优雅地描述计算，又能像手写CUDA内核一样榨干GPU的每一分算力？传统CUDA编程的门槛与PyTorch等框架在底层性能上的妥协，构成了GPU编程长期以来的核心矛盾。

OpenAI开源的Triton语言与编译器，正是为了解决这一矛盾而生。它依托于MLIR的层次化中间表示生态，构建了一套独特的方言系统与多阶段Pass流水线，在易用性与高性能之间架起了一座坚实的桥梁。开发者只需用类Python的高级语法勾勒逻辑，编译器便能通过层层递进的优化，生成接近手写极限的高效硬件代码。这使其迅速成为FlashAttention、xFormers等前沿高性能算子的实现基石。

本文将深入解析Triton编译器的两大核心：Triton方言的设计哲学与多层级Pass Pipeline的工作机制。我们会先剖析方言如何抽象算子的计算与数据流，然后详解从前端解析、中间优化到后端代码生成的完整编译流程，最后通过一个简单的自定义方言与优化Pass的实例，展现其强大的可扩展性。

Triton方言

Triton方言的设计深刻体现了在MLIR框架下构建专用中间表示的精髓：它需要在GPU编程的易用性与底层硬件控制力之间取得巧妙平衡。既要通过高级抽象提升开发效率，又要保留足够的“控制阀门”来挖掘硬件潜力，并特别针对AI领域的计算密集型算子提供高效的表达范式。

Triton方言的设计理念

Triton方言的核心追求，是将开发者从繁琐的GPU线程编排、内存管理和同步细节中解放出来，同时保留进行深度性能调优的能力。

传统CUDA编程迫使开发者手动管理线程网格、块和索引，代码冗长且容易出错。而一些过于高级的抽象又常常丢失关键的优化机会，导致性能不理想。Triton方言巧妙地引入了块级并行作为核心抽象支点。通过 tt.program_id 和 tt.make_range 等操作，编译器隐式地处理了网格级别的并行调度以及块内的偏移生成，开发者只需专注于描述单个计算块内的逻辑。这种抽象让IR的表达更接近声明式的张量操作，不仅大幅简化了语义，提升了开发生产力，也为后续优化阶段提供了清晰、规整且易于分析的并行结构。

与此同时，Triton方言并未牺牲对底层的控制。它通过显式的机制为性能调优保留了必要空间。例如，其指针空间建模明确区分了全局内存、共享内存和寄存器等不同层次，允许在IR层面就精准地控制数据的驻留与流动路径。掩码与边界检查机制被深度集成到 tt.load / tt.store 等内存操作中，在确保访问安全的同时，最大限度地减少无效计算。这些机制在保持方言本身硬件无关性的前提下，为开发者提供了基于领域知识的调优手段，同时也为优化阶段实施硬件特定的变换（如数据布局注入、计算调度重排）奠定了坚实的基础。对编译器底层机制的理解，有助于更好地运用这些抽象。

Triton方言的核心内容解析

Triton方言（TTIR）作为编译器的中间表示，提供了一套丰富的操作符来支持高性能GPU编程。其设计特点主要体现在以下几个方面：

1. 灵活的张量形状变换

Triton方言的形状操作核心在于高效解耦张量的逻辑视图与物理存储。以 reshape 操作为例，它允许在不改变底层数据的前提下，重新解释张量的维度结构，这种“视图变换”避免了昂贵的数据重排开销。编译器可以根据 allow_reorder 等属性提示，在保持语义一致性的前提下，自主决定是否调整内存布局以优化后续的访问模式。

transpose 操作则专门处理维度的重排列。其智能之处在于能够识别何时仅需调整内存访问的“步幅”等元数据即可实现维度交换，从而避免进行实际的数据搬运。这种设计使得矩阵转置等常用操作能最大程度地利用现有数据布局，减少对内存带宽的消耗。

2. 高性能计算支持

TT_DotOp 是Triton方言中封装标准矩阵乘加运算的粗粒度原语。它将矩阵乘法与累加这两个关键步骤融合为一个单一的高级操作。这种大颗粒度的设计允许编译器将整个计算块视为原子单元进行统一的调度与优化。该操作通过 inputPrecision 属性支持TF32等面向Tensor Core的精度控制，能根据硬件能力自动选择最优的实现路径，从而在保持接口统一的前提下，为编译器高效映射至硬件的大块矩阵计算指令提供了核心抽象。

归约操作 ReduceOp 则将跨维度的聚合计算（如求和、求最大值）提升为编译器可以显式分析与优化的独立原语。其关键设计在于允许开发者自定义归约的具体组合算法，同时由编译器基于此高层语义，自动选择最优的并行执行策略（如树状归约），从而高效解决数据聚合带来的同步挑战。

扫描操作 ScanOp 专门处理像前缀和这类具有数据依赖性的计算模式。它将序列上的关联操作抽象为一个可定制的内核，使编译器能够理解其数学上的并行潜力，从而将原本串行的累积计算转化为高效的分层或分块并行实现，在保持逻辑正确性的同时最大化硬件利用率。

3. 指针系统

• 通用指针类型：定义了统一的 TT_PtrType，能够指向标量或张量，并通过 addressSpace 参数显式区分内存区域（如全局、共享），为跨层次的内存访问提供了类型安全且支持完整指针算术的基础抽象。
• 多样化的指针变体：在通用指针基础上，系统性地引入了 TT_PtrTensor（指针张量）与 TT_TensorPtr（指向张量的指针）等高级变体，专门用以高效表达间接访问、批量内存操作以及复杂数据结构。
  • ptr<tensor<...>>（指向张量的指针）：将单个指针与一个完整的数据块形状绑定，使得内存操作能够以“块”而非离散标量为粒度进行寻址与传输。这为编译器识别和优化连续的、规整的块状访问（如合并加载）提供了清晰的类型化依据。
  • tensor<...xptr<>>（元素为指针的张量）：构成了一个指针数组，允许每个元素独立寻址，从而天然地用于表达稀疏数据结构和间接的、不规则的访问模式。

4. 指针系统与内存操作的协同

TTIR 构建了一套以类型为中心的内存访问抽象体系。例如，ptr<tensor<128x128xf16>> 这类具体化的指针类型，静态地定义了目标数据块的形状与布局，成为所有内存访问操作的根基性约束与上下文。

高级内存操作的设计完全建立在此类型系统之上。它们接收这类携带完整形状信息的指针作为操作数，其本身的语义（如访问粒度、边界行为）也由指针所指向的类型来定义。

协同工作的典型模式是：针对不同类型的指针使用相应的算术操作。对于标量指针和指针张量（TT_PtrLike），使用 TT_AddPtrOp 操作；而对于指向张量的指针（ptr<tensor<...>>），则使用专门设计的 TT_AdvanceOp 操作，通过 advance %ptr, [offsets] 表示多维偏移。这两种操作都被标记为纯函数并支持编译器折叠优化，确保派生出的新指针能完整保留目标块的形状语义，可被直接传递给后续的内存操作。

TT_LoadOp 等内存操作则实现了形状感知与安全可控的高层块状访问。TT_TensorPtr 所携带的形状信息，使得 Load 操作在语义上便明确了待传输数据的整体布局，编译器可据此预先规划寄存器分配与内存访问模式。

同时，TT_LoadOp 通过内嵌的多种属性实现了安全与性能的精细控制：boundaryCheck 属性支持按维度指定边界检查策略，padding 属性提供了边界访问时的填充选项，cache 属性允许显式控制缓存行为等。这些属性以声明式的方式将策略融入操作定义，配合掩码机制，极大增强了访问的灵活性。编译器利用这些丰富的语义信息，能在保障正确性的前提下，对块状内存访问进行深度优化，如自动合并相邻访问、调整访问顺序以提高缓存命中率，从而实现了高层抽象与底层性能的有机统一。

多层级 Pass Pipeline 与集成流程

总体架构：三层式 Pass Pipeline 设计

Triton 的编译流程通常被设计为一个清晰的三阶段Pass Pipeline，每个阶段目标明确，分工协作。

前端阶段主要负责从 Python 源代码到初始 Triton IR（TTIR）的转换。其核心目标是忠实且无歧义地捕捉用户内核的计算语义与数据流抽象，同时进行初步的规范化。前端 Pass 包括 Python AST 解析、类型推断、参数绑定以及初始的 Dialect 转换（例如将 triton.language 中的调用转换为 tt.func 和 tt.ops）。这一阶段的输出是高层次的 TTIR，它完整保留了块级并行、指针空间和张量布局等抽象，刻意避免过早引入硬件特定细节。其分工重点在于正确性与易调试性，确保生成的 IR 能够清晰反映用户意图，便于后续优化。

优化阶段是整个 Triton Pipeline 的核心性能引擎，目标是通过一系列针对性极强的 Pass 来最大化内核性能。该阶段主要在 Triton IR 层面展开，并逐步向更通用的 MLIR 方言降低。优化 Pass 包括循环变换、算子融合、内存提升、数据布局优化等。其核心哲学是在保持高层语义的抽象层面上进行深度优化，例如提升数据局部性、重叠计算与内存访问、挖掘指令级并行等。

后端阶段聚焦于硬件特定代码的生成，目标是将经过充分优化的 IR 最终降低为可执行的机器码。该阶段从优化后的 IR 开始，通过转换 Pass 将其映射到 LLVM Dialect，并最终生成 PTX 汇编或机器码。其中，转换 Pass 负责主体语义的映射，而寄存器分配、指令调度等 Pass 则在此之后进行细粒度的资源管理与最终的性能微调。

通过这三个阶段的明确分工，Triton 编译器成功地将语义保真、效能优化和硬件适配这些复杂关注点进行了有效分离，深刻体现了渐进式降低的设计哲学。

前端 Pass Pipeline：从高级抽象到 Triton IR

Triton 编译器的前端 Pass Pipeline 承担着关键的桥梁角色。其核心使命是将开发者用 Python 编写的高级抽象内核，系统性地、保真地转换为规范化且富含语义的 Triton IR。这一阶段的设计强调语义保真与初步规范化：在完整保留块级并行、数据流与计算意图的同时，完成类型推导、常量传播，并将高级抽象显式化，同时刻意避免在此阶段引入硬件相关的底层细节。

前端 Pipeline 虽然相对精简，却为整个编译流程奠定了清晰、可靠的基础。它所生成的高层次 TTIR，是后续优化 Pass 施展针对性变换（如内存提升、循环流水线化）的理想载体，同时也支持快速的 JIT 编译，确保了开发调试阶段的高效迭代。

前端 Pipeline 的输入是经 @triton.jit 装饰的 Python 函数对象，输出则为嵌入 MLIR Module 中的 tt.func 函数，其函数体由 tt. 命名空间下的高级操作构成。该过程在内核首次被调用时触发，其工作流程如下：

• 构建 AST 树：编译器分析函数字节码，识别对 triton.language（tl.）模块的调用。这些调用在编译时实质上是IR 构建器，它们共同定义了一个用于描述计算的AST 树。
• 执行上下文关联：编译器将用户调用内核时提供的 grid、num_warps 等执行配置，与上一步构建的计算图进行绑定。同时，函数的形式参数被赋予具体的类型和属性，为后续优化提供完整的上下文。
• 高级 TTIR 生成：基于以上信息，编译器生成初始的 MLIR Module。此时 IR 中的操作仍保持高级抽象，但所有动态的 Python 语言特性已被固化为静态的、可分析的数据流和控制流图。

以下是一个简单的 Python Triton 内核示例：

import triton
import triton.language as tl

@triton.jit
def add_kernel(x_ptr, y_ptr, output_ptr, n_elements, BLOCK_SIZE: tl.constexpr):
    pid = tl.program_id(axis=0)
    block_start = pid * BLOCK_SIZE
    offsets = block_start + tl.arange(0, BLOCK_SIZE)
    mask = offsets < n_elements
    x = tl.load(x_ptr + offsets, mask=mask)
    y = tl.load(y_ptr + offsets, mask=mask)
    output = x + y
    tl.store(output_ptr + offsets, output, mask=mask)

经过前端转换后，会生成如下的初始 TTIR 片段（为简洁起见，部分细节已简化）：

module {
  tt.func public @add_kernel(%arg0: !tt.ptr<f32> {tt.divisibility = 16 : i32}, %arg1: !tt.ptr<f32> {tt.divisibility = 16 : i32}, %arg2: !tt.ptr<f32> {tt.divisibility = 16 : i32}, %arg3: i32 {tt.divisibility = 16 : i32}) attributes {noinline = false} {
    %c1024_i32 = arith.constant 1024 : i32
    %0 = tt.get_program_id x : i32
    %1 = arith.muli %0, %c1024_i32 : i32
    %2 = tt.make_range {end = 1024 : i32, start = 0 : i32} : tensor<1024xi32>
    %3 = tt.splat %1 : i32 -> tensor<1024xi32>
    %4 = arith.addi %3, %2 : tensor<1024xi32>
    %5 = tt.splat %arg3 : i32 -> tensor<1024xi32>
    %6 = arith.cmpi slt, %4, %5 : tensor<1024xi32>
    %7 = tt.splat %arg0 : !tt.ptr<f32> -> tensor<1024x!tt.ptr<f32>>
    %8 = tt.addptr %7, %4 : tensor<1024x!tt.ptr<f32>>, tensor<1024xi32>
    %9 = tt.load %8, %6 : tensor<1024x!tt.ptr<f32>>
    %10 = tt.splat %arg1 : !tt.ptr<f32> -> tensor<1024x!tt.ptr<f32>>
    %11 = tt.addptr %10, %4 : tensor<1024x!tt.ptr<f32>>, tensor<1024xi32>
    %12 = tt.load %11, %6 : tensor<1024x!tt.ptr<f32>>
    %13 = arith.addf %9, %12 : tensor<1024xf32>
    %14 = tt.splat %arg2 : !tt.ptr<f32> -> tensor<1024x!tt.ptr<f32>>
    %15 = tt.addptr %14, %4 : tensor<1024x!tt.ptr<f32>>, tensor<1024xi32>
    tt.store %15, %13, %6 : tensor<1024x!tt.ptr<f32>>
    tt.return
  }
}

优化 Pass Pipeline：保持语义的深度优化

优化 Pass Pipeline 是 Triton 编译流程的核心性能引擎。其任务是在Triton IR 层面实施一系列渐进式、具有高度针对性的高级变换。这一阶段的设计哲学是在保持语义的抽象层上进行深度优化：从前端输出的、相对纯净的 TTIR 出发，逐步且系统地注入适用于通用并行计算模型的优化，例如数据局部性提升、计算与内存访问的重叠、指令级并行挖掘。

该 Pipeline 聚焦于并行计算架构的通用抽象，如数据局部性、并行执行单元协作、分层存储系统等，确保生成的内核代码在 GPU 乃至其他加速器上具备良好的性能可移植性。其最终产出是一个经过充分优化、蕴含丰富并行与访存信息的中间表示，为后续各类硬件特定的后端提供了高性能且语义明确的共同起点。

整个优化 Pipeline 由一个智能的 PassManager 动态调度，并与自动调优框架深度集成：调优器会驱动 Pipeline 以不同的编译时常量反复执行，以搜索最优配置。

以下代码片段展示了优化阶段可能执行的一系列关键 Pass：

def _ttir_to_coreir(mod):
    # ... 获取TTIR代码并写入临时文件 ...
    args = [triton_opt_path, src_path,
            "--triton-to-core-dialects",
            "--linalg-tiling",
            "--legalize-tensor-form-loops",
            "--one-shot-bufferize",
            "--convert-bufferization-to-memref",
            "--cse",
            "--canonicalize"]
    # ... 执行编译命令并返回结果 ...

这些 Pass 各司其职：

• --triton-to-core-dialects：这是一个自定义转换 Pass，负责将 Triton 方言操作重写为核心 MLIR 方言操作，主要映射到 linalg（线性代数）、arith（算术）、scf（结构化控制流） 等方言。这是关键的桥接步骤，它将程序引入通用的 MLIR 优化生态系统。
• --linalg-tiling：对 Linalg 操作应用分块变换，将大张量计算分解为小块上的循环嵌套。这是提升数据局部性的核心优化，分块尺寸通常由自动调优器驱动选择。
• --legalize-tensor-form-loops：合法化分块后生成的循环结构，确保其符合 MLIR 张量方言的语义规范，为后续转换铺路。
• --one-shot-bufferize：应用 MLIR 的“一次性缓冲化”策略，将张量操作整体转换为基于内存缓冲区（memref）的操作。其全局分析能力能最大程度实现原位更新并消除临时拷贝，对于降低内存峰值至关重要。
• --convert-bufferization-to-memref：将缓冲化结果标准化为纯粹的 memref 方言操作。
• --cse（公共子表达式消除）与 --canonicalize（规范化）：作为收尾清理 Pass，消除冗余计算、折叠常量并简化 IR 形式。

这个例子展示了 Triton 优化流水线的一个核心设计原则：它是一个由可重用、可配置的优化模块灵活组合而成的框架，具备强大的内在适应性。

后端 Pass Pipeline：硬件适配与代码生成

后端 Pass Pipeline 是编译流程的最终阶段，负责将优化后的 IR 转换为目标硬件的可执行代码。这一阶段聚焦于硬件映射与最终优化：从已包含高级优化属性但保持硬件中立的 IR 出发，通过一系列 Lowering Pass，逐步将其适配到特定硬件架构，最终生成能充分利用目标平台专用计算单元的高效代码。

这里以向 CPU 后端 Lowering 为例，展示后端阶段执行的部分关键 Pass：

def _coreir_to_llir(mod, metadata):
    # ... 获取Core IR代码并写入临时文件 ...
    args = [mlir_opt_path, coreir_path,
            "--convert-linalg-to-affine-loops",
            "--lower-affine",
            "--convert-linalg-to-loops",
            "--expand-strided-metadata",
            "--convert-scf-to-cf",
            "--convert-arith-to-llvm",
            "--convert-math-to-llvm",
            "--convert-complex-to-llvm",
            "--convert-vector-to-llvm",
            "--convert-index-to-llvm",
            "--memref-expand",
            "--finalize-memref-to-llvm",
            "--convert-func-to-llvm",
            "--convert-cf-to-llvm",
            "--lower-affine",
            "--convert-arith-to-llvm",
            "--canonicalize",
            "--reconcile-unrealized-casts"]
    # ... 执行编译命令 ...

这些 Pass 主要完成以下几类工作：

高层方言到低级循环的转换

"--convert-linalg-to-affine-loops",  # Linalg→Affine循环
"--lower-affine",                    # Affine→标准循环
"--convert-linalg-to-loops",         # 剩余Linalg→循环

这一阶段将声明式的线性代数操作转换为结构化的控制流，是计算语义从代数描述到具体执行流程的关键转变，同时保留了前序优化的分块策略。

内存抽象的低级化转换

"--memref-expand",
"--finalize-memref-to-llvm",

这一转换的核心目标是将抽象的内存空间、布局和访问模式，逐步具体化为面向特定硬件架构的低级表示，翻译为 LLVM 能够理解和优化的显式内存操作序列。

控制流和计算原语的统一化

"--convert-scf-to-cf",                # 结构化控制流→基础控制流
"--convert-arith-to-llvm",            # 算术运算→LLVM运算
"--convert-vector-to-llvm",           # 向量操作→LLVM向量指令

此过程将所有控制流与计算原语统一至 LLVM 框架，为后续的跨平台指令生成提供了语义一致的中间表示基础。

迭代清理与最终合法化

# 二次清理确保转换完整性
"--lower-affine",
"--convert-arith-to-llvm",
"--canonicalize",
"--reconcile-unrealized-casts"

由于转换过程可能产生新的中间表示，需要多次清理以确保 IR 的完全合法化。这体现了编译器降低过程的复杂性——转换并非线性单向，而是一个需要迭代协调的循环过程。

在获得 LLVM IR 后，后端即可通过调用 Clang 等工具将其进一步转换为目标平台上的二进制代码。探索这类开源实战项目中的编译流程，对深入理解系统设计大有裨益。

自定义方言与优化 Pass

自定义方言与优化 Pass 的引入，是 Triton 框架实现可扩展性与硬件泛化能力的核心机制。其设计遵循一套连贯的工程范式：首先通过自定义方言为新的硬件特性或计算模式建立抽象模型；随后，围绕该方言设计针对性的优化 Pass，在编译流水线的适当时机，将高级抽象逐步“翻译”并“优化”为具体的硬件指令。接下来，我们通过一个简单的计算器方言示例来演示这一过程。

自定义 Dialect 的定义

假设我们需要定义一个简单的 Calculator 方言，仅实现标量整数的加减乘除功能。第一步是编写其 TableGen 定义文件。

典型的目录结构如下：

calculator/Dialect/IR/
├── CMakeLists.txt
├── CalculatorDialect.h
├── CalculatorDialect.td
├── CalculatorOps.h
└── CalculatorOps.td

首先，在 CalculatorDialect.td 中定义方言的元信息：

#ifndef CALCULATOR_DIALECT
#define CALCULATOR_DIALECT

include "mlir/IR/DialectBase.td"

// 定义计算器方言
def CalculatorDialect : Dialect {
  let name = "calc";
  let cppNamespace = "::mlir::calculator";
  let summary = "Calculator dialect for basic arithmetic operations";
  let description = [{
    The Calculator dialect provides basic arithmetic operations
    as a simple example of how to define a custom MLIR dialect.
  }];
}

#endif

接着，在 CalculatorOps.td 中定义具体的算术操作：

def AddOp : CalculatorOp<"add", []> {
  let summary = "integer addition operation";
  let description = [{
    Performs integer addition on two operands.
  }];
  let arguments = (ins AnyType:$lhs, AnyType:$rhs);
  let results = (outs AnyType:$result);
}

def SubOp : CalculatorOp<"sub", []> {
  let summary = "integer subtraction operation";
  let description = [{
    Performs integer subtraction on two operands.
  }];
  let arguments = (ins AnyType:$lhs, AnyType:$rhs);
  let results = (outs AnyType:$result);
}

def MulOp : CalculatorOp<"mul", []> {
  let summary = "integer multiplication operation";
  let description = [{
    Performs integer multiplication on two operands.
  }];
  let arguments = (ins AnyType:$lhs, AnyType:$rhs);
  let results = (outs AnyType:$result);
}

def DivOp : CalculatorOp<"div", []> {
  let summary = "integer division operation";
  let description = [{
    Performs integer division on two operands.
  }];
  let arguments = (ins AnyType:$lhs, AnyType:$rhs);
  let results = (outs AnyType:$result);
}

其中，summary 和 description 提供文档，arguments 和 results 定义了操作的输入输出接口。

完成定义后，需要通过 MLIR 的构建系统（TableGen）生成对应的 C++ 代码。通常在 CMakeLists.txt 中配置：

set(LLVM_TARGET_DEFINITIONS CalculatorOps.td)
mlir_tablegen(CalculatorDialect.h.inc -gen-dialect-decls -dialect=calc)
mlir_tablegen(CalculatorDialect.cpp.inc -gen-dialect-defs -dialect=calc)
mlir_tablegen(CalculatorOps.h.inc -gen-op-decls)
mlir_tablegen(CalculatorOps.cpp.inc -gen-op-defs)
add_public_tablegen_target(CalculatorTableGen)

TableGen 会自动生成大量样板代码，使开发者能专注于语义逻辑。

自定义优化 Pass 的实现

定义方言后，下一步是构建将其转换到标准 MLIR 方言的 Pass。我们的目标是将 Calculator 操作 Lowering 到 arith 方言。

典型的转换 Pass 项目结构如下：

├── include/                         // 接口层
│   └── calculator/
│       └── Conversion/
│           └── CalculatorToArith/
│               ├── Passes.td
│               ├── Passes.h
│               ├── CalculatorToArith.h
│               └── CMakeLists.txt
└── lib/                             // 实现层
    └── Conversion/
        └── CalculatorToArith/
            ├── CalculatorToArithPass.cpp
            ├── CalculatorToArith.cpp
            └── CMakeLists.txt

首先，在 lib/Conversion/CalculatorToArith/CalculatorToArith.cpp 中实现核心的匹配重写逻辑：

#define GEN_PASS_CLASSES
#include "calculator/Conversion/CalculatorToArith/Passes.h.inc"

using namespace mlir;
using namespace mlir::calculator;

namespace {

struct AddOpConversion : public OpConversionPattern<AddOp> {
  using OpConversionPattern::OpConversionPattern;

  LogicalResult
  matchAndRewrite(AddOp op, OpAdaptor adaptor,
                  ConversionPatternRewriter &rewriter) const override {
    rewriter.replaceOpWithNewOp<arith::AddIOp>(op, adaptor.getLhs(), adaptor.getRhs());
    return success();
  }
};
// 其他 SubOp, MulOp, DivOp 的 Conversion 模式类似实现...

每个转换模式通过 matchAndRewrite 方法，将源操作原位替换为目标方言中的等价操作。

接着，在 CalculatorToArithPass.cpp 中创建并注册 Pass：

namespace mlir {
namespace calculator {
#define GEN_PASS_DEF_CONVERTCALCULATORTOARITH
#include "calculator/Conversion/CalculatorToArith/Passes.h.inc"
} // namespace calculator
} // namespace mlir

namespace {
using namespace mlir;
using namespace mlir::calculator;

class ConvertCalculatorToArithPass
    : public calculator::impl::ConvertCalculatorToArithBase<ConvertCalculatorToArithPass> {
public:
  void runOnOperation() override {
    MLIRContext *context = &getContext();
    ConversionTarget target(*context);
    RewritePatternSet patterns(context);

    // 定义转换目标：arith 合法，calculator 非法
    target.addLegalDialect<mlir::arith::ArithDialect,
                           mlir::func::FuncDialect>();
    target.addIllegalDialect<mlir::calculator::CalculatorDialect>();

    // 添加转换模式
    populateCalculatorToArithConversionPatterns(patterns);

    // 执行部分转换
    if (failed(applyPartialConversion(getOperation(), target, std::move(patterns)))) {
      signalPassFailure();
    }
  }
};
} // namespace

然后，在接口层的 Passes.td 中声明此 Pass：

#ifndef CALCULATOR_TO_ARITH_PASSES
#define CALCULATOR_TO_ARITH_PASSES

include "mlir/Pass/PassBase.td"

def ConvertCalculatorToArith : Pass<"convert-calculator-to-arith", "mlir::ModuleOp"> {
  let summary = "Convert Calculator dialect to Arith dialect";
  let description = "This pass converts operations from the Calculator dialect to the Arith dialect.";
  let constructor = "mlir::calculator::createConvertCalculatorToArithPass()";
  let dependentDialects = ["mlir::arith::ArithDialect"];
}

#endif

最后，在 CalculatorToArith.h 中提供公共接口：

namespace mlir {
namespace calculator {

#define GEN_PASS_DECL
#include "calculator/Conversion/CalculatorToArith/Passes.h.inc"

void populateCalculatorToArithConversionPatterns(RewritePatternSet &patterns);

std::unique_ptr<mlir::Pass> createConvertCalculatorToArithPass();

} // namespace calculator
} // namespace mlir

转换示例

假设我们有一个使用 Calculator 方言的 MLIR 程序：

func.func @main(%arg0: i32, %arg1: i32) -> i32 {
  %0 = "calc.add"(%arg0, %arg1) : (i32, i32) -> i32
  %1 = "calc.sub"(%0, %arg0) : (i32, i32) -> i32
  %2 = "calc.mul"(%1, %arg1) : (i32, i32) -> i32
  %3 = "calc.div"(%2, %arg1) : (i32, i32) -> i32
  return %3 : i32
}

通过调用 --convert-calculator-to-arith Pass，编译器会将其转换为：

module {
  func.func @main(%arg0: i32, %arg1: i32) -> i32 {
    %0 = arith.addi %arg0, %arg1 : i32
    %1 = arith.subi %0, %arg0 : i32
    %2 = arith.muli %1, %arg1 : i32
    %3 = arith.divsi %2, %arg1 : i32
    return %3 : i32
  }
}

现在，该程序已经完全由标准的 arith 方言构成，可以无缝接入 MLIR 庞大的优化与代码生成生态系统，进行常量折叠、代数简化等进一步优化，并最终降低到 LLVM IR 或机器码。这个过程是理解现代技术文档中编译器如何工作的绝佳案例。

总结

本文系统性地剖析了 Triton 编译器核心的设计哲学与工程实现。我们首先阐述了 Triton 方言如何通过其精心设计的类型系统、操作集与属性，在高级编程的友好性与底层硬件的控制力之间取得了卓越的平衡。接着，我们深入介绍了其多层次 Pass Pipeline 的完整流程：从前端对 Python 代码的解析与初步融合，到在平台无关的中间表示上进行深度优化，再到针对特定 GPU 架构的后端代码生成与精细调度，并完整展现了 Triton IR 与 MLIR 标准方言及 LLVM IR 生态的集成降低路径。

最后，通过一个从定义、实现到集成自定义方言与优化 Pass 的完整案例，我们生动地展示了 Triton 编译器框架强大的可扩展性与硬件适配活力。这种基于 MLIR 的模块化、层次化设计，为社区构建高性能、可移植且易于扩展的 AI 算子供给了坚实而灵活的编译基础设施，持续推动着深度学习计算效率的边界。