社区所有版块导航
Python
python开源   Django   Python   DjangoApp   pycharm  
DATA
docker   Elasticsearch  
aigc
aigc   chatgpt  
WEB开发
linux   MongoDB   Redis   DATABASE   NGINX   其他Web框架   web工具   zookeeper   tornado   NoSql   Bootstrap   js   peewee   Git   bottle   IE   MQ   Jquery  
机器学习
机器学习算法  
Python88.com
反馈   公告   社区推广  
产品
短视频  
印度
印度  
Py学习  »  机器学习算法

Rust、跨语言、模块化:谈谈 Agent 时代用 Rust 原生开发机器学习编译器

NeuralTalk • 15 小时前 • 25 次点击  

投稿/寻求报道/文章纠错:公众号后台 -> 联系我们

关键词:机器学习编译器、Rust、TVM-FFI、跨语言、动态扩展

作者:白板笔[1],感谢 @玉川[2] 与我共同完成这篇文章的撰写,也感谢 @陈天奇[3]  和其他社区成员对文章提出的宝贵意见。同时,也感谢 TVM、TileLang 以及广大机器学习编译社区一直以来的支持、反馈和贡献!

最近半年来,Agent 在 GPU kernel 生成和底层系统开发上的进展,相信不少同学已经开始怀疑人生了。从自动生成高性能 kernel,到实现机器学习编译器(下文简称编译器)的 pass 和各种程序分析工具,它已经可以承担非常多纯手搓工作。

不过,在 agent 开始大规模输出代码的同时,我们会遇到一个头疼的问题:我们如何验证这些代码是正确的?尤其是当我们的场景从自动生成 kernel 转到编译器开发,毕竟编译器核心代码不是一次性的,我们尽量不能让它变成石山。(当然了,如果你能仔仔细细一行行去 review agent 写的几万行代码的话当我没说 orz)

  • 打破语言边界:谈谈 Agent 时代用 Rust 原生开发机器学习编译器
  • 作者:白板笔,https://zhuanlan.zhihu.com/p/2104413924921708824
  • Apache TVM 官方博客:Building a Rust-Native, Cross-Language Foundation for Agentic ML Compilers
  • GitHub:https://github.com/apache/tvm-tirx
  • TIRx 官方文档:https://tvm.apache.org/tirx/ir_guides/working_with_ir_in_rust.html
  • TIRx Harness:https://github.com/mlc-ai/TIRx-harness

相关推荐

在上一篇文章《构建 Agent 时代的机器学习编译基础层》[4]中,我们提出过一个判断:即使未来 agent 可以直接生成 CUDA、PTX 甚至更底层的代码,机器学习编译器基础层依然有重要价值。它不仅可以变换程序,更重要的是,可以帮助我们分析和验证agent 生成的程序。

顺着这个思路,一个自然的变化是:agent 不应该只能调用已经写好的编译器功能,还应该能直接访问程序的中间表示(Intermediate Representation,IR),并为自己的任务编写定制化的编译器工具。这些 IR 通常包含循环、表达式、函数调用等节点,结构化地描述程序。过去,编译器基础层主要服务于人类开发者;现在,它也越来越需要直接面向 agent。

而我们开始用 agent 来编写这些工具时,另一个非常实际的问题也随之而来:这些工具虽然操作同一份 IR,但对开发效率、执行性能和代码安全性的需求却不尽相同。

unsetunset本文目录unsetunset

  • 一、编译器模块应该用什么语言来写?
  • 二、如何让 Rust 写编译器和 C++、Python 一样自然?
    • 2.1 按节点类型分发的两个宏
    • 2.2 四种结构遍历接口
    • 2.3 同一个分析,分别用 Python、C++和 Rust 实现
  • 三、如何保证 Rust 和 C++的内存布局一致?
    • 3.1 基于 TVM-FFI 自动生成 Rust Struct
    • 3.2 创建对象与防止定义过期
  • 四、如何在不重新编译核心的情况下动态扩展 IR?
    • 4.1 扩展模块独立构建、独立加载
    • 4.2 让已有遍历工具认识新节点类型
  • 五、一些讨论和展望
  • 附录:使用 Rust 扩展 TIRx 的复数运算
    • 附录1 在 Rust 中定义新的 IR 类型
    • 附录2 注册新的 Operator
    • 附录3 在 Rust 中实现 Lowering Pass
    • 附录4 将 Rust Pass 接入已有的编译 Pipeline

unsetunset一、编译器模块应该用什么语言来写?unsetunset

图 1 |编译器模块该用什么语言来写。图中上方列出三个候选:Rust(安全加性能)、Python(快速原型)、C++(现有生态),三者汇聚到中间的「Choose one」,再由机器人举着「编译器例程」的牌子,指向右侧带问号的「编译器基础层主语言」。图的核心在于:三种语言各有明确的分工优势,任何单一选择都要牺牲另外两者的长处,问号恰好落在「谁来当主语言」这个传统假设上。
图 1 |编译器模块该用什么语言来写。图中上方列出三个候选:Rust(安全加性能)、Python(快速原型)、C++(现有生态),三者汇聚到中间的「Choose one」,再由机器人举着「编译器例程」的牌子,指向右侧带问号的「编译器基础层主语言」。图的核心在于:三种语言各有明确的分工优势,任何单一选择都要牺牲另外两者的长处,问号恰好落在「谁来当主语言」这个传统假设上。

编译器模块用什么语言来写,和今天晚上吃啥一样重要

Rust是一个很自然的选择。它的所有权和借用规则、静态类型系统以及并发安全机制,可以在编译阶段挡住不少内存安全错误和数据竞争问题,同时保持较高的执行效率。因此对于 agent 生成的大量底层代码,这些保证尤其有价值。也难怪最近风靡“用 Rust 重写一切”。当然 Rust 并不能保证程序逻辑一定正确,但至少能让开发者少为一部分底层错误操一份心。

Python同样很难被替代。它有丰富的机器学习生态,又足够灵活,特别适合快速验证新想法。我们在使用 agent 开发编译器时也发现,它有时宁愿先用 python 搓一个原型,也不急着修改 c++或者 rust 代码。对 agent 来说,更快完成原型,也意味着更短的迭代周期。

C++则有非常成熟的底层编译器生态。llvm 等工具链已经积累了大量可靠的基础设施,很多生产级编译器框架至今也主要由 c++实现。在这些已经很成熟的部分,我们当然没有必要每次都重新造轮子。

众所周知,传统的编译器通常围绕一门主要语言构建:IR 和其它核心数据结构定义在这门语言中,通常是 c++;python 等其它语言则通过 binding 或者 wrapper 来访问它们。

问题在于,前面讨论了一圈,我们会发现我们选不出“天下第一”的语言,毕竟每个语言各有优劣。而且根据我们的经验,agent 可能更倾向于用 python 开发原型,再用 rust 或 c++完成需要长期维护、更加稳定的实现。

既然如此,一个很自然的问题就出现了: 为什么不让编译器原生支持多种语言呢?

我们的核心思路是,大多数编译器工具其实都围绕同一份 IR 工作,而 IR 本质上就是一棵表示程序的节点树。如果能让不同语言直接访问内存中的同一份 IR 对象,而不必在每次字段访问时付出额外的跨语言调用开销,再为不同语言提供 first-class、符合使用习惯的 API,我们就有机会构建一个真正能让 rust、c++和 python 协同工作的跨语言编译基础层。

图 2 |两种跨语言架构的对比。左侧「传统方式」:IR 住在一栋 C++ 编译器的房子里,Pass、分析、验证器都在房子内部,Python 和 Rust 只能通过墙上伸出的「Bindings」管道间接接触 IR。右侧「原生共享对象」:IR 被放在写有「内存共享对象」的台座上,Python、Rust、C++ 乃至未来的新模块都直接连线到同一份 IR。图底部一句话点题:为每个组件选择语言,而不是为整个编译器选择语言。
图 2 |两种跨语言架构的对比。左侧「传统方式」:IR 住在一栋 C++ 编译器的房子里,Pass、分析、验证器都在房子内部,Python 和 Rust 只能通过墙上伸出的「Bindings」管道间接接触 IR。右侧「原生共享对象」:IR 被放在写有「内存共享对象」的台座上,Python、Rust、C++ 乃至未来的新模块都直接连线到同一份 IR。图底部一句话点题:为每个组件选择语言,而不是为整个编译器选择语言。

小孩子才做选择题,成年人当然是全都要

要理解这套设计,可以先看它和传统跨语言 binding 的区别。

就像前面说的,传统的机器学习编译器架构通常以某一种语言为核心,再把接口通过 binding 暴露给其它语言。这类 binding 有时会引入额外的间接调用,而且不一定能把编译器内部的所有功能都做成符合目标语言习惯的 API。比如,在 python 中调用一个现成的 c++ pass 很方便,但如果想直接在 Rust 中编写自己的 pass,就需要频繁访问循环的 body、表达式的 op,以及其它 IR 字段。

我们希望做到的是细粒度的原生访问(Fine-grained Native Access):rust 模块和 c++ Pass 可以操作同一个 IR 对象,或者同一份其它编译器数据结构,并且直接读取对象字段,而不是层层调用 wrapper。

为此,我们需要一套位于具体编程语言之下的共享约定。我们的解决方案是 TVM-FFI(《构建机器学习系统的开放 ABI 和 FFI 标准》[5] )。TVM-FFI 提供了一套面向机器学习系统的开放 ABI。通过统一的 C ABI,不同语言可以共享同一套引用计数对象。类型注册系统则记录对象有哪些字段,以及这些字段在内存中的位置。新的动态库加载时,还可以向注册系统添加新的类型。这样,rust 不仅能够原地读取 c++对象的字段,也能够定义新的对象类型,供其它语言共享使用。

图 3 |同一个 IR 对象、同一段汇编。图的上方左右分别是 Rust 和 C++ 对同一个 For 节点的结构体定义,二者都指向中间的「同一个 IR 对象」,Python 则用 node.body 直接读字段。下方是关键证据:Rust 和 C++ 读取 body 字段所生成的汇编完全相同,都是三条指令——取出对象指针、加上偏移量 72、返回。它说明这种跨语言访问没有包装层和额外开销,字段读取就是一次普通的内存加载。
图 3 |同一个 IR 对象、同一段汇编。图的上方左右分别是 Rust 和 C++ 对同一个 For 节点的结构体定义,二者都指向中间的「同一个 IR 对象」,Python 则用 node.body 直接读字段。下方是关键证据:Rust 和 C++ 读取 body 字段所生成的汇编完全相同,都是三条指令——取出对象指针、加上偏移量 72、返回。它说明这种跨语言访问没有包装层和额外开销,字段读取就是一次普通的内存加载。

聪明的你肯定发现了他俩汇编有个地方的大小写不一样,但这是对的

我们把这部分工作称为TIRx Rust。它构建在TIRx[6] 之上:TIRx 提供一套轻量、稳定的机器学习编译基础层;TIRx Rust 则进一步提供跨语言原生 IR 访问、符合 Rust 使用习惯的 API,以及动态扩展能力。

我们并不想“把整个编译器都用 Rust 重写一遍”,而是尝试一种新的开发方式:让 Agent 在不同模块、不同开发阶段自由选择最合适的语言,并且在细粒度上组合使用。

我们目前的初步实践也说明, 这种方式可以让 Agent 使用 Python 更快地开发原型,使用 Rust 实现更加可靠的模块,同时自然地接入 C++中成熟的编译工具链。

unsetunset二、如何让 Rust 写编译器和 C++、Python 一样自然?unsetunset

有了 TVM-FFI,我们已经可以在 rust 中共享编译器的 IR 对象。但能拿到 IR 对象只是第一步,写起来顺不顺手是另一回事。我们希望不论是人还是 Agent,都能用符合 Rust 习惯的方式检查、遍历和改写 IR,写起来轻松愉悦~

首先,rust 中的共享 IR 对象通过引用计数来管理,并且遵循 Rust 的所有权规则。例如,clone 一个对象 handle 会增加引用计数,drop 时则会减少引用计数。访问字段时也可以遵循 Rust 的借用机制。开发者不需要自己管理每一次跨语言对象的释放。

另一方面,在编译器分析中,我们经常要根据当前节点的类型决定下一步怎么做。比如,遇到For节点就处理循环,遇到Add就处理加法表达式,遇到Var就读取变量名。

2.1 按节点类型分发的两个宏

TIRx Rust 提供了match_any!宏,让我们能够根据 IR 对象的实际类型进行分发。例如,下面的describe函数接收一个PrimExpr,递归生成它的字符串表示:

fn describe(expr: &PrimExpr) -> Result {
    let text = match_any! {
        expr {
            Add(ref add) => format!("({} + {})", describe(&add.a)?, describe(&add.b)?),
            Mul(ref mul) => format!("({} * {})", describe(&mul.a)?, describe(&mul.b)?),
            Var(ref var) => var.name.as_str().to_owned(),
            IntImm(ref imm) => imm.value.to_string(),
            _ => "".to_owned(),
        }
    };
    Ok(text)
}

这里遇到Add或Mul时会递归处理两个 op;遇到Var时读取变量名;遇到 IntImm时读取常量值。最后的_负责匹配没有单独处理的其它类型。

这和 Rust 原生的 Enum Pattern Matching 很像,但有一个重要区别:我们不需要事先定义一份包含所有 IR 节点类型的固定 Enum。下游扩展模块可以在独立的动态库里新增自己的 IR 类型,而match_any!仍然可以用来匹配这些运行时注册的类型。这一点对 Agent 快速扩展 IR 尤其重要:新增表示方式时,不必每次都重新编译整个系统。当然,想要对新类型执行专门逻辑的代码,仍然需要写出对应的匹配分支。

除了match_any!,TIRx Rust 还提供了#[dispatch]宏,可以把针对不同节点类型的处理函数组织在同一个 rust struct 中。这样的类型分发模式,在传统编译器 Visitor 和 Analysis 中非常常见。

例如,下面的Printer分别实现加法、变量和整数常量的打印逻辑,再通过 self.dispatch选择对应的处理函数:

#[dispatch(print, (AnyView, bool), String)]
impl Printer {
    fn print_add(&self, add: &Add, nested: bool) -> String {
        let text = format!("{} + {}", self.show(&add.a, true), self.show(&add.b, true));
        if nested { format!("({text})") } else { text }
    }

    fn print_var(&self, var: &Var) -> String {
        var.name.as_str().to_owned()
    }

    fn print_imm(&self, imm: &IntImm) -> String {
        imm.value.to_string()
    }

    fn show(&self, expr: &PrimExpr, nested: bool) -> String {
        let text = self.dispatch(AnyView::from(expr), nested);
        text.unwrap_or_else(|| "".to_owned())
    }
}

2.2 四种结构遍历接口

这样,开发者可以把注意力放在每种节点对应的处理逻辑上,不必反复手写底层类型判断。不过,在实际开发编译器 Pass 时,仅仅能够根据节点类型执行不同操作还不够。我们还需要递归遍历整棵 IR 树,对其中的节点进行分析和改写。为此,TIRx 提供了四种 Structural Traversal 接口(参见 TVM-FFI 文档《Rust Guide》[7]):

图 4 | IR 遍历 API 的四个象限。这张图把四个遍历接口按两个维度归类:横轴是「读 IR」还是「改写 IR」,纵轴是递归由框架自动完成还是由 pass 自己控制。structural_walk 负责读且自动递归,structural_map 负责改写且自动递归,structural_visit 负责读但由自己控制下钻,structural_mutate 负责改写且自己控制。选择接口时先想清楚这两个问题,就可以直接对号入座。
图 4 | IR 遍历 API 的四个象限。这张图把四个遍历接口按两个维度归类:横轴是「读 IR」还是「改写 IR」,纵轴是递归由框架自动完成还是由 pass 自己控制。structural_walk 负责读且自动递归,structural_map 负责改写且自动递归,structural_visit 负责读但由自己控制下钻,structural_mutate 负责改写且自己控制。选择接口时先想清楚这两个问题,就可以直接对号入座。

请选择你要使用的接口

其中,structural_walk和structural_map会自动递归访问子节点,适合常见的分析和变换场景;而structural_visit和structural_mutate则允许开发者自己控制遍历过程。

例如,在 TIRx 文档《Working with IR in Rust》[8]的例子中,我们通过#[dispatch]实现了一个简单的 Counter,用来统计 IR 中Var和 Add节点的数量:

#[derive(Default)]
struct Counter {
    vars: usize,
    adds: usize,
}

#[dispatch(walk, (AnyView, DefRegionKind), Result)]
impl Counter {
    fn walk_var(&mut self, _var: &Var) -> Result {
        self.vars += 1;
        // ...
        Ok(WalkResult::Advance)
    }

    fn walk_add(&mut self, _add: &Add) -> Result {
        self.adds += 1;
        Ok(WalkResult::Advance)
    }
}

fn count() -> Result<:string> {
    // ...
    tvm_ffi::structural_walk(&expr, &mut counter, WalkOrder::PreOrder)?;
    // ...
}

有了#[dispatch],再配合 structural traversal 或者带类型信息的 closure,我们就可以比较自然地实现各种编译器 pass 和 analysis。

不过,这里还留下两个需要解决的技术问题:Rust 如何保证自己看到的对象内存布局与 C++完全一致?以及,当扩展模块引入新的 IR 节点类型时,已有的 traversal 怎样访问这些从未见过的节点?

下面我们来看一个更具体的跨语言例子。

2.3 同一个分析,分别用 Python、C++和 Rust 实现

我们通过 TIRx 文档《IR Overview》[9]中的 add_one 例子,展示前面介绍的这些能力如何在不同编程语言中使用。

在这个例子中,add_one通过循环计算B[i] = A[i] + 1,这次写入操作在 IR 中由一个TensorStore节点表示。这里我们分别使用 python、c++和 rust 实现同一个 analysis,收集这个函数写入的 Tensor,也就是找到B。

图 5 |一次写入操作的 IR 子树。这张图把 add_one 中的写操作 B[i] = A[i] + 1 展开成一棵树:根节点是 TensorStore,向下分出三个字段——dest 指向变量 B,indices 是下标 [i],value 是表达式 A[i] + 1。它展示的是 IR 的本质:程序并不是一串文本,而是结构化的节点树,每个节点都有明确的字段,编译器的分析和变换都是在这样的树上进行的。
图 5 |一次写入操作的 IR 子树。这张图把 add_one 中的写操作 B[i] = A[i] + 1 展开成一棵树:根节点是 TensorStore,向下分出三个字段——dest 指向变量 B,indices 是下标 [i],value 是表达式 A[i] + 1。它展示的是 IR 的本质:程序并不是一串文本,而是结构化的节点树,每个节点都有明确的字段,编译器的分析和变换都是在这样的树上进行的。

B[i] = A[i] + 1对应的 TensorStore节点,其中dest表示写入目标,indices表示写入位置,value表示写入的表达式,我们要找到的是 B,也就是dest。

Python 版本:

writes = []

def on_store(store):
    writes.append(store.dest.name)

tvm_ffi.structural_walk(add_one, (ir.TensorStore, on_store))
print(writes)

C++版本:

ffi::Array<:string> TensorsWritten(const tirx::Function& func) {
  ffi::Array<:string> writes;
  ffi::StructuralWalk<:walkorder::kpostorder>(
      func, [&](const TensorStore& store "&") -> ffi::Expected<:walkresult> {
        writes.push_back(store->dest.as()->name);
        return ffi::WalkResult::Advance();
      });
  return writes;
}

Rust 版本:

fn written_tensors(func: Function) -> Result {
    let mut writes = Vec::new();
    let on_store = |store: TensorStore| -> Result {
        let dest = Var::try_from(&store.dest)?;
        writes.push(dest.name.clone());
        Ok(WalkResult::Advance)
    };
    tvm_ffi::structural_walk(&func, on_store, WalkOrder::PostOrder)?;
    Ok(writes.into_iter().collect())
}

可以看到,三种语言都通过structural_walk遍历 IR,并且只在遇到TensorStore节点时执行对应的 Callback。TensorStore表示向 Tensor 写入一个值的操作,dest字段就是写入目标。

这里特别值得注意的是 Rust 代码中的 store.dest。在 TIRx 中,TensorStore和Var这些 IR 节点类型原本都是在 C++中定义的,而 Rust 却可以直接通过store.dest读取字段,不需要经过额外的 wrapper 函数。

这正是我们希望实现的 Fine-grained Native Access:不同语言共享同一份 IR 对象,并且可以通过各自原生的 API 直接访问内部字段。

不过,要让 Rust 直接读取 C++对象的字段,还有一个问题需要解决:Rust 怎么知道这些字段在内存中的具体位置?

unset unset三、如何保证 Rust 和 C++的内存布局一致?unsetunset

让 rust 直接读取 c++对象的字段,听起来似乎只需要在 rust 中定义一个对应的 struct。

但这里有一个非常重要的前提:他俩必须对对象的内存布局达成完全一致的理解。这不仅包括对象的 size 和 alignment,还包括每个字段在内存中的 offset。

而 c++对象的实际布局会受到继承、模板、padding 等因素影响,最终由 c++编译器决定。如果我们手动在 rust 中维护一份对应的 struct,那么一旦 c++侧移动了某个字段,rust 就可能继续按照旧的 offset 读取数据。这种错误不一定会立即报错,而是可能直接导致 Undefined Behavior。

因此,我们希望 rust 的类型定义能够根据 c++编译器实际确定的内存布局自动生成,而不是依赖开发者手动同步。

3.1 基于 TVM-FFI 自动生成 Rust Struct

TIRx 通过 TVM-FFI 的类型反射机制解决了这个问题。

TVM-FFI 会在编译后的 library 中记录每个反射类型由 c++编译器确定的实际内存布局。当我们运行tvm-ffi-stubgen --target rust时,stubgen会读取这些 layout 信息,并自动生成与 c++内存布局一致的 rust struct。

不过,并不是所有类型都可以直接生成能够安全访问字段的 rust struct。为此,stubgen首先会检查类型是否具有完整的 layout。这里的完整是指:除了 padding 之外,从父类型结束的位置到当前类型结束的位置,都能够通过已经反射的字段完整描述。

例如,对于prim.Add:

  • 父类型ir.Expr在 Byte 40 结束。
  • Add的两个 Operand 字段 a和b占据[40, 56)这段内存。
  • 因此,这个类型具有完整的 Layout。

stubgen会生成对应的 rust struct,同时自动加入检查,验证 rust 侧的 size 和 alignment 是否与 c++一致。

图 6 | stubgen 如何让 Rust 镜像与 C++ 保持同步。左侧是 C++ 头文件中的 BinaryOpObj,含 a、b 两个字段;中间的 stubgen 从编译好的库里读取真实的偏移量和大小;右侧是自动生成的 Rust 结构体,标注「已断言:大小 56、对齐 8」。中间的内存条显示字段精确填满  区间。底部流程说明:C++ 一旦增删或调换字段,CI 检查就会报告过期并直接失败,杜绝悄悄错位的风险。
图 6 | stubgen 如何让 Rust 镜像与 C++ 保持同步。左侧是 C++ 头文件中的 BinaryOpObj,含 a、b 两个字段;中间的 stubgen 从编译好的库里读取真实的偏移量和大小;右侧是自动生成的 Rust 结构体,标注「已断言:大小 56、对齐 8」。中间的内存条显示字段精确填满 [40, 56) 区间。底部流程说明:C++ 一旦增删或调换字段,CI 检查就会报告过期并直接失败,杜绝悄悄错位的风险。

我们养了一只克隆羊,它的名字不叫多莉

这样一来,rust 和 c++实际上持有的是指向同一块内存的指针。当 rust 读取一个对象字段时,只需要按照 c++使用的 offset 进行一次内存读取,而不需要额外的跨语言 wrapper 调用。

3.2 创建对象与防止定义过期

除了读取对象,rust 也可以创建这些 IR 对象。我们的stubgen还可以自动生成直接设置字段的 constructor。 如果某种类型的 c++构造函数包含额外的业务逻辑或合法性检查,则需要为它手动编写对应的 rust constructor。

对于 layout 不完整的类型,stubgen不会生成可以直接访问字段的 struct,而是让它保持 opaque,通过 c accessor 访问。不过,pass 经常使用的大多数 IR 节点都具有完整的 layout。

另外,为了防止 rust 侧的类型定义随着 c++代码更新而过期,CI 会根据新构建的 library 重新检查这些定义;如果生成结果与仓库中维护的版本不一致,CI 就会失败。

通过这样的设计,我们不需要手动维护一整套 C++ IR 在 Rust 中的镜像,也可以让 Rust 原生地操作这些共享对象。

解决了跨语言原生访问的问题之后,我们还需要进一步考虑如何让不同语言独立扩展新的 IR 类型和编译器功能。

unsetunset四、如何在不重新编译核心的情况下动态扩展 IR?unsetunset

Agent 经常需要尝试新的 IR 抽象,例如添加一种数据类型,或者为新硬件特性增加一个 op。

在传统 C++编译器中,这类修改通常需要进入核心代码:更新 IR 类型,重新编译核心及其依赖组件,再检查受影响的代码。当很多扩展模块都由 Agent 分别开发时,这套流程就会一遍遍重复。

我们更倾向采用另外一种开发模式:每个扩展都可以在独立模块中完成,开发者或者 reviewer 只需要关注发生变化的模块,而不需要反复修改整个编译器核心。

4.1 扩展模块独立构建、独立加载

为此,TIRx 允许 python、c++和 rust 模块在加载时注册新的 IR 类型、op 和 pass,使用的就是 TIRx 内置类型相同的注册机制。

每个模块可以独立构建、独立加载。当模块加载后,已有的编译器基础设施可以通过 TVM-FFI 发现新注册的类型和功能。这样,开发者只需要重新编译正在修改的扩展模块,TIRx 核心和其它模块都不需要跟着重新编译。

图 7 |动态扩展与聚焦评审。左右对比两种扩展方式。左侧传统编译器:新能力被塞进编译器核心,所有受影响的组件都被圈进评审范围,底部标着「重建核心」。右侧 TIRx 模块化扩展:核心保持「不变」,Python、C++ 模块已在运行,新写的 Rust 模块作为唯一的评审焦点被独立加载进来,旁边虚线框里还留着「下一个模块,任何语言?」的位置。底部对比一目了然:重建核心,还是独立构建、更快出结果。
图 7 |动态扩展与聚焦评审。左右对比两种扩展方式。左侧传统编译器:新能力被塞进编译器核心,所有受影响的组件都被圈进评审范围,底部标着「重建核心」。右侧 TIRx 模块化扩展:核心保持「不变」,Python、C++ 模块已在运行,新写的 Rust 模块作为唯一的评审焦点被独立加载进来,旁边虚线框里还留着「下一个模块,任何语言?」的位置。底部对比一目了然:重建核心,还是独立构建、更快出结果。

只需要加上去就行了,简单吧

4.2 让已有遍历工具认识新节点类型

但动态扩展也带来了一个新的挑战:如何让已有的 IR 遍历和改写工具处理那些后来才加入的节点?

传统的 IR Visitor 通常需要提前知道所有节点类型,并为它们分别实现对应的 Visit 函数。一旦扩展模块动态注册了新的 IR 类型,原来的 Visitor 可能无法识别它,甚至直接跳过。如果这是一个 validator,就可能错误地认为一个没有被完整检查的 kernel 通过了验证。更麻烦的是,新模块也无法直接修改那些早已编译好的 Visitor。

为了解决这个问题,TVM-FFI 把节点的遍历信息从 pass 转移到了 IR 类型本身。 每种类型都会在 registry 中描述自己的结构,例如哪些字段需要递归访问。TIRx 中的大多数节点通过预先编译好的 Structural Hook 提供这些信息,其它类型则可以通过反射字段完成遍历。这样,traversal 只需要根据节点的 type index 查询对应的结构信息,就能够访问原本不认识的新节点。

图 8 |钩子随类型走。左侧是经典 Visitor 的做法:Add、Call 各有对应的 Visit 方法,一旦新增 NewNode,就要在 Visitor 里补写一个 VisitNewNode(),新类型意味着遍历器必须跟着改。右侧是 TVM-FFI 的做法:每种类型在注册时就自带一个 hook 钩子,遍历器只按类型索引查找钩子,自身保持不变。两相对照,核心差别就一句话:新类型来了,左边要改遍历器,右边不用。
图 8 |钩子随类型走。左侧是经典 Visitor 的做法:Add、Call 各有对应的 Visit 方法,一旦新增 NewNode,就要在 Visitor 里补写一个 VisitNewNode(),新类型意味着遍历器必须跟着改。右侧是 TVM-FFI 的做法:每种类型在注册时就自带一个 hook 钩子,遍历器只按类型索引查找钩子,自身保持不变。两相对照,核心差别就一句话:新类型来了,左边要改遍历器,右边不用。

每一种 type 都对应一个 hook

如图所示,传统 Visitor 和这种设计的区别在于:

  • 传统 Visitor: 每增加一种新的节点类型,就可能需要为已有的 Visitor 添加新的 Visit 函数。
  • TVM-FFI: 每个类型注册自己的 traversal 描述,已有的通用遍历工具就能够自动发现和访问它。

当然,如果一个 pass 需要针对新的 op 实现特殊优化或者 lowering,仍然需要编写相应的逻辑。但对于通用的 IR 遍历和结构改写工具,我们不需要随着每一种新类型的加入而反复修改。

这使得编译器核心可以保持稳定,而 Agent 能够在独立模块中持续扩展新的 IR 类型和编译器功能。

为了展示这种动态扩展能力,我们还实现了一个支持复数运算的 TIRx 扩展[10],核心实现只有大约260 行 Rust 代码。这个扩展可以定义新的 IR 类型、注册 op、实现 lowering pass,并且直接接入已有的编译 pipeline,而不需要修改 TIRx 核心。具体的中文版本完整实现过程和代码示例放在文末附录,感兴趣的读者可以进一步参考。

unsetunset五、一些讨论和展望 unsetunset

随着 Agent 能力爆炸式提升,我们认为编译器开发的重心也会逐渐发生变化。

过去几十年,编译器的一个核心思路是实现通用的 optimization pass,然后把这些 pass 应用到不同程序上。但现在 agent 已经可以针对某一个具体 kernel 直接进行优化,甚至生成针对目标硬件的底层实现。在这样的开发模式下,我们可能会越来越多地面对另外一个问题:

当 Agent 已经生成了一个性能很好的 kernel,我们应该如何快速、可靠地判断它是否正确?

这也意味着,除了传统的 transformation pass,程序分析和验证工具可能会在 Agent 时代变得更加重要。

目前,我们已经在 TIRx Harness(《TIRx Harness,一个面向 Agentic GPU Programming 的 Open Compiler Harness》[11])中探索了这样的方向。这个项目是一个面向 Agentic GPU Programming 的开放 Compiler Harness,其中的一些核心分析工具已经基于本文中的 TIRx Rust 实现。

例如,它的 CPU Simulator NumSim使用本文介绍的 rust API 构建 frontend,读取 kernel 的 IR,并将其转换成可以在 CPU 上执行的原生 Rust 代码。在此基础上,Synccheck和 Racecheck进一步复用这套模拟执行机制,在 kernel 真正运行到 GPU 上之前,检查潜在的线程同步错误和内存数据竞争。相关细节也可以参考这个项目的文档《Compiler Analysis》[12]。

图 9 |工具生态的重心转移。左边是传统的「编译器 pass」,经「焦点转移」箭头指向右边一排独立工具——分析、验证、诊断,以及一个标注「任何语言」的新模块插槽。所有工具都立在同一块底座上,底座写着「跨语言基础层(TIRx · TVM-FFI)」。这张图的意思是:未来编译器周边的工作会拆成许多独立的小工具,各自选用最合适的语言,共享同一套底座。
图 9 |工具生态的重心转移。左边是传统的「编译器 pass」,经「焦点转移」箭头指向右边一排独立工具——分析、验证、诊断,以及一个标注「任何语言」的新模块插槽。所有工具都立在同一块底座上,底座写着「跨语言基础层(TIRx · TVM-FFI)」。这张图的意思是:未来编译器周边的工作会拆成许多独立的小工具,各自选用最合适的语言,共享同一套底座。

喊一声嘿土豆可以召唤妙妙工具箱 🧰

这些工具也展示了一种不同于传统编译优化的新方向:我们不一定需要让所有编译器模块都去修改程序,也可以围绕同一套 IR 构建各种独立的分析、模拟和验证工具,为 agent 提供更加可靠的反馈。

这也是我们认为跨语言开发会成为机器学习编译器重要发展方向的原因。这类工具往往数量多、规模小,而且各自只需要解决一个具体问题。agent 自然可以根据任务选择最合适的编程语言,而不必受限于编译器核心使用的语言。通过 TIRx,不同语言都可以直接访问同一套 IR,新的模块也能够独立加入,而不需要修改已有的编译器核心。

这样,rust 也能够在现有的编译器基础设施之上持续发展。新的编译器模块可以直接用 rust 实现,同时继续复用已有的代码和工具链,无需重新实现整个编译器。

未来,agent 的开发习惯和偏好的编程语言可能还会不断变化,但我们希望编译器的基础架构不需要因此被反复重写。我们相信,这样一个开放、稳定且可扩展的跨语言基础层,可以帮助我们在快速变化的 agent 时代,更加轻量地构建和维护机器学习编译器。

unsetunset附录:使用 Rust 扩展 TIRx 的复数运算unsetunset

这里通过一个具体的例子,展示如何利用 TIRx 的 rust 原生 API 和动态扩展机制,在不修改编译器核心的情况下实现新的编译器功能。

我们实现了一个支持复数运算的 TIRx 扩展。它被打包成一个独立的 python package,核心实现只有大约260 行 Safe Rust 代码。这个扩展可以定义新的复数类型和相关 op,并编译一个对复数数组进行乘法计算的 kernel,其中复数的实部和虚部分别存储在两个 float32数组中。

下面介绍它的主要实现过程。

附录1 在 Rust 中定义新的 IR 类型

首先,我们定义一个新的ComplexType,用来表示复数类型:

/// A complex number whose real and imaginary parts share a scalar type.
#[rs_object("my_ext.ComplexType", final, immutable)]
pub struct ComplexTypeObj {
    base_: TypeObj,
    pub dtype: PrimType,
}

#[derive(Clone, tvm_ffi::derive::ObjectRef)]
#[object_ref(parent = Type)]
pub struct ComplexType {
    data_: tvm_ffi::ObjectArc,
}

tvm_ffi::static_init_block! {
    register_type::()?;
}

这里的#[rs_object]会生成符合#[repr(C)]的对象布局,并在 Library 加载时提供类型注册所需的信息。这个类型的父类型是 ir.Type,同时反射了dtype字段,用于描述实部和虚部采用的标量类型。

随后,register_type会将这个新类型注册到 TVM-FFI 对象系统,并将其暴露给 Python,例如通过my_ext.Complex使用它。C++和其它 Rust 模块也可以通过共享对象系统访问这个类型。

这里比较重要的是:这个类型完全在 rust 扩展中定义,不需要提前在 TIRx 核心中添加对应的 c++ Class。

这里还有一个细节:ComplexType并没有显式注册 Structural Hook,但由于dtype字段已经提供了反射信息,已有的 Structural Traversal 仍然可以自动访问这个字段,而不需要重新编译。这也展示了动态类型注册和结构遍历机制如何配合工作。

附录2 注册新的 Operator

有了复数类型,接下来还需要定义复数相关的操作。这里我们提供四个 Operator:

  • complex:根据实部和虚部构造一个复数。
  • cmul:计算两个复数的乘积。
  • real:提取复数的实部。
  • imag:提取复数的虚部。

这些 op 可以通过 TIRx 的OpDef接口注册。例如,复数构造操作可以写成:

tvm_ffi::static_init_block! {
    OpDef::new("my_ext.complex", "Construct the complex number re + im * i.")
        .signature((
            sig::arg::<:primexpr>("re", "The real part."),
            sig::arg::<:primexpr>("im",  "The imaginary part."),
        ))
        .set_infer_type(infer_complex)
        .set_validator(validate_call)
        .set_attr(CALL_EFFECT_KIND, CallEffectKind::Pure);
}

这里除了定义 op 的参数,我们还注册了两个 rust 函数:infer_complex和validate_call。

infer_complex负责在构造 call 时推断结果类型,并在输入参数不合法时抛出TypeError;validate_call则可以在需要时重新验证这个 call,例如在后面实现的map_call中调用它。

TIRx 还会根据这些注册信息自动生成对应的 python builder。

这样,新 operator 的定义、type Inference 和验证逻辑都可以集中在 rust 扩展模块中完成。

附录3 在 Rust 中实现 Lowering Pass

虽然我们现在已经可以在 IR 中表示复数运算,但现有的 codegen 并不知道这些新 operator 应该如何生成底层代码。

因此,扩展模块还需要实现一个LowerComplex pass,把复数运算转换成编译器已经支持的标量运算。

思路很直接:将每个复数拆成两个float32值,分别表示实部和虚部。

例如,两个复数相乘:

(a + bi)(c + di) = (ac - bd) + (ad + bc)i

就可以转换成普通的标量加减乘法。

这里的Lowering是一个带有#[dispatch]的 Struct,通过 structural_map按照 Post-order 遍历 IR,保证 Operand 先于使用它们的表达式完成 Lowering。

其中,bindings用于维护复数变量到标量变量对的映射,parts负责取出表达式的实部和虚部,map_call则对cmul、real和imag进行改写。

核心代码如下:

#[dispatch(map, (AnyView,), Result>)]
impl Lowering {
    fn map_call(&mut self, call: Call) -> Result> {
        if is_complex_op(&call.op)? {
            validate_call(&call)?;
        }
        if call.op.same_as(&Op::get("my_ext.cmul")?) {
            let (a, b) = self.parts(&call.args[0])?;
            let (c, d) = self.parts(&call.args[1])?;
            // (a + bi)(c + di) = (ac - bd) + (ad + bc)i
            let re = &a * &c - &b * &d;
            let im = &a * &d + &b * &c;
            return Ok(Call::new(
                None,
                Op::get("my_ext.complex")?,
                [re, im],
                None,
                Vec::::new(),
                call.loc.clone(),
            )?
            .into());
        }
        let real = call.op.same_as(&Op::get("my_ext.real")?);
        if real || call.op.same_as(&Op::get("my_ext.imag")?) {
            let (re, im) = self.parts(&call.args[0])?;
            return Ok(if real { re.into() } else { im.into() });
        }
        Ok(call.into())
    }
    ...
}

除了这里展示的map_call,还有一个省略的map_bind,用于把复数变量拆成两个标量变量。例如:

z = complex(a, b)

会被转换成:

z_re = a
z_im = b

完成 Lowering 后,我们还会运行第二次structural_map,检查是否残留了无法处理的复数类型或者 op。例如,如果函数参数中仍存在复数类型,就会抛出ValueError ,避免不支持的 IR 进入后续编译阶段。

附录4 将 Rust Pass 接入已有的编译 Pipeline

最后,我们还需要把LowerComplex接入现有的编译器。

在 rust 侧,可以将lower_function包装成一个标准的 Function pass,并通过 TVM-FFI 导出:

fn lower_complex() -> Result {
    let pass = FunctionPass::new(lower_function, PassInfo::new(0, "my_ext.LowerComplex"));
    Ok(Pass::from(&pass))
}

tvm_ffi::tvm_ffi_dll_export_typed_func!(lower_complex, lower_complex);

随后,在 Python Package 中初始化 type 和 op 对应的 builder,并加载 rust library:

_init_exposed_op_api("my_ext", __name__, wrapper=auto_emit_void_call)
_init_exposed_type_api("my_ext", __name__)
_LIB = load_lib_module("my-ext", "my_ext", extra_lib_paths=[Path(__file__).parent])

library 加载后,前面定义的 IR 类型、op 和 pass 就会完成注册。

接下来,我们只需要把LowerComplex放到 TIRx 默认 Lowering 之前:

def _pipeline(*, target=None):
    lower, finalize_host, finalize_device = tirx.get_tir_pipeline("default", target=target)
    return ir.transform.Sequential([lower_complex(), lower]), finalize_host, finalize_device

tirx.register_tir_pipeline("my_ext", _pipeline)

这样,我们就可以直接调用 TIRx 原本的编译接口:

compiled = tvm_tirx.compile(complex_product, target="llvm", pipeline="my_ext")

整个 kernel 会先经过 Rust 扩展提供的 Lowering pass,将复数运算转换成已有的标量 IR,再复用 TIRx 现有的 llvm backend 完成编译,最终计算结果也与 NumPy 一致。

这样,我们就通过一个独立的 Rust 扩展,完成了从定义 IR 类型、注册 op、实现 Lowering pass 到接入编译 pipeline 的整个流程。只需要 import my_ext,就能为 TIRx 增加一种新类型、四个 op 和一个 pass,而不需要修改 TIRx 核心。

欢迎大家使用 TIRx,也期待更多感兴趣的同学一起参与讨论!

参考资料
[1] 

白板笔: https://www.zhihu.com/people/bai-ban-bi-68

[2] 

@玉川: https://www.zhihu.com/people/30214fbfd41ee031069e948949e4eaab

[3] 

@陈天奇: https://www.zhihu.com/people/1d09d935246523c51f69bd13d3c35cfe

[4] 

《构建Agent时代的机器学习编译基础层》: https://zhuanlan.zhihu.com/p/2101651274798196721

[5] 

《构建机器学习系统的开放ABI和FFI标准》: https://zhuanlan.zhihu.com/p/81570886474

[6] 

TIRx: https://github.com/apache/tvm-tirx

[7] 

《Rust Guide》: https://tvm.apache.org/ffi/guides/rust_lang_guide.html#structural-walk-and-visit

[8] 

《Working with IR in Rust》: https://tvm.apache.org/tirx/ir_guides/working_with_ir_in_rust.html#structural-walk

[9] 

《IR Overview》: https://tvm.apache.org/tirx/ir_guides/overview.html

[10] 

支持复数运算的TIRx扩展:  https://github.com/apache/tvm-tirx/tree/main/examples/extension_guides/rust

[11] 

《TIRx Harness,一个面向Agentic GPU Programming的Open Compiler Harness》: https://zhuanlan.zhihu.com/p/2088605062314643836

[12] 

《Compiler Analysis》: https://tirxharness.mlc.ai/docs/components/tools.html


相关推荐

浇个朋友加群请在 NeuralTalk 公众号后台回复:浇个朋友

© THE END

转载请联系本公众号获得授权

Python社区是高质量的Python/Django开发社区
本文地址:http://www.python88.com/topic/203528