第二个黄金尖钉:跨越 Valen/Rust 边界的内存安全

Lobsters Hottest 工具

摘要

Verdagon 详细介绍了实验性编程语言 Valen 如何在 Valen/Rust 边界上强制保证内存安全,通过实现分组借用(无需共享异或可变的借用检查),并能无缝直接调用 Rust 函数。

<p><a href="https://lobste.rs/s/ajtnc6/second_golden_spike_memory_safety_across">评论</a></p>
查看原文
查看缓存全文

缓存时间: 2026/10/01 14:26

# 第二个黄金道钉:跨越 Valen/Rust 边界的内存安全 来源:https://verdagon.dev/blog/boundary-memory-safety 让两个内存安全的世界相遇 2026年10月1日—— 在《黄金道钉:复活 Vale(n) 编程语言》(https://verdagon.dev/blog/golden-spike-reviving-vale-valen) 中,我们看到了一门语言如何能够直接调用 Rust 函数,无需经过 C,而是通过直接与 Rust 编译器集成来实现。<sup>0</sup><sup>1</sup> 这真是一段惊心动魄的旅程! 最终,我成功打造了"黄金道钉"——一个使用 Rust 图形库的 Valen 程序: 在那篇文章中,我暗示了我们是如何在 Valen 和 Rust 之间进行借用检查的: 这篇文章篇幅较长,细节我会留到下一篇再讲,但先来个 TL;DR:它还没有完全实现,但这个原型正在跨边界做一些借用检查! 欢迎来到那篇下篇文章! 在本文中,我将展示我们如何在跨越 Valen/Rust 边界时维护内存安全。此外,我们还将看到一个**意外发现**——它发生在我构建这套系统的过程中,结果导致我**打破了宇宙的一条基本法则。** ### Valen( 如果你读过《黄金道钉》(https://verdagon.dev/blog/golden-spike-reviving-vale-valen),可以跳过这一节 (https://verdagon.dev/blog/boundary-memory-safety#valens-memory-safety-group-borrowing)) 这一切都是在全新的 Valen (https://github.com/valen-lang/Valen) 编程语言(Vale (https://vale.dev/) 的继任者)中完成的。它是一门非常早期的实验性语言,具备以下特点:<sup>2</sup> - 无缝调用 Rust 函数(包括泛型函数!),无需绑定或包装器。 - 使用一个**更灵活的借用检查器,不强制共享-或-可变互斥**。 - 拥有用于资源安全的**线性类型**和[更高阶 RAII](https://verdagon.dev/blog/higher-raii-uses-linear-types)。 它还计划加入: - Zig 风格的 comptime,这样我们就能实现[不可能的优化](https://verdagon.dev/blog/impossible-optimization)这类操作。 - 世代引用<sup>3</sup> - 一种能够在不使用 RefCell/Cell/Mutex 的情况下持有可变数据的 Rc。 - 以及*更多*东西。<sup>4</sup> 整个项目*极其实验性*,很多地方还存在漏洞和尖锐的边缘(见边注<sup>5</sup>)。在把这个可怕的东西释放到世界上之前,还有几个月的美好时光用来清理、重写和夯实它。 欢迎访问 [Valen 仓库](https://github.com/valen-lang/valen),但要注意,此处有龙<sup>6</sup> 有人可能会称它为 Rust++,因为它能无缝调用现有 Rust 代码。也可以说它更像 Rust--,因为它旨在更简单,并且提供了一种更轻松使用 Rust 代码的方式。 我们在下文会看到这一点,因为它能让我们以比 Rust 本身更灵活的方式使用现有 Rust 代码。 让我们来谈谈 Valen 的内存安全方法! ### Valen 的内存安全:分组借用 这是 Valen 让我*极度*兴奋的地方。 终于,Valen 实现了 Nick Smith 的[分组借用](https://verdagon.dev/blog/group-borrowing)内存安全方法。 分组借用与 Rust 的借用检查类似,但没有共享-或-可变互斥的限制。 这意味着 Valen 函数可以做到: - 拥有指向同一对象的多个局部变量,并通过其中任意一个进行写入。 - 接受多个指向同一对象的参数,并通过它们进行写入。 - 接受一个指向某对象的参数,以及另一个指向该对象*内部*某处的参数,并且只对后者进行写入。 这带来了*巨大*的简化能力。 例如,下面是一个 Rust 函数,接着我会展示 Valen 能将其简化成什么样子。 ``` // Make attacker_id entity attack defender_id entity. // Note: Attacker might be defender (attacking self). fn attack( entities: &mut SlotMap, attacker_id: DefaultKey, defender_id: DefaultKey ) -> Result<(), String> { let a = entities .get(attacker_id) .ok_or_else(|| "Attacker not found in entities map".to_string())?; let d = entities .get(defender_id) .ok_or_else(|| "Defender not found in entities map".to_string())?; let a_energy_cost = a.calculate_attack_cost(d); let d_energy_cost = d.calculate_defend_cost(a); let damage = a.calculate_damage(d); let a_mut = entities .get_mut(attacker_id) .ok_or_else(|| "Attacker not found in entities map".to_string())?; a_mut.use_energy(a_energy_cost); let d_mut = entities .get_mut(defender_id) .ok_or_else(|| "Defender not found in entities map".to_string())?; d_mut.use_energy(d_energy_cost); d_mut.damage(damage); Ok(()) } ``` 上面的代码在 Valen 中变成了这样:<sup>7</sup> ``` // Make attacker_id entity attack defender_id entity. // Note: Attacker might be defender (attacking self). func attack(a &Entity in g, d &Entity in g) mut(g) { let a_energy_cost = a.calculate_attack_cost(d); let d_energy_cost = d.calculate_defend_cost(a); let damage = a.calculate_damage(d); a.use_energy(a_energy_cost); d.use_energy(d_energy_cost); d.damage(damage); } ``` 差别巨大!<sup>8</sup><sup>9</sup> 之所以能做到这一点,是因为分组借用允许我们**拥有指向同一对象的多个可变引用。** 这正是 Rust 代码*试图*表达的,但 Rust 的借用检查器不允许这么做。<sup>10</sup> 具体来说,Rust 的借用检查器有**共享-或-可变互斥**限制,规定: - 每个引用必须是只读或可读可写的。<sup>11</sup> - 如果你持有某个对象的可读可写引用,就不能使用该对象的任何其他引用。 - 如果你持有某个对象的只读引用,就不能通过它进行写入。<sup>12</sup> 而分组借用的方式则是**告知编译器**两个引用可能指向同一事物,然后使用**失效追踪**来确保我们不会使用一个可能已经悬垂的引用。<sup>13</sup> 你几乎可以把它看作是[世代引用](https://verdagon.dev/blog/generational-references)的编译期版本(事实上,它在编译器中的实现方式也与之非常接近!) 如果你想了解更多关于分组借用的内容,可以查看[原始的分组借用文章](https://verdagon.dev/blog/group-borrowing)。 目前只需要知道,它更加灵活,因为它允许对同一对象存在多个引用,并且允许我们**通过其中任意一个进行写入。** 接下来是令人惊讶的部分:Valen 对 Rust 对象同样能做到这一点。 换句话说,我们可以安全地拥有指向 Rust 对象的多个可变引用。 我能听到你们中有些人的反应:*"等等,什么?!"* ## 第二个黄金道钉:跨越 Valen/Rust 边界的内存安全 本文 0% 的内容由 AI 撰写。<sup>0</sup> 更多想法见[这里](https://verdagon.dev/blog/personal-ai-policy)。 我的立场是:如果你希望别人花时间去阅读某样东西,那就花时间自己动手去写。 感谢阅读 =) --- ### 注释 <sup>1</sup> 也要感谢 Let's Get Rusty,他们为《黄金道钉》这篇文章制作了一个 [YouTube 视频](https://www.youtube.com/watch?v=jJJm2nQVolY)。这是一个很棒的概览,去看看吧!另外纠正一点:我已经不在 Mojo 工作了。他们肯定不会让我做这些事! <sup>2</sup> Valen 与 Vale 的主要区别: - Valen 将采用[分组借用](https://verdagon.dev/blog/group-borrowing),而 Vale 采用的是[区域借用](https://verdagon.dev/blog/generational-references)。 - Valen 将采用普通的世代引用,而 Vale 采用的是概率性世代引用。 - Valen 将具备(而 Vale 没有的)Rust 互操作、Rc、comptime。 - Valen 不会具备(而 Vale 具备的)完美可重放性、无所畏惧的 FFI。 两者都有线性类型。它们的语法大部分仍然相同,但 Valen 可能在语法上会变得更像"更简单的 Rust"。 <sup>3</sup> 指的是普通的世代引用,而不是 Vale 风格的[随机世代引用](https://verdagon.dev/blog/generational-references#random-generational-references)。 <sup>4</sup> 例如:更好的 async 故事、更好的枚举、更好的 mustprogress (https://llvm.org/docs/LangRef.html) 优化、实现 trait 的闭包、统一函数调用语法、良好的编译时间,以及*如果运气好的话*我们也许能把[完美可重放性](https://verdagon.dev/blog/perfect-replayability-prototyped)的部分能力带回来。 <sup>5</sup> 为了明确目前哪些东西是可用的: - Valen 有线性类型,但我们还不能声明现有的 Rust 类型是线性的。 - Valen 有分组借用(闭包除外),并且会在跨边界时进行借用检查。 - 结构体可以跨边界使用,甚至 Valen 的结构体也可以实现 Rust trait。但它们必须是零大小的(填充结构体在我的单独原型中可以工作,但在 Valen 中还没有)。 - 世代引用暂时被禁用,希望很快就能恢复。 <sup>6</sup> 具体来说是绿色的龙。 <sup>7</sup> 最大的收获是引用上的 `in g` 告诉编译器这些引用可能指向同一个对象。`mut(g)` 也表示我们可能会修改它。如果想真正理解这里发生了什么,请查看[分组借用](https://verdagon.dev/blog/group-borrowing)文章。 <sup>8</sup> 此外,如果你仔细看,你会发现 Valen 的例子可能会更快,因为它不需要所有的错误处理分支,而且它不像 Rust 版本那样做 4 次查找,而是做 0 次(或者 2 次,因为根据情况我们可能已经把它们移出去交给调用者了)。不过先打个折扣,我还没有做基准测试。如果真是这样,等那篇文章出来一定会非常疯狂。 <sup>9</sup> 我喜欢这个例子因为它最清晰,但我遇到过更多常见情况,分组借用可以让代码比普通借用检查更简洁。更多例子见[这一节](https://verdagon.dev/blog/boundary-memory-safety#thoughts-on-group-borrowings-flexibility)。 <sup>10</sup> 看起来我们也许可以用 `Cell` 来做到这一点,但这会对这些方法内部的内容做出很多假设。取决于 `use_energy` 和 `damage` 有多复杂,使用 `Cell` 可能不是什么好主意。对于这个例子,`GhostCell` 可能是更好的选择。不过还有其他分组借用的例子是 `GhostCell` 无法胜任的,我不认为它们是等价的。 <sup>11</sup> 更准确地说,一个引用必须是"共享"或"唯一"的。 <sup>12</sup> 技术上我们仍然可以通过 Rust 共享引用来进行修改,如果它内部某处有 `UnsafeCell` 的话。但这通常会带来一些权衡,比如不能对它内部的某些东西创建引用(`Cell`)、运行时错误(`RefCell`)或者使用 `unsafe`。 <sup>13</sup> "悬垂"(dangling)指的是指向一个已经被销毁的事物。 --- ### 打破宇宙的一条基本法则 没错,Valen 代码可以**安全地拥有指向 Rust 对象的多个可变引用。** 我大脑中的 Rust 那一半甚至无法理解这有多亵渎。<sup>14</sup> 而疯狂的巫师那一半则对 Rust 那一半的不安哈哈大笑。<sup>15</sup> 然而,它确实可行! ``` import slotlib.Slot; exported func main() int { let slot = Slot.new(); let ref_a = &slot; let ref_b = &slot; ref_a.mutate(42); ref_b.mutate(73); return ref_a.get(); } ``` ``` pub struct Slot { value: i32, } impl Slot { pub fn new() -> Slot { ... } pub fn get(&self) -> i32 { self.value } pub fn mutate(&mut self, x: i32) { self.value = x; } } ``` 注意 `ref_a` 和 `ref_b` 都指向同一个 `Slot`,然而 `ref_a.mutate(42);` 却把其中一个引用传给了 Rust 的 `&mut` 引用。 但要想理解为什么这能行得通,我们先来谈谈**临时唯一引用**和 "noalias",然后我会解释它们如何帮助我们像上面那样调用 Rust 函数。 <sup>14</sup> 如果你以前用过 Rust,这会让人很惊讶,因为 Rust 的核心信条之一是同一时刻对一个对象只能有*一个*可变引用。但我们都知道那是一个不精确的模型,当人们说 Rust 的借用检查器是保守的时候,他们指的就是这个。(别误会,分组借用也是保守的,只是在这种情况下没有 Rust 那么保守。) <sup>15</sup> 而第三半则在笑话前两半总是为了什么可能和/或什么是理智的而吵个不停。 --- ### 临时唯一性和 noalias 我经常被问到的一个相关问题是:"等等,Verdagon,Rust 的引用之所以更易于优化,是因为它们在 LLVM 中会变成 noalias 指针。如果 Valen 的引用可以互相别名,那不会让它变慢吗?" 这是个好问题,理解答案也有助于我们理解 Valen/Rust 边界。 **TL;DR:**Valen 同样使用 noalias,所以速度一样快。 我会先更详细地解释这个问题,然后解释 Valen 是如何做到的。 #### 什么是 noalias? 在 Rust 中,当你有一个引用参数指向某些数据时,<sup>16</sup>你知道**没有其他人在写入那些数据。** rustc 会把它们变成 LLVM 的 noalias 指针,这样 LLVM 就能知道这一点,并进行更好的优化。 这类似于 C 的 `restrict` 指针,它们同样会变成 LLVM 的 noalias 指针。 例如,这是一个没有 `restrict` 的 C 函数: ``` void addMuchRandom(int *destination, struct Rand *random_state) { for (int i = 0; i < 100; i++) *destination += next_random(random_state); } ``` LLVM 无法很好地优化它。<sup>17</sup> 然而,如果我们将那个参数写成 `int *restrict destination`,就像这样: ``` void addMuchRandom(int *restrict destination, struct Rand *random_state) { for (int i = 0; i < 100; i++) *destination += next_random(random_state); } ``` ……那么它就可以被更好地优化,因为 C 编译器把它变成了一个 LLVM `noalias` 指针。<sup>18</sup> 现在 LLVM 可以把这个函数优化成类似这样的形式:<sup>19</sup><sup>20</sup> ``` void addMuchRandom(int *restrict destination, struct Rand *random_state) { register int temp_register = *destination; for (int i = 0; i < 100; i++) temp_register += next_random(random_state); *destination = temp_register; } ``` 这样更快,因为我们在开头**从指针加载一次**,在结尾存储一次,而不是在每次迭代中都做加载和存储。 所以 C 的 `restrict` 指针和 Rust 的引用非常相似。 两者都保证没有其他人在写入那些数据,并且都会变成 LLVM 的 noalias 指针,从而得到更好的优化。 <sup>16</sup> 注意,对于共享引用,这发生在 Freeze 数据(意味着它不包含任何 `UnsafeCell`、`Cell`、`RefCell` 等)上,或者对于唯一引用也是如此。 <sup>17</sup> 它会变成[这个未优化的 LLVM IR](https://godbolt.org/z/1WsdaGEbd),优化后变成[这个已优化的 LLVM IR](https://godbolt.org/z/P8hM6fW57),这并不算特别优化,因为我们仍然在每次迭代中做加载和存储。 <sup>18</sup> 它会变成[这个带 noalias 的 LLVM IR](https://godbolt.org/z/3KMxoq46T),优化后会变成[这个更优的版本](https://godbolt.org/z/b6abqvoWo)。 <sup>19</sup> 有了 `restrict`,LLVM 就可以把加载和存储提到循环外面。之前没有 `restrict` 时,LLVM 知道那个 `int* destination` 可能指向*任何地方*……包括 `int` 或者 `random_state->state_int`,在这种情况下把加载和存储提到循环外面会导致奇怪的行为。`restrict` 向 LLVM 承诺它不会被那样调用。 <sup>20</sup> 这并不完全等同于 C 中 `register` 关键字的工作方式,但你们懂这个意思就行。 #### Valen 是如何生成 LLVM noalias 指针的? 现在让我们再看一遍我们的 Valen 示例函数,加上 `damage` 方法: ``` func attack(a &Entity in g, d &Entity in g) mut(g) { ... d.d ```

相似文章

Valen 的内存安全:一种新型借用检查

Hacker News Top

Valen 的新文章介绍了一种更灵活的借用检查器(group borrowing),编译器会记住引用指向的位置,以实现比 Rust 更简单灵活的内存安全方案,并已被 Google Carbon 等语言采纳。

金钉子:复活 Vale(n) 编程语言

Lobsters Hottest

这篇文章讨论了一个雄心勃勃的项目,旨在复兴Vale编程语言并创建一种名为Valen的新语言,目标是实现与Rust的无缝集成,以支持跨语言泛型和内存安全。

内存安全是生死攸关的问题

Lobsters Hottest

作者认为,内存不安全的开源软件极易受到即将到来的人工智能漏洞查找代理的攻击,这使内存安全成为道德义务,并且Rust必须作为领先且零开销的内存安全语言取得成功。