之前一段时间偶然在 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++ 内存模型知识的一块拼图。