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

BAML 编译器新增 Rust 后端,编译代码平均提速约 3.5 倍

来源标题:Compiling BAML to Rust

BAML 团队为编译器编写了新的 Rust 后端,可将全部 BAML 代码编译为 Rust。编译后代码平均比解释器快约 3.5 倍,在紧凑循环中最高快 34 倍。该后端从字节码上一层的 MIR 出发进行编译。

Hacker News 最新rathiharivansh2026/11/16 · 今天22 分钟阅读

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

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

BAML 从外面看可能像一门小语言,但它功能极其丰富,并提供了大量运行时保证。它读起来像 TypeScript,并发方式像 Go。任何函数都可以 await/暂停,而且没有 async 关键字。它还会对每一次函数调用进行纳秒级性能分析,并自动追踪每个错误从何处开始、如何沿调用栈向上传播。

这张图展示了 BAML 编译器的内部工作机制及其所有中间表示。我们选择从 MIR(中层中间表示)编译,它比字节码高一层。如果再往高走,我们就得自己重做 BAML 的全部 lowering,并祈祷我们做出的选择与字节码编译器一致。

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

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

C 语言原生支持 goto,所以 MIR 可以 1:1 编译成 C。但同样会撞上 ABI 墙,因为就连 BAML 里的 + 都是一个 63 位带检查加法,位于 VM 辅助函数中,C 既看不见也无法优化。

Cranelift 只能内联它自己的 IR,这意味着我们的 Rust 运行时又成了黑盒。

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

MIR 是由 goto 连接的基本块,而 Rust 没有 goto。我们只能用循环、if 和 break 来凑。

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

function sum(xs: int[]) -> int { let total = 0; let i = 0; while (i < xs.length()) { total += xs[i]; i += 1; total sum.mircopy 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 内部的循环。它无法向量化循环或把工作提升到循环外,所以运行时相当慢。

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 'label。这只有在每个循环恰好只有一个入口点时才行(否则就是不可规约控制流)。在扫描了约 1.5 万个 BAML 函数后,我们没有发现例外。我们没有对此发现做形式化验证,所以我们用两条规则来绕过它:

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

'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 随后像普通函数调用一样返回请求的结果。

从不挂起的函数几乎不付出任何代价。一个挂起的任务占用约 3.7 KB 内存(取决于对象是泛型还是像数组这样的可增长容器)。

BAML 的 GC 是分代式、stop-the-world 的复制收集器。它运行时,所有 VM 都会停止,被收集代中的存活对象(任何仍可达的对象)会被复制到更老的一代。然后收集器清空源代。

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

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

打开原文
去社区讨论 →