方言系统：属性Attributes

可视化演示

属性基本概念

阿楠在车间里发现，每台设备的不锈钢铭牌上都刻着三行字：额定功率、模具编号、压力上限。传送带上的工件换来换去，可铭牌从来不改。老师傅说：“铭牌管的是这台设备怎么用，不是这批工件是什么。” 一句话点醒了他——设备参数和流水线物料，是两回事。

MLIR 里每个 Operation（设备）同样挂着一组 Attribute（铭牌）。比如 arith.addi 这个加法操作：它究竟加哪两个数，由操作数（传送带上的工件）决定；但它的“可折叠性”“结果类型”这些特性，则由属性描述。编译器优化器会反复读铭牌做决策，运行时的数据流却永远不会去修改铭牌。

形式上，Attribute 是编译期不可变的静态元数据。一个操作可以通过 op->getAttr("name") 读取属性，修改和删除则必须走 setAttr / removeAttr 接口。属性既不是寄存器里的值，也不是内存里的张量，它与操作数是两条完全独立的通道。属性的生命周期由 MLIRContext 统一管理，同一份内容在上下文内只保存一份——这就是后文的唯一化机制。

阿楠在笔记本上写道：传送带上的工件会流动、会被加工，但设备铭牌纹丝不动，是设计师定好的“出厂参数”。理解这条界线，就理解了属性的第一课。

属性类型体系

铭牌上的字段格式各不相同：功率写数字，型号写字母串，配件清单则是一串多行参数。如果所有信息都糊成一行文字，读起来必然打架。工厂因此规定：不同字段使用不同的书写格式。

MLIR 属性也有自己的类型系统。最基础的是 IntegerAttr（整型属性）和 StringAttr（字符串属性）：前者放 padding=1 这类数值参数，后者放 name="conv2d" 这类标识信息。它们是铭牌上最常见的两种“字体”。

组合场景则需要更复杂的格式。ArrayAttr（数组属性）保存一串同类型属性，比如 strides=[1,2] 就是一个包含两个整型属性的数组；DictionaryAttr（字典属性）则保存键值对集合，把一组关联参数捆绑成一个整体。所有属性都继承自 Attribute 基类，在 IR 文本打印时会带上类型信息——例如 #arith.constant<value=5 : i32> 明确说明这是一个 32 位整型属性。

懂了，铭牌上“功率=3kW”用的是数字格式，“型号=A3”用的是字母格式，“配件清单”则是一串数组。格式门当户对，才不会读错行。

特殊属性类型

有些铭牌不走寻常路。阿楠在冲压车间看到一块铭牌，上面不是数字，而是钢印的模具三维图——它描述的是“部件应该长成什么样”；另一台检测设备上只敲了一个“已质检”章，没有任何数值；仓库货架旁的设备，铭牌上写的是一个“货位编号”，指向另一个地方。

这三类特殊属性在 MLIR 里都有对应。TypeAttr 的值本身是一个类型，比如 tensor<4x4xf32>，它描述“这一块数据应该以什么形状存在”。UnitAttr 是无值属性，不携带任何数据，只要存在就表示“该选项开启”，类似代码里的 flag（标志位）。FlatSymbolRefAttr（符号引用属性）保存一个符号名，用来引用函数或全局变量，比如 call @main 中的 @main 就是通过它完成的。

这三类属性看似简单，却在框架里高频出现：TypeAttr 帮助类型推导系统快速拿到张量形状；UnitAttr 常用来标注 no_inline、overflow 等可选项；FlatSymbolRefAttr 是模块级“跳转”的基石。新手最容易把它们混淆，因为它们打印出来都不是普通数值。

阿楠把三类记成三个形象：模具图（TypeAttr）、质检章（UnitAttr）和仓库货位号（FlatSymbolRefAttr）。都是铭牌，但“内容”完全不同——读铭牌前，先分清它是哪一种。

属性接口机制

工厂新来了一位质检员，面对各车间的五花八门设备，他只需要一个读卡器：所有铭牌都统一钉在机身右侧，字段命名规范，一刷就出数据。工厂为此专门立了《铭牌管理制度》。

MLIR 通过统一的 Attribute 基类接口约束所有属性。每个具体属性类都要实现 getId（获得唯一标识）、getDialect（返回所属方言）、print（打印文本）等接口。上层代码不需要知道具体类型，就能遍历、比较、打印任意属性——这就是“统一读卡器”的意义。

在 ODS（算子定义规范）中声明属性后，TableGen 会自动生成强类型访问器。例如给 StrideOp 声明 stride: I64ArrayAttr，框架就会生成 getStride() 方法，让 C++ 代码直接拿到数组值。访问器内部调用 getAttrOfType<ArrayAttr>("stride") 做类型转换，把“读铭牌”变成“点菜单”。此外，TypedAttr 接口进一步要求“属性必须携带类型信息”，使类型相关的算法可以统一处理所有带类型的属性。每个属性也通过 getDialect 知道自己属于哪个方言，跨方言时才能找到正确的翻译规则。

阿楠体会到了“统一读卡器”的好处：无论哪个车间的设备，只要铭牌规范，编译器框架的通用代码就能无障碍读取。接口机制，就是那本《铭牌管理制度》。

属性经典用法

真正讲究的铭牌，除了固定参数，还要处理“出生证明”和“运行档案”。阿楠看到仓库里一张巨型库存表：如果全量记录每个货位的状态，几百页纸都写不完；但老师傅只在一张稀疏表格上记录“哪排哪架有货”，其余空白。

DenseElementsAttr（稠密元素属性）以密集方式保存张量元素，权重、常量数据都常用它——每个位置都写，简单直接。SparseElementsAttr（稀疏元素属性）则只保存非零元素及其坐标，适合零值占比极高的矩阵。此外，布局属性（LayoutAttr）记录数据的内存排布，比如 NCHW 还是 NHWC，tile 形状是什么；名称属性（NameAttr）给操作或名字赋值，在符号表和调试信息里大量出现。选哪种属性，直接决定 IR 的体积和优化器遍历成本。

阿楠学会了：先看铭牌上的数据长什么样——全量密排、零值稀疏、还是带布局描述？选对属性格式，比硬塞进一个标准字段省得多。

属性与重写优化

老师傅每天做“纸面审查”：看到标着“可折叠”的设备，直接在排产表上算出结果，根本不用开机试运行；只有标着“必须现场加工”的，才放上流水线。纸面计算不耗电、不占机床，是最便宜的优化。

属性在模式匹配（Pattern-Matching）和常量折叠（Constant Folding）中扮演关键角色。匹配一段 IR 时，属性值就是“指纹”：匹配器会比较 op->getAttr("pad") 是否等于期望值，不满足就跳过当前候选操作。约束检查越严格，重写规则越精准。

折叠算法则检查每个操作：若所有操作数都是 IntegerAttr 等常量属性，且操作本身是纯函数（无副作用），就当场计算结果，把整个操作替换成一个新的常量操作。这个机制把大量“运行时的重复计算”变成“编译期的一次算术”。更广义的规范化（Canonicalization）会反复应用折叠、合并、消除规则，直到 IR 收敛到精简形态——这正是优化器质量的关键指标。

老师傅的“纸面计算”就是编译期的常量折叠。铭牌上的参数决定了能不能直接算答案——所有性能优化里，这是最便宜的一种。

跨方言属性处理

一台设备从 A 车间搬到 B 车间，铭牌不能原样带过去。B 车间有自己的字段规范，“功率=3kW”必须翻译成 B 车间写法的"power=3000mW"，否则新车间的老师傅看不懂。

跨方言转换（DialectConversion）时，属性同样要“翻译”。新方言可以接收并保留原生属性，也可以定义转换规则把旧属性重写为新方言的属性。在 ConversionPattern 中，通常通过 rewriter.getRemappedAttr 把源属性映射为目标属性；规则没覆盖的属性则默认保留，由新方言决定是否接管。

做好属性转换要盯住三点：打印格式——IR 文本中 #dialect.attr 前缀让每个属性都有归属，读文本就能看出它来自哪个方言；内存唯一化——自定义属性必须实现 hash 和 ==，才能复用 MLIRContext 的缓存，否则每个对象各存一份，内存白白膨胀；常见陷阱——转换时丢了属性、类型不匹配、数组长度变化，都会导致后续 Pass 读到的铭牌“缺字”。处理好这三点，跨方言的 IR 才能正确往返（round-trip）。

阿楠想起老师傅的话：铭牌不是一成不变，而是“入乡随俗”地翻译。编译器的降级（lower）过程，就是一次又一次把铭牌翻译成更底层的方言语言，直到车间里的每一台机器都能接住。

AI 应用场景

Python 演示

# 模拟 MLIR 属性机制：唯一化 + 常量折叠class Attribute:    """属性基类：相同值的属性只保留一个实例（uniquing）。"""    _interned = {}     def __new__(cls, value):        key = (cls.__name__, value)        if key not in cls._interned:            node = super().__new__(cls)            node.value = value            cls._interned[key] = node        return cls._interned[key]     def __repr__(self):        return "{}({!r})".format(type(self).__name__, self.value)  class IntegerAttr(Attribute):    """整型属性：保存编译期整数常量。"""  class StringAttr(Attribute):    """字符串属性：保存编译期字符串，如算子名称。"""  class Operation:    """操作：模拟 MLIR Operation，携带操作数和属性字典。"""     def __init__(self, name, operands, attrs):        self.name = name        self.operands = operands        self.attrs = attrs     def get_attr(self, key):        return self.attrs.get(key)     def __repr__(self):        ops = ", ".join(repr(o) for o in self.operands)        attrs = ", ".join("{}={}".format(k, v) for k, v in self.attrs.items())        return "{}({}) [{}]".format(self.name, ops, attrs)  class ConstantOp(Operation):    """常量操作：只有一个 value 属性，是编译期常量。"""     def __init__(self, value_attr):        super().__init__("arith.constant", [], {"value": value_attr})  def fold_constants(ops):    """常量折叠：add 的两个操作数都是 IntegerAttr 时，编译期直接求和。"""    folded = []    for op in ops:        if op.name == "add":            left, right = op.operands            if isinstance(left, IntegerAttr) and isinstance(right, IntegerAttr):                folded.append(ConstantOp(IntegerAttr(left.value + right.value)))                continue        folded.append(op)    return folded  def main():    a2 = IntegerAttr(2)    a3 = IntegerAttr(3)    a2_again = IntegerAttr(2)    print("唯一化: IntegerAttr(2) is IntegerAttr(2) ->", a2 is a2_again)    print("唯一化: IntegerAttr(2) is not StringAttr('2') ->", a2 is not StringAttr("2"))    print("interned 表大小(折叠前):", len(Attribute._interned))     ops = [        ConstantOp(a2),        ConstantOp(a3),        Operation("add", [a2, a3], {}),    ]    print("折叠前:", ops)    folded = fold_constants(ops)    print("折叠后:", folded)    print("interned 表大小(折叠后):", len(Attribute._interned))    assert isinstance(folded[-1], ConstantOp)    assert folded[-1].attrs["value"].value == 5  if __name__ == "__main__":    main()

1. key = (cls.__name__, value)用“类型名 + 值”作为唯一键，保证 IntegerAttr(2) 与 StringAttr("2") 互不干扰，这正是 MLIR 唯一化表的简化版。
2. node.value = value只在新实例创建时赋值，重复获取已有属性不会再次初始化。
3. class IntegerAttr(Attribute):空类体即可区分属性类型，体现 MLIR 中“类型本身也是元信息”。
4. def get_attr(self, key)模拟 op->getAttr() 的按名读取接口。
5. isinstance(left, IntegerAttr) and isinstance(right, IntegerAttr)折叠判定条件：操作数必须是整型常量属性。
6. folded.append(ConstantOp(IntegerAttr(left.value + right.value)))折叠发生时，整个加法操作被替换为一个新的常量操作。
7. assert folded[-1].attrs["value"].value == 5最终验证折叠结果正确，体现“编译期纸面计算”的可信度。

常见误区

面试题