返回资讯中心
外部精选
软件工程
#开发者实时流

BAML 为编译器新增 Rust 后端,运行速度最高提升 34 倍

来源标题:Making our compiler 34x faster

BAML 为编译器开发了新的 Rust 后端,可将 BAML 代码编译成 Rust。编译后代码平均比解释器快约 3.5 倍,在紧凑循环中最高快 34 倍。团队选择从 MIR(高于字节码一层)开始编译,以避免重新实现 BAML 的全部 lowering 逻辑。

Hacker News 最新aaronvg2026/11/19 · 今天22 分钟阅读

以下正文由 AI 翻译自 Hacker News 最新(原文版权归原站所有),可能存在偏差,重要内容请以原文为准。

为 BAML 编写了一个 Rust 编译器,运行时最高提速 34 倍。

我们为 BAML 编译器写了一个新的后端,可以把所有 BAML 代码编译成 Rust。编译后的代码平均比我们的解释器快约 3.5 倍,在紧凑循环中最高快 34 倍。

BAML 从外面看像是一门小语言,但它的特性极其丰富,并且提供了大量运行时保证。它读起来像 TypeScript,并发模型像 Go。任何函数都可以 await/暂停,而且没有 async 关键字。它还会对每一次函数调用做纳秒级 profiling,并自动追踪每个错误的起点以及它如何在调用栈上向上传播。

这张图展示了 BAML 编译器的内部结构及其所有的中间表示。我们选择从 MIR(中层中间表示)编译,它比字节码高一层。再往高走,我们就得自己重做 BAML 的全部 lowering,还得指望我们做出的选择和字节码编译器一致。

我们考察过的大多数方案最终都落到 LLVM 或类似的东西上。对我们来说真正重要的问题是:「在我们的 MIR 和运行时之间横着什么,以及我们最少需要重建多少运行时才能拿到最大程度的优化?」

LLVM IR 是个不错的选择。它是基本块和分支,形状和我们的 MIR 一样,所以我们不需要从 MIR 重建结构化循环。由于我们的 VM 是用 Rust 写的,IR 只能通过 C ABI 调用它。这意味着所有 VM 调用都变成黑盒,除非把它们重写成 IR 操作,否则 inliner 无法穿透优化。工作量太大了。

C 开箱即用地支持 goto,所以 MIR 可以 1:1 编译成它。但同样会撞上 ABI 这堵墙,因为 BAML 里连 + 都是一个 63 位带检查的加法,实现在 VM 的 helper 里,C 既看不见也优化不了。

Cranelift 只能内联它自己的 IR,也就是说我们的 Rust 运行时同样是个黑盒。

由于我们的 VM 运行时是用 Rust 写的,选这个方案后上述大部分问题都消失了。生成的代码调用已经存在的 VM 函数,并能复用相同的类型。配合 fat LTO,LLVM 把生成的代码和运行时作为一个整体来优化,这意味着共享的 helper 也会被内联。这非常好。rustc 还会对输出做类型检查,所以大部分字段索引错误在编译期就能发现。

MIR 是由 goto 连接起来的基本块,而 Rust 没有 goto。

我们只能用循环、if 和 break 来凑。

作为参考,下面是 BAML 中的一个 while 循环及其 MIR:

copy fn user.sum(xs: int[]) -> int { bb0: { _2 = const 0_i64; _3 = const 0_i64; goto -> bb1; bb1: { _5 = copy _3; _6 = len(_1); goto -> bb2; bb2: { _4 = copy _5 < copy _6; branch copy _4 -> [bb5, bb3]; bb3: { _0 = copy _2; goto -> bb4; bb4: { return; bb5: { _8 = copy _1; _9 = copy _3; _7 = copy _8[_9]; _2 = copy _2 + copy _7; _3 = copy _3 + const 1_i64; goto -> bb1;

注意,从 bb5 回到 bb1 的箭头是唯一向后跳的边。

最朴素的做法是在一个 match 外面套一个循环,每个基本块对应一个分支。这在技术上可行,但 LLVM 无法可靠地找到并优化 match 内部的循环。它没法对循环做向量化(用 SIMD 指令一次执行循环的多次迭代,比如一条指令做四次加法),也没法把每次迭代结果都相同的计算提升到循环外(这样只运行一次)。所以运行时相当慢。

copy let mut block = 0; loop { match block { 0 => { total = 0; i = 0; block = 1; } 1 => { n = len(xs); block = 2; } 2 => { block = if i < n { 5 } else { 3 }; } 3 => { result = total; block = 4; } 4 => return result, 5 => { total += xs[i]; i += 1; block = 1; } _ => unreachable!(),

我们可以把每条回边变成一个循环,把每次前向跳转变成一个带标签的 break。

这只有在每个循环都恰好只有一个入口点时才行(否则就是不可规约控制流——一个可以从多个块进入的循环。没有唯一的入口块,所以不复制代码就无法把它写成结构化循环(loop、break、continue))。在扫过约 1.5 万个 BAML 函数之后,我们没有发现例外。我们没有对这一发现做形式化验证,所以改用两条规则来绕过它:

MIR 构建器在编译期检查这两条规则。我们为 sum 生成的 Rust 长这样:

copy 'l1: loop { l5 = l3; l6 = expect_int(vm.container_len(l1)?)?; l4 = l5 < l6; if l4 { l9 = l3; l7 = expect_int(vm.load_array_element(l1, Value::int(l9))?)?; l2 = vm.add_i64(l2, l7)?; l3 = vm.add_i64(l3, 1)?; continue 'l1; } else { return Ok(l2);

LLVM 能看见这个循环并优化它,这让较大的 while 循环在运行时快 2-5 倍。

Rust 默认不提供的第二样东西,是在执行过程中暂停函数。函数的局部变量存在于它的栈帧里,函数返回时栈帧就被弹出,所以编译后的代码无法在调用中途把控制权交还给 VM 并在之后恢复。

通常的变通办法是把每个可能挂起的函数编译成状态机(Rust 的 async 就是这么做的)。由于挂起具有传递性,这个设计会扩散到约 69% 的编译后函数,并让它们比解释器本身还慢约 1.3-1.8 倍。

我们用有栈协程解决了这个问题。每个 VM 拥有一个独立的栈(一个 fiber),编译后的代码在它上面运行,所以挂起只是在同一线程的两个栈之间做一次上下文切换。

函数通过调用 vm.suspend 并传入诸如 Await(future) 这样的请求来暂停。suspend 把被调用者保存寄存器压入 fiber,并把栈指针切回线程的栈,从而把控制权交还给 VM。

VM 处理该请求的方式与处理解释器时相同,并在此期间调度其他任务。

要恢复执行,VM 把栈指针切回 fiber 并恢复寄存器。然后 suspend 像普通函数调用一样返回该请求的结果。

(原文较长,此处译出前 6000 字,完整内容请点「打开原文」。)

正文由 探How 从来源站点 RSS 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。

打开原文
去社区讨论 →