相关疑难解决方法(0)

一般地,对于int num,num++(或++num),作为读-修改-写操作中,是不是原子.但我经常看到编译器,例如GCC,为它生成以下代码(在这里尝试):

由于第5行对应于num++一条指令,我们可以得出结论,在这种情况下num++ 是原子的吗？

如果是这样,是否意味着如此生成num++可以在并发(多线程)场景中使用而没有任何数据争用的危险(例如,我们不需要制作它,std::atomic<int>并强加相关成本,因为它是无论如何原子)？

UPDATE

请注意,这个问题不是增量是否是原子的(它不是,而且是问题的开头行).它是否可以在特定场景中,即在某些情况下是否可以利用单指令性质来避免lock前缀的开销.而且,作为公认的答案约单处理器的机器,还有部分提到这个答案,在其评论和其他人谈话解释,它可以(尽管不是C或C++).

关于多核CPU或多处理器系统中使用的高速缓存存储器,我有几个问题.(虽然与编程没有直接关系,但是当一个人为多核处理器/多处理器系统编写软件时会产生很多反响,因此在这里问!)

1. 在多处理器系统或多核处理器(Intel Quad Core,Core two Duo等......)中,每个cpu核心/处理器都有自己的缓存(数据和程序缓存)吗？

2. 一个处理器/核心可以访问彼此的高速缓存,因为如果允许它们访问彼此的高速缓存,那么我认为可能存在较少的高速缓存未命中,如果特定处理器高速缓存没有一些数据但是其他一些处理器的缓存可能有它,从而避免从内存读入第一个处理器的缓存？这个假设是否有效且真实？

3. 允许任何处理器访问其他处理器的高速缓冲存储器会有任何问题吗？

任何人都可以解释什么是加载缓冲区以及它与失效队列的不同之处.以及存储缓冲区和写入组合缓冲区之间的区别？Paul E Mckenny的论文http://www.rdrop.com/users/paulmck/scalability/paper/whymb.2010.07.23a.pdf 很好地解释了存储缓冲区和失效队列,但不幸的是没有谈到写入组合缓冲区

在大多数处理器中,为什么L1缓存的大小小于L2缓存的大小？

处理器x86/x86_64中使用哪种寻址在L1,L2和L3(LLC)中进行缓存 - 物理或虚拟(使用PT/PTE和TLB)以及PAT(页面属性表)对它有何影响？

在这种情况下,驱动程序(内核空间)和应用程序(用户空间)之间是否存在差异？

简短回答 - 英特尔使用虚拟索引,物理标记(VIPT)L1缓存:线程之间的数据交换将用于在具有HT的一个Core上执行什么？

• L1 - 虚拟寻址(在8-way用于定义的高速缓存中Set需要低12 bits,这在virt和phys中是相同的)
• L2 - 物理寻址(需要访问Virt-2-Phys的TLB)
• L3 - 物理寻址(需要访问Virt-2-Phys的TLB)

单个进程中的两个不同线程可以通过读取和/或写入来共享公共存储器位置.

通常,这种(有意)共享是使用lockx86上的前缀使用原子操作实现的,该前缀对于lock前缀本身(即,无竞争成本)具有相当广为人知的成本,并且当实际共享高速缓存行时还具有额外的一致性成本(真或假共享).

在这里,我对生产 - 消费者成本感兴趣,其中单个线程P写入内存位置,另一个线程`C从内存位置读取,都使用普通读取和写入.

在同一个套接字上的不同内核上执行此类操作的延迟和吞吐量是多少,并且在最近的x86内核上在同一物理内核上执行兄弟超线程时进行比较.

在标题中,我使用术语"超级兄弟"来指代在同一核心的两个逻辑线程上运行的两个线程,以及核心间兄弟,以指代在不同物理核心上运行的两个线程的更常见情况.

在英特尔优化手册似乎对存储缓冲区的数量存在于处理器的许多地方,但谈判没有谈存储缓冲区的大小.这是公共信息还是商店缓冲区的大小保留为微架构细节？

我正在研究的处理器主要是Broadwell和Skylake,但其他人的信息也不错.

另外,存储缓冲区究竟做了什么？

超线程是否允许使用 L1 缓存在两个线程之间交换数据，这两个线程在单个物理内核上同时执行，但在两个虚拟内核中？

前提是两者都属于同一个进程，即在同一个地址空间中。

第 85 页 (2-55) -英特尔® 64 位和 IA-32 架构优化参考手册：http : //www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia- 32-architectures-optimization-manual.pdf

2.5.9 英特尔® 微架构代号 Nehalem 中的超线程技术支持

...

更深的缓冲和增强的资源共享/分区策略：

• HT 操作的复制资源：寄存器状态、重命名的返回堆栈缓冲区、大页面 ITLB。

• HT 操作的分区资源：加载缓冲区、存储缓冲区、重新排序缓冲区、小页面 ITLB 在两个逻辑处理器之间静态分配。

• HT 操作期间竞争性共享的资源：保留站、缓存层次结构、填充缓冲区、DTLB0 和 STLB。

• HT操作时交替：前端操作一般在两个逻辑处理器之间交替，以保证公平性。

• HT 未知资源：执行单元。

与我之前的问题类似，请考虑以下代码

-- Initially --
std::atomic<int> x{0};
std::atomic<int> y{0};

-- Thread 1 --
x.store(1, std::memory_order_release);

-- Thread 2 --
y.store(2, std::memory_order_release);

-- Thread 3 --
int r1 = x.load(std::memory_order_acquire);   // x first
int r2 = y.load(std::memory_order_acquire);

-- Thread 4 --
int r3 = y.load(std::memory_order_acquire);   // y first
int r4 = x.load(std::memory_order_acquire);

是怪异的结果 r1==1, r2==0，并r3==2, r4==0有可能在C ++ 11内存模型下，这种情况下？如果我要全部替换std::memory_order_acq_rel成该std::memory_order_relaxed怎么办？

在x86上，这样的结果似乎是被禁止的，请参见此SO问题，但我一般是在询问C ++ 11内存模型。

奖励问题：

我们都同意，与std::memory_order_seq_cst该怪异的结果不会在C ++ 11被允许。现在，赫伯·萨特（Herb Sutter）在他著名的- …

我看到g ++生成一个简单的movfor x.load()和mov+ mfencefor x.store(y).考虑这个经典的例子:

#include<atomic>
#include<thread>
std::atomic<bool> x,y;
bool r1;
bool r2;
void go1(){
    x.store(true);
}
void go2(){
    y.store(true);
}
bool go3(){
    bool a=x.load();
    bool b=y.load();
    r1 = a && !b;
}
bool go4(){
    bool b=y.load();
    bool a=x.load();
    r2= b && !a;
}





int main() {
    std::thread t1(go1);
    std::thread t2(go2);
    std::thread t3(go3);
    std::thread t4(go4);
    t1.join();
    t2.join();
    t3.join();
    t4.join();
    return r1*2 + r2;
}

其中根据https://godbolt.org/z/APS4ZY go1和go2被翻译成

go1():
        mov     BYTE PTR x[rip], 1 …

我在 Windows 7 64 位、VS2013（x64 发行版本）上尝试内存排序。我想使用最快的同步来共享对容器的访问。我选择了原子比较和交换。

我的程序产生两个线程。写入器推送到向量，读取器检测到这一点。

最初我没有指定任何内存排序，所以我假设它使用memory_order_seq_cst?

每个操作的memory_order_seq_cst延迟为 340-380 个周期。

为了尝试提高性能，我让商店使用memory_order_release并加载使用memory_order_acquire。

然而，每个操作的延迟增加到大约 1,940 个周期。

我是不是误会了什么？完整代码如下。

使用默认值memory_order_seq_cst：

#include <iostream>
#include <atomic>
#include <thread>
#include <vector>

std::atomic<bool> _lock{ false };
std::vector<uint64_t> _vec;
std::atomic<uint64_t> _total{ 0 };
std::atomic<uint64_t> _counter{ 0 };
static const uint64_t LIMIT = 1000000;

void writer()
{
    while (_counter < LIMIT)
    {
        bool expected{ false };
        bool val = true;

        if (_lock.compare_exchange_weak(expected, val))
        {
            _vec.push_back(__rdtsc());
            _lock = false;
        } …

众所周知，现代x86_64上的所有缓存L1 / L2 / L3级别都是虚拟索引的，并进行了物理标记。并且所有内核都通过QPI / HyperTransport上的高速缓存一致性协议MOESI / MESIF通过最后一级高速缓存-L3进行通信。

例如，Sandybridge系列CPU具有4至16路高速缓存L3和page_size 4KB，那么这允许在并发进程之间交换数据，并发进程通过共享内存在不同内核上执行。这是可能的，因为高速缓存L3不能同时包含与进程1的页面和与进程2的页面相同的物理内存区域。

这是否意味着每次进程1请求相同的共享内存区域时，进程2会将其页面的缓存行刷新到RAM中，然后进程1加载与页面的缓存行相同的内存区域在process-1的虚拟空间中？真的很慢还是处理器使用了一些优化？

现代的x86_64 CPU是否使用相同的缓存行，而不进行任何刷新，以通过共享内存在具有不同虚拟空间的2个进程之间进行通信？

Sandy Bridge Intel CPU-缓存L3：

• 8 MB-缓存大小
• 64 B-缓存行大小
• 128 K-行（128 K = 8 MB / 64 B）
• 16路
• 8 K-路数集（8 K = 128 K线/ 16路）
• 虚拟地址（索引）的13位[18：6]-定义当前设置号（这是标签）
• 512 K-每个相同（虚拟地址/ 512 K）竞争同一组（8 MB / 16路）

• 低19位-对确定当前设置的数字有效

• 4 KB-标准页面大小

• 仅低12位-每个地址的虚拟和物理地址相同

我们有7个丢失的位[18:12]-即我们需要检查（7 ^ 2 * 16位）= 1024个缓存行。这与1024路缓存相同-因此非常慢。这是否意味着缓存L3（已物理索引，已物理标记）？

标签虚拟地址中丢失位的摘要（页面大小8 KB-12位）：

• L3（8 MB = 64 B x 128 K线），16路，8 K集，13位标签[18：6]-缺少7位
• L2（256 KB = 64 B x 4 …

由于其 TSO 内存模型，X86 保证所有商店的总顺序。我的问题是是否有人知道这是如何实际实施的。

我对所有 4 个围栏是如何实现的印象很好，所以我可以解释如何保留本地秩序。但是 4 个栅栏只会给 PO；它不会给您 TSO（我知道 TSO 允许旧商店跳到新负载前面，因此只需要 4 个围栏中的 3 个）。

单个地址上所有内存操作的总顺序是一致性的责任。但我想知道英特尔（特别是 Skylake）如何在多个地址的商店上实现总订单。