Question

AFAIK C ++原子（<atomic>）系列提供3个好处：

原始指令不可分割性（无脏读），
内存排序（包括CPU和编译器）和
跨线程可见性/更改传播。

我不确定第三个子弹，因此请看下面的例子。

#include <atomic>

std::atomic_bool a_flag = ATOMIC_VAR_INIT(false);
struct Data {
    int x;
    long long y;
    char const* z;
} data;

void thread0()
{
    // due to "release" the data will be written to memory
    // exactly in the following order: x -> y -> z
    data.x = 1;
    data.y = 100;
    data.z = "foo";
    // there can be an arbitrary delay between the write 
    // to any of the members and it's visibility in other 
    // threads (which don't synchronize explicitly)

    // atomic_bool guarantees that the write to the "a_flag"
    // will be clean, thus no other thread will ever read some
    // strange mixture of 4bit + 4bits
    a_flag.store(true, std::memory_order_release);
}

void thread1()
{
    while (a_flag.load(std::memory_order_acquire) == false) {};
    // "acquire" on a "released" atomic guarantees that all the writes from 
    // thread0 (thus data members modification) will be visible here
}

void thread2()
{
    while (data.y != 100) {};
    // not "acquiring" the "a_flag" doesn't guarantee that will see all the 
    // memory writes, but when I see the z == 100 I know I can assume that 
    // prior writes have been done due to "release ordering" => assert(x == 1)
}

int main()
{
    thread0(); // concurrently
    thread1(); // concurrently
    thread2(); // concurrently

    // join

    return 0;
}

首先，请在代码中验证我的假设（尤其是thread2）。

其次，我的问题是：

a_flag写入如何传播到其他核心？
std::atomic是否将编写器缓存中的a_flag与其他核心缓存同步（使用MESI或其他任何内容），或者传播是自动的？
假设在特定机器上对标志的写入是原子的（想想x86上的int_32）并且我们没有任何私有内存来同步（我们只有一个标志）我们需要使用原子吗？
考虑到最流行的CPU架构（x86，x64，ARM v.whatever，IA-64），跨核可见性（我现在不考虑重新排序）是自动的（但可能会延迟），或者您需要发出特定命令来传播任何数据？

Answer 1

核心本身并不重要。问题是“所有内核最终如何看到相同的内存更新”，这是您的硬件为您所做的事情（例如缓存一致性协议）。只有一个内存，因此主要关注的是缓存，这是硬件的私密问题。
这个问题似乎不清楚。重要的是由a_flag的加载和存储形成的获取 - 释放对，这是一个同步点并导致thread0和thread1的效果按特定顺序出现（即商店发生之前thread0中的所有内容 - 在<{1}}中循环后的所有内容。
是的，否则您将没有同步点。
在C ++中不需要任何“命令”。 C ++甚至没有意识到它在任何特定类型的CPU上运行。你可以用一个想象力在魔方上运行一个C ++程序。 C ++ 编译器选择必要的指令来实现C ++内存模型描述的同步行为，并在x86上选择发出指令锁前缀和内存栅栏，以及不重新排序指令。由于x86具有强排序的内存模型，因此与没有原子的天真的，不正确的代码相比，上面的代码应该产生最少的附加代码。
在代码中使用thread1会使整个程序处于未定义的行为。

只是为了好玩，并且为了表明找出适合自己的事情可以起到启发作用，我编写了三种不同的代码。（我添加了一个glbbal thread2，在int x我添加了thread1）。

获取/发布（您的代码）

x = data.y;

顺序一致：（删除显式排序）

thread0:
    mov DWORD PTR data, 1
    mov DWORD PTR data+4, 100
    mov DWORD PTR data+8, 0
    mov DWORD PTR data+12, OFFSET FLAT:.LC0
    mov BYTE PTR a_flag, 1
    ret

thread1:
.L14:
    movzx   eax, BYTE PTR a_flag
    test    al, al
    je  .L14
    mov eax, DWORD PTR data+4
    mov DWORD PTR x, eax
    ret

“天真”：（仅使用thread0: mov eax, 1 mov DWORD PTR data, 1 mov DWORD PTR data+4, 100 mov DWORD PTR data+8, 0 mov DWORD PTR data+12, OFFSET FLAT:.LC0 xchg al, BYTE PTR a_flag ret thread1: .L14: movzx eax, BYTE PTR a_flag test al, al je .L14 mov eax, DWORD PTR data+4 mov DWORD PTR x, eax ret）

bool

正如你所看到的，没有太大的区别。 “错误”版本实际上看起来大多正确，除了缺少负载（它使用带内存操作数的thread0: mov DWORD PTR data, 1 mov DWORD PTR data+4, 100 mov DWORD PTR data+8, 0 mov DWORD PTR data+12, OFFSET FLAT:.LC0 mov BYTE PTR a_flag, 1 ret thread1: cmp BYTE PTR a_flag, 0 jne .L3 .L4: jmp .L4 .L3: mov eax, DWORD PTR data+4 mov DWORD PTR x, eax ret）。顺序一致的版本隐藏了cmp指令的昂贵性，该指令具有隐式锁定前缀，并且似乎不需要任何明确的栅栏。

C ++原子和跨线程可见性

1 个答案: