自定义方言：给编译器工厂设计与众不同的积木套装

可视化演示

自定义方言开发允许用户根据特定领域需求定义专用的操作和类型系统。通过TableGen描述操作语义、注册方言并实... 切换模式查看不同维度。

方言初识：乐高工厂的行业黑话

走进乐高工厂，你会看到城市车间的工人在聊“十字路口模块”，太空车间在聊“离子推进器”，城堡车间在聊“吊桥绞盘”。这些行业黑话不是故意让外人听不懂，而是为了让同组员工三秒钟完成沟通。MLIR 里的方言就是这个逻辑：每一种方言都是一组领域专用的“词汇”——封装了该领域最常用的操作、类型和属性。TensorFlow 方言里有 tf.matmul，而 LLVM 方言里有 llvm.mul，同一个乘法的语义在不同方言里被描述成了不同形态。

MLIR 之所以被称为“多级中间表示”，秘密就在于它允许不同方言放在同一张“工作台”上共存。一张 AI 计算图刚开始是高层框架方言（如 TensorFlow 的 HLO 方言），经过一次次降级转换后，逐步变成自定义硬件方言、再变成 LLVM 方言，最终成为机器码。这个过程就像把一座“城市街景”图纸逐步变成“标准砖块”清单——每一层都保留必要的语义，但又不断逼近真实的机械结构。自定义方言正是你在中间插入的“专属楼层”。

那么，一个方言到底由什么构成？从这个角度看，可以把方言抽象成一个简单的集合模型：

所以，当你站在乐高工厂的中央调度台前，你会发现：不同车间各说各话不是混乱，而是高效协作的前提。自定义方言，就是给工厂申请一条新生产线、定义一套新黑话。理解了这个“三层积木”模型，你就握住了整个方言系统的钥匙。

TableGen基础：用填空表格替代手工画图

假如你要为乐高工厂设计一款“海洋主题套装”，你不需要从零雕刻每块积木的塑料模具——只要填一份标准设计表格，工厂的自动产线就会按表格生成模具。MLIR 的 TableGen 就是这张“标准设计表格”。它是一个声明式描述语言，让你不用手写海量 C++ 胶水代码，只需写下“我要一块什么样子的积木”，剩下的交由代码生成器处理。

TableGen 搭配 ODS（Operation Definition Specification，操作定义规范）框架，构成了自定义方言开发的第一块基石。ODS 定义了一套“字段模板”：操作的名称、输入参数、输出类型、约束条件、打印格式等。你只管填空，mlir-tblgen 工具会把这张表格翻译成完整的 C++ 类定义、解析器、打印器，甚至自动生成文档。这就是为什么社区常说“TableGen 把方言开发的体力活变成了脑力活”。

从计算角度看，TableGen 的工作方式可以理解为一台“规格翻译机”：

TableGen 的设计哲学很像乐高的模块化模具库：你不需要理解注塑机的每个螺丝，只需要选对模板、填对参数。理解了它的“填空生成”心智模型，后面定义操作和类型时，你会觉得一切水到渠成。

定义操作：设计积木颗粒的拼接接口

在设计海洋套装时，最关键的是每块积木的“拼接接口”——凸点和凹槽的尺寸、位置必须精确，否则两块积木永远无法咬合。方言里的操作（Op）也一样：它不只带一个名字，还定义了自己的“输入接口”和“输出接口”，构建起整个 IR 图的数据流。

在 MLIR 中，一个操作通常由三要素构成：操作数（operands）就是拼接口（输入数据），属性（attributes）是积木上的印刷图案（编译期固定参数），结果（results）则是拼好后的成品凸起（输出数据）。比如你用 ODS 定义一个 matmul 操作，就是声明“这块积木有两个输入凹槽、一个输出凸点，允许贴一张'转置'标签”。同时，你还能为操作添加约束与验证：例如要求输入维度匹配，否则在解析或验证阶段直接报错。

用数学形式表达一个操作的类型签名，可以写成：

在 ODS 里定义操作时，你写的 let arguments = ... 和 let results = ... 本质就是在填这个函数签名。接口设计得越清晰，后续的解析、打印、验证代码就越省力。正如乐高积木的咬合精度决定了整套建筑的稳固，Op 接口定义也在根本上决定了编译优化的质量。

定义类型：给积木贴上精确的尺寸标签

乐高积木的尺寸标签（2×4、1×2）让工人一眼就知道拼接方式；如果所有积木都只标“蓝色方块”，整个工厂会立刻陷入混乱。MLIR 同理——类型（Type）就是给数据值贴上的“尺寸标签”，它告诉编译器“这个值是什么形状、占多少位”。内置类型如 f32、i64 或张量类型 tensor<4x8xf32>，都遵循同一套标签语法。

自定义方言往往需要属于自己的类型。比如你的 AI 芯片用特殊的“4×8 脉动阵列块”，就应该定义 !my.tensor<4x8xf32> 这样的专有类型。定义自定义类型时，要用 .td 声明类型的存储参数（例如形状和元素类型），然后实现该类型的解析器与打印器——否则编译器既看不懂你的文本表示，也没法把内存中的类型结构写回成字符串。

一个带参数的自定义类型，在 MLIR 的文本格式里长这样：

自定义类型最棘手的部分不是声明，而是“解析打印往返”——把类型从字符串读进内存、再还原成相同字符串。这就像乐高的尺寸标签必须正反两面信息一致，差一个数字，后面的积木就拼不上。类型定义稳妥了，你的方言才有坚实的地基。

方言注册：让工厂调度台认识你的新品种

你设计好了海洋套装的积木，可如果工厂调度系统里没有登记，产线上的机器人根本不会碰它们。MLIR 的方言注册就是这个“调度登记”过程：把方言对象挂载到 DialectRegistry（方言注册表）上，让它成为工厂正式认可的“正式员工”。

注册的另一个关键动作是声明依赖。你的新方言可能要用到其它方言的类型或操作，比如你的 !my.tensor 依赖内置的 IndexType，或者 my.matmul 的输出是标准张量类型。在 .td 中通过 dependentDialects 字段声明清楚，加载方言时就会自动先加载依赖项，避免“需要的积木还没入库”的尴尬。

把注册过程抽象一步，它实际上是从单个方言汇聚成整个上下文环境：

常见的坑是：只写好了方言类却忘了调用 registerDialect，或忘了在命令行里 --load-dialect，结果 mlir-opt 报出刺眼的 unknown dialect 错误。记住：积木再好，不登记入库就永远只能待在设计室里。

转换Pass：把城市积木改装成太空积木

同一个乐高零件，在工厂里如何从“城市套装”变成“太空套装”？答案是产线上的改装工序——拆掉部分零件、换装新零件、重新组装。MLIR 的转换 Pass 就是这样的工序，它把高层方言的“语义积木”逐步拆解成低层方言的“机械积木”。这个过程叫降级（lowering）。

降级靠的是“模式重写”（rewrite pattern）。一条模式声明“如果遇到 hlo.matmul，就把它改写成 gpu.matmul 加上一个转置预热操作”。当编译器在 IR 里匹配到左侧形状时，就触发右侧的替换逻辑。多条模式可以串成一条流水线（Pass pipeline），让 IR 一层层从“说人话”变成“说机器话”。比如在可视化演示里，hlo.matmul 先变 gpu.matmul，再变 llvm.mul，就是两个 Pass 接力完成的工作。

把一次匹配改写过程写成数学表达，就是：

写 Pass 时最需谨记的是：不要打破 SSA 支配关系，否则后续优化会得到错误结果。就像改造产线时，不能把传动带拆了却忘了安装新的——链条断了，整个工厂停摆。

实战步骤：搭一条完整的积木套件产线

好，各项零件都齐了，现在我们真正动工：搭一条从设计图到质检报告的自定义方言产线。首先建立工程目录，创建 MyDialect.td 文件，用 ODS 声明方言和几个示例操作。然后运行 mlir-tblgen，让它生成 MyDialect.h.inc 与 MyDialect.cpp.inc，再写一个薄薄的 MyDialect.cpp 把这些生成代码包装成可直接编译的方言库。

第二步是把方言集成进工具链。在你的 CMakeLists.txt 中链接 MLIRDialect、MLIRIR 和 MLIRPass 库，注册 dialect 扩展，让 mlir-opt --my-dialect 能加载它。接下来编写降级 Pass：基于 mlir::RewritePattern 写模式匹配规则，把 my.matmul 等操作重写为更底层的组合。最后，跑一遍“往返测试”——把 IR 文本打印出来再重新解析，检查两次结果是否一致。整个流程的骨架就是：

乐高工厂有条铁则：新套装上市前必须经历从图纸到试产再到质检的完整闭环。自定义方言同样讲究“最小闭环先行”——先做一个能跑通 matmul 的最小工程，再逐步扩展操作与优化。这样即使出错，你也能精确知道是图纸、模具还是组装线的问题。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-"""迷你自定义方言引擎: 注册方言并用Pattern重写实现Pass降级""" class Op:    """操作节点: name + 输入变量列表 + 属性字典"""    def __init__(self, name, inputs=None, attrs=None):        self.name = name        self.inputs = inputs if inputs else []        self.attrs = attrs if attrs else {}     def __repr__(self):        ins = ", ".join(self.inputs)        attr = ", ".join(f"{k}={v}" for k, v in self.attrs.items())        text = f"{self.name}({ins})"        return f"{text} [{attr}]" if attr else text  class Dialect:    """方言 = 名字 + 允许的操作白名单"""    def __init__(self, name, ops=None):        self.name = name        self.ops = set(ops or [])     def allows(self, op):        return op.name in self.ops     def __repr__(self):        return f"Dialect[{self.name}]{sorted(self.ops)}"  class RewritePattern:    """一条转换规则: 匹配源Op名, 由factory返回新Op列表"""    def __init__(self, src, factory):        self.src = src        self.factory = factory     def apply(self, op):        if op.name != self.src:            return None        return self.factory(op)  class Pass:    """一次降级Pass: 遍历所有Op并尝试改写"""    def __init__(self, name, patterns):        self.name = name        self.patterns = patterns     def run(self, ops):        result = []        for op in ops:            for pat in self.patterns:                new_ops = pat.apply(op)                if new_ops is not None:                    result.extend(new_ops)                    break            else:                result.append(op)        return result  class Compiler:    """迷你编译器: 装载方言 + 串起Pass管线"""    def __init__(self):        self.dialects = {}        self.pipeline = []     def load_dialect(self, dialect):        self.dialects[dialect.name] = dialect     def add_pass(self, pass_obj):        self.pipeline.append(pass_obj)     def compile(self, ops):        print("== 初始IR ==")        for op in ops:            print(op)        current = list(ops)        for ps in self.pipeline:            current = ps.run(current)            print(f"== after: {ps.name} ==")            for op in current:                print(op)        return current  def main():    # 1. 声明三种方言    hlo = Dialect("hlo", ["hlo.matmul", "hlo.relu"])    gpu = Dialect("gpu", ["gpu.matmul", "gpu.relu"])    llvm = Dialect("llvm", ["llvm.call"])     # 2. 自定义方言的降级Pattern    def matmul_to_gpu(op):        return [Op("gpu.matmul", op.inputs, {"tma": True})]     def relu_to_gpu(op):        return [Op("gpu.relu", op.inputs, {"chunk": 2})]     lower_pass = Pass("hlo->gpu", [        RewritePattern("hlo.matmul", matmul_to_gpu),        RewritePattern("hlo.relu", relu_to_gpu),    ])     # 3. 装载并编译    comp = Compiler()    for d in (hlo, gpu, llvm):        comp.load_dialect(d)    comp.add_pass(lower_pass)     module = [Op("hlo.matmul", ["%a", "%b"]), Op("hlo.relu", ["%c"])]    comp.compile(module)    print("方言注册表:", {k: sorted(v.ops) for k, v in comp.dialects.items()})  if __name__ == "__main__":    main()

1. class Dialect对应“方言 = 操作集合”的概念，每个方言都有一个操作白名单，类似乐高套件的零件清单。
2. def __init__(self, name, ops=None)方言构造函数，记录方言名与其允许的操作，这是注册表的基本单元。
3. class RewritePattern对应 ODS 中的模式重写规则，src 是要匹配的高层操作名，factory 是产生低层操作的工厂函数。
4. def apply(self, op)核心匹配逻辑：若操作名匹配则调用工厂生成新操作，否则返回 None 表示不命中。
5. class Pass模拟一次转换 Pass，它遍历所有操作并尝试用模式改写，未匹配的操作原样保留。
6. def run(self, ops)Pass 的主体循环，对应编译器遍历 IR 并逐个节点应用 rewrite pattern 的过程。
7. class Compiler迷你编译器总装：load_dialect 装载方言，add_pass 串联 Pass 管线，compile 依次执行。
8. def matmul_to_gpu(op)一个具体 pattern 工厂：把 hlo.matmul 降级为带 tma=True 属性的 gpu.matmul，模拟自定义硬件方言的定制参数。
9. for op in ops: ... else:利用 for...else 语义实现“任一模式命中就改写，否则保留原操作”的优雅遍历。
10. if __name__ == "__main__": main()可执行入口，保证脚本直接被运行时能够自测。

常见误区

面试题