之前一段时间偶然在 B 站上刷到了南京大学蒋炎岩（jyy）老师在直播操作系统网课。点进直播间看了一下发现这个老师实力非凡，上课从不照本宣科，而且旁征博引又不吝于亲自动手演示，于是点了关注。后来开始看其网课录播，其中一节的标题吸引了我，多处理器编程：从入门到放弃 (线程库；现代处理器和宽松内存模型)。“多处理器编程”这个词让我联想到去年看的《The Art of Multiprocessor Programming》，于是仔细看了一下这节网课。里面介绍到了一个试例 write_x_read_y，它是用 C 语言和内联汇编写的，它用来说明运行期指令重排。这个试例能够成功观测到运行期指令重排现象。这让我不得不佩服 jyy 的实践精神。之前看了一些介绍 C++ 内存模型的文章，没有一个能用可复现的完整代码说明问题的，全部都是说这段代码可能出现 xx 结果，没有实际的执行结果。在 C++ 内存模型中，这个测试用例除了能够说明运行期指令重排，也能用于说明 happens-before consistency 和 sequential consistency 的差别。于是尝试用 C++ Atomic 来实现这段代码，看看能不能观测到预期结果。
首先线程库 pthread 替换为 std::thread，内联汇编替换为 std::atomic，且 load 和 store 操作全部使用最弱的 std::memory_order_relaxed 内存序。完整的代码如下：
// write_x_read_y.cpp
#include <atomic>
#include <thread>
#include <stdio.h>
static std::atomic_int flag{0};
inline void wait_flag(int id)
{
while (!(flag & (0x1 << id))) {}
}
inline void clear_flag(int id)
{
flag.fetch_and(~(0x1 << id));
}
std::atomic_int x{0}, y{0};
void write_x_read_y()
{
while (true) {
wait_flag(0);
x.store(1, std::memory_order_relaxed); // t1.1
int v = y.load(std::memory_order_relaxed); // t1.2
printf("%d ", v);
clear_flag(0);
}
}
void write_y_read_x()
{
while (true) {
wait_flag(1);
y.store(1, std::memory_order_relaxed); // t2.1
int v = x.load(std::memory_order_relaxed); // t2.2
printf("%d ", v);
clear_flag(1);
}
}
int main()
{
std::thread t1(write_x_read_y), t2(write_y_read_x);
while (true) {
x = 0, y = 0;
flag = 0b11;
while (flag) {}
printf("\n");
fflush(stdout);
}
t1.join();
t2.join();
}
注意这段代码要开启代码优化才能观测到运行期指令重排，这里选择 O2
g++ -o write_x_read_y.out -O2 -pthread -std=c++11 -Wall -Wextra write_x_read_y.cpp
然后使用 jyy 视频里使用的 Unix 命令进行测试并整理结果
./write_x_read_y.out | head -n1000000 | sort | uniq -c
以下结果是在虚拟机环境中执行得到的。宿主机 CPU 型号为 AMD Ryzen 7 5800X，OS 为 Windows 10 x64，虚拟机是 Rocky Linux 8.6。
948739 0 0
50150 0 1
1109 1 0
2 1 1
成功观测到“0 0”。假设程序按照简单交叉执行，执行结果只可能是“0 1”、“1 0”、“1 1”这三种，不可能出现“0 0”。也就是说发生了运行期指令重排。
接下来，将 std::memory_order_relaxed 替换为 std::memory_order_release 和 std::memory_order_acquire，再测一遍
x.store(1, std::memory_order_release); // t1.1
int v = y.load(std::memory_order_acquire); // t1.2
printf("%d ", v);
y.store(1, std::memory_order_release); // t2.1
int v = x.load(std::memory_order_acquire); // t2.2
printf("%d ", v);
测试结果为：
613684 0 0
360557 0 1
25757 1 0
2 1 1
又出现了“0 0”，也就说明这个试例无法区分 relaxed memory model 和 happens-before consistency。这也与理论相符，虽然 t1.1 happens-before t2.2、t2.1 happens-before t1.2，但是却无法借此推导出约束关系来限制执行结果。“0 0”依然有可能出现。
接下来替换为 std::memory_order_seq_cst
x.store(1, std::memory_order_seq_cst); // t1.1
int v = y.load(std::memory_order_seq_cst); // t1.2
printf("%d ", v);
y.store(1, std::memory_order_seq_cst); // t2.1
int v = x.load(std::memory_order_seq_cst); // t2.2
printf("%d ", v);
测试结果为：
132394 0 1
151 1 0
867455 1 1
这次“0 0”并没有出现，运行期指令重排没有被观测到。这与理论相符，使用 std::memory_order_seq_cst 的所有原子操作可以视为简单交叉执行，也就是 sequential consistency。“0 0”不可能出现。
write_x_read_y 这个试例很好地说明了 C++ 内存模型中的 happens-before consistency 和 sequential consistency 的区别。它的代码片段常见于各种相关文章中，却没有完整的代码和实际的测试结果。这下也算补全了 C++ 内存模型知识的一块拼图。
