（图来自 CMU 15-418 Spring 2020 和 CS152）

当我们涉及多核的时候，我们的多个核可能会共享一份内存：

单个变量的访问可能会有问题：

我们访问 memory, 可能在直觉上会是：

读到最近一级别存储 x 的上一个写入的值

但是，memory 会遇到的问题是

1. 有 global 的 storage 和 local cache，而且这两个可能是不一致的
   1. 所以我们有 write back 和 write through 的策略，来 trade 性能和 consitent
2. 有多个 local cache 的话，可能也会导致这种视图上的不一致

但是说到底，“读到上一个写入的值”，或者，“写入时间最近的值”，究竟是什么语义呢：

事实上，我们之前介绍过 CPU Cache, 现在给出一个 L1 L2 L3 的视图

显然，现在我们对同一个变量的访问，如上上张图所示，我各个处理器本身是顺序处理的，而它们在一起，会得到一个诡异的偏序，而 P1 P2 P3 的 x 值和内存中的 x 值是 inconsistent 的。这是问题所在：我们无法定义“上一个”逻辑意义上是什么。

要在保证性能的同时，也作出各个处理器对 x 的值读写的偏序保证，我们需要 coherence

Single CPU System: I/O

单核 CPU IO 的时候，假设要读/写数据，可能会：

1. processor 写到了 write-buffer 里，而网卡可能没有读到 buffer 中的数据，而是读到了 memory 中的 stale data，造成写 stale data
2. 网络中数据写到了 memory 中，通知 processor, processor lw 读到了 cache，造成读 stale data

某种意义上说，这也是一种不一致导致的，为了解决这个问题，需要下列的支持

1. CPU 写的时候可以写到和设备的 shared buffer 中，而不是本身的 write buffer。让设备能够读到正确信息
2. OS 可以把读写的 page 设置成不可 cache 的，同时，IO 完成的时候 flush cache page
3. 在生产中，DMA transfer 的频率远比 lw sw 少，所以可以接受代价较高。

Coherence

终于到了 conherence 了，那么我们来讲讲，memory coherence，我必须要说，下面这张图理的绝对很清晰了：

.

1. 单个 Processor 对单个变量 x 的读写是顺序的
2. write propagation: P 对一个变量的写入必须最终对其他 Process 可见
3. write serialization : 写有全局的顺序

以上便是违背 write serialization 的例子，对于 x 写入 “a" "b", P3 P4 观察到的顺序不一致。

那么，在这种假设下，假设有三个线程 t0, t1, t2:

// t0
for (i = 0; i < N; i += 2) {X = i;
}// t1
for (j = 1; j < N; j += 2) {X = j;
}// t3
for (k = 0; k < ..; k++) {s[k] = X;
}

那么，数组 s 中，可以看到我写的脑瘫程序可以输出：

26980 626437 1226236 1806376 2449353 3083919 3382384 3734980 4165338 5994059
4872578 7435291 5586348 8893777 6262932 6539670 6875646 7205346 7535204 7873218
8256550 8658202 14268993 14634249 9901488 10347038 15693957 16119785 16529365 17135341
17836189 12867162 19251979 19962671 13929908 14261510 14598770 22698103 15331624 24051107

这里奇数/偶数都是强 order 的，但是他们之间并没有什么保证，只能保证全局有一致的 order

(题外话：但是我看到这有个问题，就是 atomic + relaxed 和 non-atomic 有什么区别，瞅了眼： https://stackoverflow.com/questions/63810298/what-is-the-difference-between-load-store-relaxed-atomic-and-normal-variable 这似乎保证单个操作的原子性，比如我们 RV32I 的 auipc 和 add...)

关于实现 Cache Coherent，是下一节的内容，我们再次先看 Memory Model 吧。

Memory Consistency

最实用、最有挑战性、最令人困惑的部分来了。我们现在有了变量 x 的 coherence，我们还需要什么呢？

Cache Coherence 保证了单个 cache block 的 loads and stores 是按照定义运行的，但是我们假设有一个 produce-consume:

// produce
value <- 5
flag <- ok// consume
wait until flag is ok
-- 操作 value

那么，很尴尬的是，你会发现 cache coherent 没有提供可靠的保障。

“Memory Consistency Model” (sometimes called “Memory Ordering”): do all loads and stores, even to separate cache blocks, behave correctly?

实际上，你会发现问题的来源很多，而且来源不是上层应用，而是我们讲了2节的 cache write-buffer multi-level cache 这些给我们带来利好的东西，和 OoO 执行、编译器乱序等正常对程序员透明，现在全冒出来了的东西。

Uniprocess Memory Model

单个程序按 program order 的语义执行、读写

这图相当于我们 Part2 说的。

那么，在并行的时候，也就是我们说的 producer-consumer 中，可能会有下图的问题：

write buffer 和 OoO 等乱序不能保证写入会被顺序的传播，没有 happens-before 的语义。

更要命的是，cache 也会在其中添乱：（当然不止是 cache，所以回头来，你要理解到，volatile 这个词在 C/C++ 中是危险的，不能认为它们读写内存就万事大吉了，不过我也不太清楚搞 NVM 的大佬们会不会用到这个）

由于 P3 上有 A 的 cache, 它并不会从内存中读取应读的值，cache coherent 也没被违背，但是这会儿程序的语义就没法保证了！

更要命的是，还有编译器的乱序，关于编译器乱序可以参考没有使用 atomic 的 LevelDB 的 SkipList, 它只是写了一个编译器 barrier，而没有用 CPU 的 barrier 和指令。

Sequential Consistency: SC

这个是老熟人了：

Formalized by Lamport (1979)

• accesses of each processor in program order
• all accesses appear in sequential order

我理解就是简单说所有操作有一个全序，就所有操作偏序变全序。你可以用 seq_cst 来体验一下（

这个时候，写入要求：

For each processor, delay start of memory access until previous one completes: each processor has only one outstanding memory access at a time

读取要求

a read completes when its return value is bound

上述会带来严格的限制和可靠性，但是性能...

只能用悲剧来形容（

于是我们有 relaxed 一些的模型，例如 TSO/PSO 等：

注：x86的 memory model 类似 TSO，只允许 store-load 乱序。

这在优化中获得了权衡：

但是，这个时候，我们仍然要面对最初的那个问题：

// produce
value <- 5
flag <- ok// consume
wait until flag is ok
-- 操作 value

Data Race:

• two conflicting accesses on different processors
• not ordered by intervening accesses

显然，我们对 flag 的操作本身没有经过同步，这个在仅允许 store-load 乱序的系统中，甚至没啥问题（不考虑编译器乱序）。但是，在 RISC-V 这种系统，或者 ARM 里，你就等死吧。我们需要一些机制来同步：

Properly Synchronized Programs:

• all synchronizations are explicitly identified
• all data accesses are ordered through synchronization

我们可以使用：

1. memory barrier
2. 显式的锁，来隐式提供 fence

逻辑如下：

1. x86 的 xchg 显式的帮你完成这一切，你可以 acquire 来获得锁，在互斥区维护 invariant，release 来释放锁。锁前，锁中，锁后都是可以 re-order 的，但是它们不能越过锁。
2. MFENCE LFENCE MFENCE , fence会 stall 程序，把之前的操作执行完，来创建偏序。

上述例子中，fence w, w 和 fence r, r 构建了一个偏序关系。sw data, (xdatap) 保证被 lw xdata, (xdatap) 感知了。

RISC-V 的支持：RV32A

RISC-V 具有宽松的内存一致性模型(relaxed memory consistency model)，因此其他线程看 到的内存访问可以是乱序的。图 6.2 中，所有的 RV32A 指令都有一个请求位(aq)和一个 释放位(rl)。aq 被置位的原子指令保证其它线程在随后的内存访问中看到顺序的 AMO 操 作;rl 被置位的原子指令保证其它线程在此之前看到顺序的原子操作。想要了解更详细的 有关知识，可以查看[Adve and Gharachorloo 1996]。

RV32A 没有直接提供了 CAS FAA 的指令，而是提供了两套指令。RV32A 认为这样有更好的可扩展性：

编译器乱序和语言的 memory_order

https://chromium.googlesource.com/external/leveldb/+/v1.15/port/atomic_pointer.h#61

除了内存，编译器也会完成乱序。最佳的例子是 LevelDB 之前的编译器 barrier。

语言会提供对应的语义，如 C++ 的六种 order （实话说我 consume 那几个完全不懂）: https://en.cppreference.com/w/cpp/atomic/memory_order

或者简单点可以看看 Golang 的（

References

1. CMU 15-418 Spring 2020
2. UCB CS152 Spring 2020
3. CPU Cache and Memory Ordering 何登成
4. RISC-V Reader
5. Computer Organization and Design RISC-V edition
6. 我坦白了，上面的我都没看完（