Cache coherency

Cacheability

Normal memory 可以設置為 cacheable 或 non-cacheable，可以按 inner 和 outer 分別設置。

Shareability

設置為 non-shareable 則該段內存只給一個(gè)特定的核使用，設置為 inner shareable 或 outer shareable 則可以被其它觀(guān)測者訪(fǎng)問(wèn)（其它核、GPU、DMA 設備），inner 和 outer 的區別是要求 cache coherence 的范圍，inner 觀(guān)測者和 outer 觀(guān)測者的劃分是 implementation defined。

PoC & PoU

當 clean 或 invalidate cache 的時(shí)候，可以操作到特定的 cache 級別，具體地，可以到下面兩個(gè)“點(diǎn)”：

Point of coherency（PoC）：保證所有能訪(fǎng)問(wèn)內存的觀(guān)測者（CPU 核、DSP、DMA 設備）能看到一個(gè)內存地址的同一份拷貝的“點(diǎn)”，一般是主存。

Point of unification（PoU）：保證一個(gè)核的 icache、dcache、MMU（TLB）看到一個(gè)內存地址的同一份拷貝的“點(diǎn)”，例如 unified L2 cache 是下圖中的核的 PoU，如果沒(méi)有 L2 cache，則是主存。

當說(shuō)“invalidate icache to PoU”的時(shí)候，是指 invalidate icache，使下次訪(fǎng)問(wèn)時(shí)從 L2 cache（PoU）讀取。

PoU 的一個(gè)應用場(chǎng)景是：運行的時(shí)候修改自身代碼之后，使用兩步來(lái)刷新 cache，首先，clean dcache 到 PoU，然后 invalidate icache 到 PoU。

Memory consistency

ARMv8-A 采用弱內存模型，對 normal memory 的讀寫(xiě)可能亂序執行，頁(yè)表里可以配置為 non-reordering（可用于 device memory）。

Normal memory：RAM、Flash、ROM in physical memory，這些內存允許以弱內存序的方式訪(fǎng)問(wèn)，以提高性能。

單核單線(xiàn)程上連續的有依賴(lài)的 str 和 ldr 不會(huì )受到弱內存序的影響，比如：

str x0, [x2]
ldr x1, [x2]

Barriers

ISB

刷新當前 PE 的 pipeline，使該指令之后的指令需要重新從 cache 或內存讀取，并且該指令之后的指令保證可以看到該指令之前的 context changing operation，具體地，包括修改 ASID、TLB 維護指令、修改任何系統寄存器。

DMB

保證所指定的 shareability domain 內的其它觀(guān)測者在觀(guān)測到 dmb 之后的數據訪(fǎng)問(wèn)之前觀(guān)測到 dmb 之前的數據訪(fǎng)問(wèn)：

str x0, [x1]
dmb
str x2, [x3] // 如果觀(guān)測者看到了這行 str，則一定也可以看到第 1 行 str

同時(shí)，dmb 還保證其后的所有數據訪(fǎng)問(wèn)指令能看到它之前的 dcache 或 unified cache 維護操作：

dc csw, x5
ldr x0, [x1] // 可能看不到 dcache clean
dmb ish
ldr x2, [x3] // 一定能看到 dcache clean

DSB

保證和 dmb 一樣的內存序，但除了訪(fǎng)存操作，還保證其它任何后續指令都能看到前面的數據訪(fǎng)問(wèn)的結果。

等待當前 PE 發(fā)起的所有 cache、TLB、分支預測維護操作對指定的 shareability domain 可見(jiàn)。

可用于在 sev 指令之前保證數據同步。

一個(gè)例子：

str x0, [x1] // update a translation table entry
dsb ishst // ensure write has completed
tlbi vae1is, x2 // invalidate the TLB entry for the entry that changes
dsb ish // ensure that TLB invalidation is complete
isb // synchronize context on this processor

DMB & DSB options

dmb 和 dsb 可以通過(guò) option 指定 barrier 約束的訪(fǎng)存操作類(lèi)型和 shareability domain：

One-way barriers

• Load-Acquire (LDAR): All loads and stores that are after an LDAR in program order, and that match the shareability domain of the target address, must be observed after the LDAR.
• Store-Release (STLR): All loads and stores preceding an STLR that match the shareability domain of the target address must be observed before the STLR.
• LDAXR
• STLXR

Unlike the data barrier instructions, which take a qualifier to control which shareability domains see the effect of the barrier, the LDAR and STLR instructions use the attribute of the address accessed.

C++ & Rust memory order

Relaxed

Relaxed 原子操作只保證原子性，不保證同步語(yǔ)義。

// Thread 1:
r1 = y.load(std::memory_order_relaxed); // A
x.store(r1, std::memory_order_relaxed); // B

// Thread 2:
r2 = x.load(std::memory_order_relaxed); // C
y.store(42, std::memory_order_relaxed); // D

上面代碼在 ARM 上編譯后使用 str 和 ldr 指令，可能被亂序執行，有可能最終產(chǎn)生 r1 == r2 == 42 的結果，即 A 看到了 D，C 看到了 B。

典型的 relaxed ordering 的使用場(chǎng)景是簡(jiǎn)單地增加一個(gè)計數器，例如 std::shared_ptr 中的引用計數，只需要保證原子性，沒(méi)有 memory order 的要求。

Release-acquire

Rel-acq 原子操作除了保證原子性，還保證使用 release 的 store 和使用 acquire 的 load 之間的同步，acquire 時(shí)必可以看到 release 之前的指令，release 時(shí)必看不到 acquire 之后的指令。

#include < thread >
#include < atomic >
#include < cassert >
#include < string >

std::atomic< std::string * > ptr;
int data;

void producer() {
    std::string *p = new std::string("Hello");
    data = 42;
    ptr.store(p, std::memory_order_release);
}

void consumer() {
    std::string *p2;
    while (!(p2 = ptr.load(std::memory_order_acquire)))
        ;
    assert(*p2 == "Hello"); // never fires
    assert(data == 42); // never fires
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join(); t2.join();
}

上面代碼中，一旦 consumer 成功 load 到了 ptr 中的非空 string 指針，則它必可以看到 data = 42 這個(gè)寫(xiě)操作。

這段代碼在 ARM 上會(huì )編譯成使用 stlr 和 ldar ，但其實(shí) C++ 所定義的語(yǔ)義比 stlr 和 ldar 實(shí)際提供的要弱，C++ 只保證使用了 release 和 acquire 的兩個(gè)線(xiàn)程間的同步。

典型的 rel-acq ordering 的使用場(chǎng)景是 mutex 或 spinlock，當釋放鎖的時(shí)候，釋放之前的臨界區的內存訪(fǎng)問(wèn)必須都保證對同時(shí)獲取鎖的觀(guān)測者可見(jiàn)。

Release-consume

和 rel-acq 相似，但不保證 consume 之后的訪(fǎng)存不會(huì )在 release 之前完成，只保證 consume 之后對 consume load 操作有依賴(lài)的指令不會(huì )被提前，也就是說(shuō) consume 之后不是臨界區，而只是使用 release 之前訪(fǎng)存的結果。

Note that currently (2/2015) no known production compilers track dependency chains: consume operations are lifted to acquire operations.

#include < thread >
#include < atomic >
#include < cassert >
#include < string >

std::atomic< std::string * > ptr;
int data;

void producer() {
    std::string *p = new std::string("Hello");
    data = 42;
    ptr.store(p, std::memory_order_release);
}

void consumer() {
    std::string *p2;
    while (!(p2 = ptr.load(std::memory_order_consume)))
        ;
    assert(*p2 == "Hello"); // never fires: *p2 carries dependency from ptr
    assert(data == 42); // may or may not fire: data does not carry dependency from ptr
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join(); t2.join();
}

上面代碼中，由于 assert(data == 42) 不依賴(lài) consume load 指令，因此有可能在 load 到非空指針之前執行，這時(shí)候不保證能看到 release store，也就不保證能看到 data = 42 。

Sequentially-consistent

Seq-cst ordering 和 rel-acq 保證相似的內存序，一個(gè)線(xiàn)程的 seq-cst load 如果看到了另一個(gè)線(xiàn)程的 seq-cst store，則必可以看到 store 之前的指令，并且 load 之后的指令不會(huì )被 store 之前的指令看到，同時(shí)，seq-cst 還保證每個(gè)線(xiàn)程看到的所有 seq-cst 指令有一個(gè)一致的 total order。

典型的使用場(chǎng)景是多個(gè) producer 多個(gè) consumer 的情況，保證多個(gè) consumer 能看到 producer 操作的一致 total order。

#include < thread >
#include < atomic >
#include < cassert >

std::atomic< bool > x = {false};
std::atomic< bool > y = {false};
std::atomic< int > z = {0};

void write_x() {
    x.store(true, std::memory_order_seq_cst);
}

void write_y() {
    y.store(true, std::memory_order_seq_cst);
}

void read_x_then_y() {
    while (!x.load(std::memory_order_seq_cst))
        ;
    if (y.load(std::memory_order_seq_cst)) {
        ++z;
    }
}

void read_y_then_x() {
    while (!y.load(std::memory_order_seq_cst))
        ;
    if (x.load(std::memory_order_seq_cst)) {
        ++z;
    }
}

int main() {
    std::thread a(write_x);
    std::thread b(write_y);
    std::thread c(read_x_then_y);
    std::thread d(read_y_then_x);
    a.join(); b.join(); c.join(); d.join();
    assert(z.load() != 0); // will never happen
}

上面的代碼中，read_x_then_y 和 read_y_then_x 不可能看到相反的 x 和 y 的賦值順序，所以必至少有一個(gè)執行到 ++z 。

Seq-cst 和其它 ordering 混用時(shí)可能出現不符合預期的結果，如下面例子中，對 thread 1 來(lái)說(shuō)，A sequenced before B，但對別的線(xiàn)程來(lái)說(shuō)，它們可能先看到 B，很遲才看到 A，于是 C 可能看到 B，得到 r1 = 1 ，D 看到 E，得到 r2 = 3 ，F 看不到 A，得到 r3 = 0 。

// Thread 1:
x.store(1, std::memory_order_seq_cst); // A
y.store(1, std::memory_order_release); // B

// Thread 2:
r1 = y.fetch_add(1, std::memory_order_seq_cst); // C
r2 = y.load(std::memory_order_relaxed); // D

// Thread 3:
y.store(3, std::memory_order_seq_cst); // E
r3 = x.load(std::memory_order_seq_cst); // F