Newshot

互斥锁中毒并非人人适用

Translation(model translation, not the source's own text)

文章标题:Mutex poisoning is not for everyone

正文: 最近关于 mutex poisoning 话题有一些讨论,尤其是一篇我觉得有趣、周到、详尽,但完全不能同意的博客文章,我想自己也来评论一下这场辩论。在我看来,默认启用 poisoning 是这门语言所犯的最大错误之一,仅次于另外一些留待日后再说的事情。

简而言之,我认为 Mutex poisoning 对大多数应用来说是错误的选择,因为

  • 它在一般情况下显著劣化了代码性能
  • 而且还妨碍了可读性
  • 同时鼓励了糟糕的代码模式来应对它的怪异行为
  • 只是为了解决一个细分问题
  • 而这个问题甚至没有被普遍解决。

什么是 poisoning?

理论上,mutex 保护代码中的一个临界区。那段代码在不受并发线程干扰的情况下改变某块数据的状态,然后释放锁。那段代码随后可能遇到错误,在完成其重要工作的中途释放锁。例如:


        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
fn important(always_even: Arc<Mutex<i32>>) -> i32 {
    // Invariant: always_even must always be even
    let mut handle = always_even.lock().unwrap();

*handle += 1;

risky_operation();

*handle += 1;

*handle
}

fn risky_operation() {
    if rng().next_u32() % 42 == 0 {
        panic!();
    }
}
      

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
      

        fn important(always_even: Arc<Mutex<i32>>) -> i32 {
    // Invariant: always_even must always be even
    let mut handle = always_even.lock().unwrap();

*handle += 1;

risky_operation();

*handle += 1;

*handle
}

fn risky_operation() {
    if rng().next_u32() % 42 == 0 {
        panic!();
    }
}
      

下面的代码在大多数时候会正常工作,但如果骰子没掷到我们想要的结果,always_even 这个 mutex 就会在一个无效状态下被解锁。在今天的 Rust 中,poisoning 的存在就是为了处理这种情况。如果一个 guard 被异常释放(在 panic 期间),它会在一个布尔值中记录此事。之后任何对 lock() 的调用都会返回 Err(PoisonError),当我们 unwrap 它时会触发 panic。坏状态永远不会被观察到,一切安好。

你可能觉得我编造的例子有些刻意。因为它确实是。这种模式的真实案例确实会发生,但大多数涉及 mutex 的使用场景要简单得多。许多临界区不过是一个变量赋值,或者没有无效的中间状态。在底层编程中,有些情况是 mutex 保护的数据并不直接位于其中,或者完全在程序的视野之外。事实上,我曾为一个 C 库写过这样的包装器。不过我不同意这是常见情况的说法。

我确实推荐大家读 Rain 关于此事的博客,因为她有一些很好的例子,说明如何导致对这些临界区的违反(即使没有 mutex),并且我完全支持为需要它的用例提供 Poison 包装器的想法。我猜想她所工作的领域相比我的领域更容易遇到这些问题。Rust 的默认行为应该让常见情况变得容易,让罕见情况成为可能。

旁注:mutex 如何工作

本节只与当前话题略有关系,但我已经写好了,还没准备好删掉我的心血。1 跳到下一节继续关于 poisoning 的讨论。

在 Rust 中,对大多数平台而言,mutex 是使用 futex2 系统调用实现的。只要相关 mutex 没有争用,它允许操作纯粹停留在用户空间,这对性能来说很好。

在底层,mutex 在大多数平台上是一个简单的 32 位整数,尽管它只持有三个唯一值:

  • 如果它为零,mutex 是空闲的,任何线程都可以通过简单的原子比较交换来占用它。

文章标题:Mutex 毒化并非人人适用

正文:

  • 如果值为一,说明互斥锁已被持有,但没有等待的线程。知道这一点很有用,因为这意味着释放互斥锁时我们不需要唤醒任何线程,可以继续留在用户空间。
  • 如果值为二,说明互斥锁已被持有,并且有其他线程正在等待它。这意味着解锁时需要额外小心。

流程图展示了 Rust 中如何通过原子操作和 futex 原语实现互斥锁的获取。注意无竞争的情况完全停留在用户空间,不会让线程休眠。

Rust 通过几个原子操作和 futex_wait 调用来实现这一点。关键在于,锁定一个无竞争的互斥锁只需一次原子操作。唯一需要上下文切换的操作是 futex_wait。

解锁则更加简单。持有互斥锁的线程首先释放锁,然后可选地,如果有迹象表明锁存在竞争,就唤醒任何休眠的线程,让它们尝试获取锁。

流程图展示了 Rust 中互斥锁的释放过程。首先,我们将当前值与 0 交换,然后根据原值是 1(仅被锁定)还是 2(存在竞争),可选地唤醒任何休眠的线程。

毒化如何损害每一段代码

如上文过于详细地讨论的那样,只要没有竞争,互斥锁的(解)锁开销就很低,而当存在竞争时,至少在指令层面开销也很低。而互斥锁毒化正是在这里给你带来麻烦。

简而言之,能够进行毒化是一项始终需要付出代价、却很少被使用的成本。首先,毒化本质上是通过给每个 Mutex 添加一个 AtomicBool 字段来实现的。由于对齐的原因,这会让每个互斥锁的大小增加从零字节到额外一个指针不等的空间。这不算太糟,但对于需要大量互斥锁来保护小对象的用例来说,这些开销会累积起来。

然而,对我来说真正的问题在于代码体积。让我们从一个同样刻意构造的例子开始,一个读取其参数、复制它并返回它的函数。理想化的版本如下所示。


        1
2
3
pub fn get_contents(val: &i32) -> i32 {
    *val
}
      

        pub fn get_contents(val: &i32) -> i32 {
    *val
}
      

这会被编译成 2 条指令和一个标签。将数据复制到寄存器中然后返回。


        1
2
3
example::check_contents::h197b180b47e24703:
        mov     eax, dword ptr [rdi]
        ret
      

        example::check_contents::h197b180b47e24703:
        mov     eax, dword ptr [rdi]
        ret
      

当然,这对于任何需要共享可变性的场景都不适用,但我们可以把它当作基线。完美的版本看起来就是这样。那么,让我们忽略原子整数的存在,在这个故事中加入一个互斥锁。我们将逐一查看各自生成的汇编代码,你可以在 Compiler Explorer 概览中对比完整的代码。

基础案例:锁定与解包

我们可以更新上面的代码来实际使用互斥锁,简单地锁定然后解包互斥锁。


        1
2
3
4
5
use std::sync::Mutex;

pub fn check_contents(mutex: &Mutex<i32>) -> i32 {
    *mutex.lock().unwrap()
}
      

        use std::sync::Mutex;

pub fn check_contents(mutex: &Mutex<i32>) -> i32 {
    *mutex.lock().unwrap()
}
      

这总共编译成 147 行汇编代码,我不会在这里完整复现。

  • 其中 75 行是专门内联到这个特定函数的,无法复用。
  • 大约 45 行是为保护 i32 的互斥锁而单态化3的。
  • 其余部分是全局程序信息,可能会被其他锁复用。

换一种方式划分,我们有

  • 检查毒化状态的代码
  • 执行互斥锁操作的代码
  • 在发生 panic 时触发毒化的代码
  • 在需要时准备 panic 的代码
  • 显示 panic 的代码
  • 一些 dyn drop glue

这篇文章的大部分内容都被内联进了函数中。这反过来又会影响性能,因为这会限制你的“实际”代码有多少能放进 CPU 的指令缓存。我写这篇文章所用的笔记本电脑只有区区 32KiB 的指令缓存。幸运的是,我们可以做得更好。

移除 panic

上一个示例中生成的大部分代码都与设置 panic 以及检查条件有关。但我们并不关心 panic。我们可以简单地承认 PoisonError 并继续执行。如下所示:


        1
2
3
4
5
6
use std::sync::Mutex;
use std::sync::PoisonError;

pub fn check_contents(mutex: &Mutex<i32>) -> i32 {
    *mutex.lock().unwrap_or_else(PoisonError::into_inner)
}
      

        use std::sync::Mutex;
use std::sync::PoisonError;

pub fn check_contents(mutex: &Mutex<i32>) -> i32 {
    *mutex.lock().unwrap_or_else(PoisonError::into_inner)
}
      

这样只生成 68 行汇编代码,好多了,尽管它们全都被内联进了我们的函数。与之前相比,我们摆脱了所有与 panic 相关的代码。仍然存在一些与 mutex 是否被 poisoned 相关的不必要分支,以及在我们函数中跟踪 poisoning 的一点额外操作。我们的函数永远不会 panic,但编译器优化目前还不会移除这里涉及的原子加载和存储。不过,如果你想面向 stable Rust,并且不关心 panic,那么这就是你目前应该做的。

理想情况:完全不处理 poison

在 Rust 当前的 nightly 构建中,存在不会产生任何开销的 non-poisoning mutex。我们可以优化上面的代码来使用它们。


        1
2
3
4
5
6
7
#![feature(nonpoison_mutex)]
#![feature(sync_nonpoison)]
use std::sync::nonpoison::Mutex;

pub fn check_contents(mutex: &Mutex<i32>) -> i32 {
    *mutex.lock()
}
      

        1
2
3
4
5
6
7
      

        #![feature(nonpoison_mutex)]
#![feature(sync_nonpoison)]
use std::sync::nonpoison::Mutex;

pub fn check_contents(mutex: &Mutex<i32>) -> i32 {
    *mutex.lock()
}
      

不需要 unwrap,而且它只生成 34 行汇编代码。这足够短,我可以逐一讲解。


        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
example[da70a55c1c00d324]::check_contents:
        push    rbp
        push    rbx
        push    rax
        xor     ebp, ebp
        mov     ecx, 1
        xor     eax, eax
        lock    cmpxchg dword ptr [rdi], ecx ; (1) 检查 mutex 是否被持有,如果没有,则占用它
        jne     .contended ; (2) mutex 不为零,跳转到争用情况
        mov     eax, dword ptr [rdi + 4] ;  (4) 如果没有,加载值
        xchg    dword ptr [rdi], ebp ; (5) 解锁 mutex
        cmp     ebp, 2 ; (6) 检查是否有其他线程在等待
        je      .exit_with_threads_waiting
.fast_exit:
        add     rsp, 8
        pop     rbx
        pop     rbp
        ret
.contended:
        mov     rbx, rdi
        call    qword ptr [rip + <std[3ebc094a278a8d54]::sys::sync::mutex::futex::Mutex>::lock_contended@GOTPCREL] ; (3) 执行 spin/futex_wait 循环
        mov     rdi, rbx ;
        mov     eax, dword ptr [rdi + 4] ; (4) 加载值
        xchg    dword ptr [rdi], ebp ; (5) 解锁 mutex
        cmp     ebp, 2 ; (6) 检查是否有其他线程在等待
        jne     .fast_exit
.exit_with_threads_waiting:
        mov     ebx, eax
        call    qword ptr [rip + <std[3ebc094a278a8d54]::sys::sync::mutex::futex::Mutex>::wake@GOTPCREL] ; (7) 唤醒休眠的线程
        mov     eax, ebx
        add     rsp, 8
        pop     rbx
        pop     rbp
        ret
      

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
      

        example[da70a55c1c00d324]::check_contents:
        push    rbp
        push    rbx
        push    rax
        xor     ebp, ebp
        mov     ecx, 1
        xor     eax, eax
        lock    cmpxchg dword ptr [rdi], ecx ; (1) 检查互斥锁是否被持有,若未被持有则将其占用
        jne     .contended ; (2) 互斥锁不为零,跳转到竞争处理分支
        mov     eax, dword ptr [rdi + 4] ;  (4) 否则,加载值
        xchg    dword ptr [rdi], ebp ; (5) 解锁互斥锁
        cmp     ebp, 2 ; (6) 检查是否有其他线程在等待
        je      .exit_with_threads_waiting
.fast_exit:
        add     rsp, 8
        pop     rbx
        pop     rbp
        ret
.contended:
        mov     rbx, rdi
        call    qword ptr [rip + <std[3ebc094a278a8d54]::sys::sync::mutex::futex::Mutex>::lock_contended@GOTPCREL] ; (3) 执行自旋/futex_wait 循环
        mov     rdi, rbx ;
        mov     eax, dword ptr [rdi + 4] ; (4) 加载值
        xchg    dword ptr [rdi], ebp ; (5) 解锁互斥锁
        cmp     ebp, 2 ; (6) 检查是否有其他线程在等待
        jne     .fast_exit
.exit_with_threads_waiting:
        mov     ebx, eax
        call    qword ptr [rip + <std[3ebc094a278a8d54]::sys::sync::mutex::futex::Mutex>::wake@GOTPCREL] ; (7) 唤醒睡眠的线程
        mov     eax, ebx
        add     rsp, 8
        pop     rbx
        pop     rbp
        ret
      

我给这段汇编加上了注释和标签,好让(加)解锁流程图中各个步骤变得可见。就汇编代码而言,它非常易读且简单。当然,这正是一段基础库代码所应有的样子。

额外的中毒状态检查逻辑、为互斥锁 guard 添加析构函数,以及(如果你选择 ergonomics)甚至 panic 机制,都会让一个相当基础的操作的代码显著膨胀。

可读性与好习惯

除了“中毒会让所有代码比需要的更大、更慢”这一纯技术性论据之外,还有一个不同的论据。如前所述,不关心互斥锁中毒的代码一般应该写成:


        1
my_mutex.lock().unwrap_or_else(PoisonError::into_inner)
      

        my_mutex.lock().unwrap_or_else(PoisonError::into_inner)
      

它相当高效,并且在 stable Rust 上可用。但整个 unwrap_or_else 部分占了半行多。你可能会说,别担心,我们可以把它写短一点:


        1
my_mutex.lock().unwrap()
      

        my_mutex.lock().unwrap()
      

这样也足够好用。它比前一个例子效率低,但简短又漂亮。如果你的代码从不 panic,它甚至完全安全。你可能已经注意到那个起关键作用的“如果”了。要保证你的代码不 panic 是挺难的。数组索引、整数除法,以及一大堆其他特性都可能意外 panic。

这对有经验的开发者来说都很难,对初学者来说就更糟了。它还会养成坏习惯。每次一个 Rust 初学者写下 unwrap() 而不是处理错误时,就会有一只小狗踩到乐高积木。或者引发一场大范围的互联网故障。两者之一,我忘了是哪个。

我们不应该把那种返回“预期”会被 unwrap 的 Result 的 API 纳入标准库。不会失败的操作就不应该失败。

不一致性

中毒机制防止任务在不变量被破坏的过程中 panic。但为什么这必须只有互斥锁才有?前面的例子用一个简单的可变借用同样成立。panic 仍可能发生,你仍可能捕获它们。


        1
2
3
4
5
6
7
8
9
10
fn important2(always_even: &mut i32) -> i32 {
    // 不变量:always_even 必须始终为偶数
    *always_even += 1;

risky_operation();

*always_even += 1;

*always_even
}
      

        1
2
3
4
5
6
7
8
9
10
      

        fn important2(always_even: &mut i32) -> i32 {
    // 不变量:always_even 必须始终为偶数
    *always_even += 1;

risky_operation();

*always_even += 1;

*always_even
}
      

这其实是个相当常见的问题。在最近的一篇博客文章中,微软的研究人员指出了他们发现的多个地方,即便是标准库也把这件事做错了。

不过在大多数情况下这没什么问题,就像开头给出的 mutex 示例那样。你并不需要对这个引用做中毒处理。但对于确实需要中毒处理的应用来说,能拥有这个能力是挺好的。

不难想象可以做一个包装器,在你需要的时候为它加上中毒行为。关键在于,这必须是一个加法式的包装器。你可以给某个东西加上中毒系统。你无法从一个本就带有中毒系统的原语中把它剥离出去。中毒安全对于需要它的特定用例很重要,但大多数用例并不需要。

我不认为值得专门让 mutex 背负这种开销,毕竟这个问题在几乎任何可变状态上都普遍存在。状态不变量的难处就在于此。

与边界检查的对比

人们可能会把中毒安全和缓冲区安全做个对比。在 Rust 中,我们总是做边界检查,依靠编译器在能够证明冗余的情况下把它优化掉。中毒安全不也可以这样吗?答案是不行。

编译器无法把中毒优化掉。它要求每个 mutex 都携带额外的数据来追踪它。也许编译器能判断出某个临界区不会 panic,因而可以省去设置和清理,但通常情况下它无法避免检查状态。这是始终存在的开销,而且会带来损害,尤其是在代码体积受限的环境中。

事实上的标准变通方案

在 C++ 中,标准里有几个选择会让某些容器的效率低于它们本可以达到的水平4。由于标准化的工作方式,这些容器永远无法被“修复”。这导致第三方实现(如 Abseil 和 Boost)成为事实上的标准。

Rust 中的 mutex 也面临同样的问题。标准库带中毒机制,但人们不想要中毒,于是转而选择 parking_lot 之类的 crate。我认为这对整个生态是有害的。当标准库提供一个特性时,它应当是一个毫无争议的好选择,除非你在做极其特殊的事情。我们不必做到“开箱即用”,但已有的部分应当合适。

结论

我写这篇博客,最初是为了回应一场想要改变 Rust 中 mutex 默认行为的运动。在我看来存在三个阵营:

  • 维持现状。std::sync::Mutex 及其同类将带有中毒机制。
  • 让 std::sync::Mutex 在中毒时传播 panic。
  • 增加一个不带中毒的变体 std::sync::nonpoison::Mutex
  • 用 std::sync::nonpoison::Mutex 替换 std::sync::Mutex。中毒变为可选。

Rain 的博客主张选项 1。我相信我们都同意选项 2 是个糟糕的主意。我认为至少应当做选项 3。选项 4 会是一个不错的 edition 改进,但它也是一个重大的兼容性问题,就连我也很难论证它真的值得。

绕了一大圈,其实就是说:我们真的应该稳定 std::sync::nonpoison,而且绝对不应该让 std::sync::Mutex 默认 panic。

  • 我越来越明显地意识到,我就是喜欢解释 mutex,而我不知道该拿这一点怎么办。↩︎
  • Fast Userspace muTEX。关于该系统调用的更多信息见 futex(2),关于其语义见 futex(7) ↩︎
  • 对于泛型定义(例如 Mutex<T>),编译器必须为每个被使用的具体 T 生成代码,而且由于种种原因,往往每个 T 不止生成一次。编译器开发文档对单态化有更深入的解释。↩︎
  • 一个著名的例子是 std::unordered_map,它因被过度规定而无法采用更高效的实现。↩︎

The translation is machine-generated and individual terms may be off. Nothing is rewritten or cut; the original is authoritative.

Published by Lobsters
This site only summarises and aggregates; copyright stays with the original author. Headlines and summaries follow the source — where they differ, the original wins.
Read the original ↗