C++ 11引入了标准化的内存模型.这是什么意思？它将如何影响C++编程？

Question

C++ 11引入了标准化的内存模型,但究竟是什么意思呢？它将如何影响C++编程？

这篇文章(引用Herb Sutter的Gavin Clarke)说,

内存模型意味着C++代码现在有一个标准化的库可以调用,无论是谁编译器以及它运行的平台.有一种标准方法可以控制不同线程与处理器内存的对话方式.

"当你谈论在标准中的不同内核之间分割[代码]时,我们正在谈论内存模型.我们将优化它,而不会破坏人们将在代码中做出的以下假设," Sutter说.

好吧,我可以在网上记住这个和类似的段落(因为我从出生以来就拥有自己的记忆模型:P),甚至可以发布作为其他人提出的问题的答案,但说实话,我并不完全明白这个.

C++程序员以前用于开发多线程应用程序,那么如果它是POSIX线程,Windows线程或C++ 11线程,它又如何重要呢？有什么好处？我想了解低级细节.

我也觉得C++ 11内存模型与C++ 11多线程支持有某种关系,因为我经常将这两者结合在一起.如果是,究竟是怎么回事？他们为什么要相关？

由于我不知道多线程的内部工作原理以及内存模型的含义,请帮助我理解这些概念.:-)

Answer 1

首先,你必须学会​​像语言律师那样思考.

C++规范不引用任何特定的编译器,操作系统或CPU.它引用了一个抽象机器,它是实际系统的概括.在语言律师的世界里,程序员的工作就是为抽象机器编写代码; 编译器的工作是在具体机器上实现该代码.通过严格按照规范进行编码,无论是今天还是50年后,您都可以确定您的代码无需在具有兼容C++编译器的任何系统上进行编译和运行.

C++ 98/C++ 03规范中的抽​​象机器基本上是单线程的.所以不可能编写相对于规范"完全可移植"的多线程C++代码.该规范甚至没有说明内存加载和存储的原子性或加载和存储可能发生的顺序,更不用说像互斥体这样的东西了.

当然,您可以在实践中为特定的具体系统编写多线程代码 - 例如pthreads或Windows.但是没有标准的方法来为C++ 98/C++ 03编写多线程代码.

C++ 11中的抽象机器是设计多线程的.它还有一个定义明确的内存模型 ; 也就是说,它说明了在访问内存时编译器可能会做什么,也可能不会做什么.

请考虑以下示例,其中两个线程同时访问一对全局变量:

           Global
           int x, y;

Thread 1            Thread 2
x = 17;             cout << y << " ";
y = 37;             cout << x << endl;

线程2可能输出什么？

在C++ 98/C++ 03下,这甚至不是Undefined Behavior; 问题本身毫无意义,因为标准没有考虑任何称为"线程"的东西.

在C++ 11下,结果是Undefined Behavior,因为加载和存储通常不需要是原子的.这可能看起来不是很大的改善......而且它本身并非如此.

但是使用C++ 11,你可以这样写:

           Global
           atomic<int> x, y;

Thread 1                 Thread 2
x.store(17);             cout << y.load() << " ";
y.store(37);             cout << x.load() << endl;

现在情况变得更有趣了.首先,定义了此处的行为.线程2现在可以打印0 0(如果它在线程1之前运行),37 17(如果它在线程1之后运行),或者0 17(如果它在线程1分配给x但在它分配给y之前运行).

它无法打印的是37 0,因为C++ 11中原子加载/存储的默认模式是强制执行顺序一致性.这只意味着所有加载和存储必须"好像"它们按照您在每个线程中编写它们的顺序发生,而线程之间的操作可以交错,但系统喜欢.因此,atomics的默认行为为加载和存储提供了原子性和排序.

现在,在现代CPU上,确保顺序一致性可能很昂贵.特别是,编译器可能会在每次访问之间发出完整的内存屏障.但是,如果您的算法可以容忍无序的加载和存储; 即,如果它需要原子性而不是订购; 即,如果它可以容忍37 0这个程序的输出,那么你可以这样写:

           Global
           atomic<int> x, y;

Thread 1                            Thread 2
x.store(17,memory_order_relaxed);   cout << y.load(memory_order_relaxed) << " ";
y.store(37,memory_order_relaxed);   cout << x.load(memory_order_relaxed) << endl;

CPU越现代,就越有可能比前一个例子更快.

最后,如果您只需要按顺序保留特定的加载和存储,您可以编写:

           Global
           atomic<int> x, y;

Thread 1                            Thread 2
x.store(17,memory_order_release);   cout << y.load(memory_order_acquire) << " ";
y.store(37,memory_order_release);   cout << x.load(memory_order_acquire) << endl;

这将我们带回有序的加载和存储 - 因此37 0不再是可能的输出 - 但它以最小的开销实现了这一点.(在这个简单的例子中,结果与完整的顺序一致性相同;在较大的程序中,它不会.)

当然,如果您想要查看的唯一输出是0 0或者37 17,您可以在原始代码周围包装互斥锁.但是如果你已经读过这篇文章了,我打赌你已经知道它是如何工作的,这个答案已经比我预想的要长:-).

所以,底线.互斥体很棒,C++ 11将它们标准化.但有时出于性能原因,您需要较低级别的基元(例如,经典的双重检查锁定模式).新标准提供了高级小工具,如互斥锁和条件变量,它还提供低级小工具,如原子类型和各种内存屏障.因此,现在您可以完全使用标准指定的语言编写复杂的高性能并发例程,并且可以确定您的代码将在今天的系统和未来的系统上编译和运行.

虽然坦率地说,除非您是专家并且正在处理一些严重的低级代码,否则您应该坚持使用互斥锁和条件变量.这就是我打算做的事情.

有关这些内容的更多信息,请参阅此博客文章.

Answer 2

我将简单地给出我理解的内存一致性模型(或简称内存模型)的类比.它的灵感来自Leslie Lamport的开创性论文"时间,时钟和分布式系统中的事件排序".这个比喻很贴切,具有根本意义,但对许多人来说可能有些过分.但是,我希望它提供一个心理图像(图形表示),便于推理内存一致性模型.

让我们在时空图中查看所有存储器位置的历史,其中水平轴表示地址空间(即,每个存储器位置由该轴上的点表示),垂直轴表示时间(我们将看到,一般来说,没有一个普遍的时间概念).因此,每个存储器位置所保持的值的历史由该存储器地址处的垂直列表示.每个值的更改都是由于其中一个线程将新值写入该位置.通过一个存储图像,我们将意味着所有的内存位置观察到的价值的总和/组合在特定的时间由特定线程.

引自"内存一致性和缓存一致性入门"

直观(且限制性最强)的内存模型是顺序一致性(SC),其中多线程执行应该看起来像是每个组成线程的顺序执行的交错,就像线程在单核处理器上进行时间复用一样.

该全局存储顺序可以从程序的一次运行到另一次运行而变化,并且可能事先不知道.SC的特征是地址空间 - 时间图中的水平切片集合表示同时性平面(即,存储器图像).在给定的平面上,其所有事件(或内存值)都是同时的.有一个绝对时间的概念,其中所有线程都同意哪些内存值是同时的.在SC中,在每个时刻,所有线程只共享一个内存映像.也就是说,在每个时刻,所有处理器都同意存储器映像(即存储器的聚合内容).这不仅意味着所有线程都查看所有内存位置的相同值序列,而且所有处理器都观察到所有变量的值的相同组合.这与所有线程以相同的总顺序观察所有内存操作(在所有内存位置上)相同.

在宽松的内存模型中,每个线程将以自己的方式切换地址空间时间,唯一的限制是每个线程的切片不会相互交叉,因为所有线程必须就每个内存位置的历史达成一致(当然,不同线程的切片可以并且将会相互交叉).没有通用的方法可以将其分割(没有特权的地址空间时间).切片不必是平面的(或线性的).它们可以是弯曲的,这可以使线程读取由另一个线程写入的值而不是它们被写入的顺序.不同内存位置的历史可以在任何特定线程查看时相对于彼此任意滑动(或拉伸).每个线程将具有不同的感知,即哪些事件(或等效地,存储器值)是同时的.与一个线程同时发生的事件(或内存值)集与另一个线程不同时发生.因此,在宽松的存储器模型中,所有线程仍然观察每个存储器位置的相同历史(即,值序列).但是他们可能会观察到不同的记忆图像(即所有记忆位置的值的组合).即使两个不同的存储器位置按顺序由相同的线程写入,也可以由其他线程以不同的顺序观察这两个新写入的值.

[来自维基百科的图片]

熟悉爱因斯坦狭义相对论的读者会注意到我所指的是什么.将Minkowski的单词翻译成内存模型领域:地址空间和时间是地址空间时间的阴影.在这种情况下,每个观察者(即线程)都会将事件的阴影(即内存存储/加载)投影到他自己的世界线(即他的时间轴)和他自己的同时平面(他的地址空间轴)上. .C++ 11内存模型中的线程对应于在狭义相对论中相对移动的观察者.顺序一致性对应于伽利略时空(即,所有观察者都同意事件的一个绝对顺序和全局同时感).

记忆模型和狭义相对论之间的相似性源于两者都定义了一组部分有序的事件,通常称为因果集.某些事件(即内存存储)可能会影响(但不受其他事件影响).C++ 11线程(或物理学中的观察者)只不过是一个链(即完全有序的集合)事件(例如,内存加载和存储到可能不同的地址).

在相对论中,一些秩序被恢复到看似混乱的部分有序事件的图像,因为所有观察者都同意的唯一时间顺序是"时间"事件之间的排序(即,原则上可由任何粒子变慢的事件连接的那些事件比真空中的光速更快.只有时间相关的事件才是不变的. 物理学时间,Craig Callender.

在C++ 11内存模型中,使用类似的机制(获取 - 释放一致性模型)来建立这些本地因果关系.

为了提供内存一致性的定义和放弃SC的动机,我将引用"内存一致性和缓存一致性的入门"

对于共享内存机器,内存一致性模型定义其内存系统的体系结构可见行为.单个处理器核心的正确性标准在" 一个正确结果 "和" 许多不正确的备选方案 " 之间划分行为.这是因为处理器的体系结构要求线程的执行将给定的输入状态转换为单个明确定义的输出状态,即使在无序核心上也是如此.但是,共享内存一致性模型涉及多个线程的加载和存储,并且通常允许许多正确的执行,同时禁止许多(更多)不正确的执行.多次正确执行的可能性是由于ISA允许多个线程同时执行,通常具有来自不同线程的许多可能的合法交错指令.

松弛或弱内存一致性模型的动机是强大模型中的大多数内存排序是不必要的.如果一个线程更新十个数据项然后更新同步标志,程序员通常不关心数据项是否按照彼此的顺序更新,而只是在更新标志之前更新所有数据项(通常使用FENCE指令实现) ).轻松的模型试图捕捉这种增加的订购灵活性,并只保留程序员"需要 "的订单,以获得更高的性能和SC的正确性.例如,在某些体系结构中,每个核心使用FIFO写入缓冲区来在将结果写入高速缓存之前保存已提交(已淘汰)存储的结果.此优化可提高性能但违反SC.写缓冲区隐藏了为存储未命中提供服务的延迟.因为商店很常见,能够避免大多数商店停滞是一个重要的好处.对于单核处理器,通过确保对地址A的加载将最近的存储的值返回到A,即使A的一个或多个存储在写缓冲区中,也可以在体系结构上使写缓冲区不可见.这通常通过绕过A的最新存储的值到A的负载来完成,其中"最近的"由程序顺序确定,或者如果A的存储在写缓冲区中则停止A的加载. .当使用多个内核时,每个内核都有自己的旁路写缓冲区.没有写入缓冲区,硬件就是SC,但是使用写入缓冲区则不是,这使得写入缓冲区在多核处理器中在架构上可见.

如果核心具有非FIFO写入缓冲区,允许存储以与其输入顺序不同的顺序离开,则可能发生存储 - 存储重新排序.如果第一个商店在高速缓存中未命中而第二个商店未命中,或者如果第二个商店可以与早期商店合并(即,在第一个商店之前),则可能发生这种情况.负载重新排序也可能发生在执行程序指令之外的指令的动态调度核心上.这可能与在另一个核心上重新排序存储的行为相同(你能想出两个线程之间的交错示例吗？).使用以后的存储(加载存储重新排序)重新排序较早的加载可能会导致许多不正确的行为,例如在释放保护它的锁之后加载值(如果存储是解锁操作).请注意,即使对于按程序顺序执行所有指令的内核,也可能由于常用FIFO写缓冲区中的本地旁路而导致存储负载重新排序.

因为缓存一致性和内存一致性有时会混淆,所以引用这个引用也是有益的:

与一致性不同,缓存一致性既不是软件可见的,也不是必需的.Coherence试图使共享内存系统的缓存在功能上与单核系统中的缓存一样不可见.正确的一致性确保程序员无法通过分析加载和存储的结果来确定系统是否以及在何处具有缓存.这是因为正确的一致性确保高速缓存从不启用新的或不同的功能行为(程序员仍然能够使用定时信息推断可能的高速缓存结构).高速缓存一致性协议的主要目的是为每个内存位置维护单写入器多读取器(SWMR)不变量.一致性和一致性之间的一个重要区别是,在每个内存位置的基础上指定了一致性,而对于所有内存位置指定了一致性.

继续我们的心理图像,SWMR不变量对应于物理要求,即任何一个位置最多只有一个粒子,但任何位置都可以有无限数量的观察者.

Answer 3

_{这是一个多年前的问题,但是非常受欢迎,值得一提的是学习C++ 11内存模型的绝佳资源.我认为总结他的演讲是没有意义的,以便再做一个完整的答案,但鉴于这是实际编写标准的人,我认为值得观看谈话.}

Herb Sutter有一个长达3个小时的关于C++ 11内存模型的讨论,名为"atomic <> Weapons",可在Channel9网站上找到 - 第1 部分和第2部分.这个讲座非常技术性,涵盖以下主题:

1. 优化,种族和记忆模型
2. 订购 - 什么:获取和发布
3. 订购 - 如何:互斥锁,原子和/或栅栏
4. 编译器和硬件的其他限制
5. 代码和性能:x86/x64,IA64,POWER,ARM
6. 轻松的原子论

谈话没有详细说明API,而是关于推理,背景,幕后和幕后(您是否知道轻松的语义被添加到标准中只是因为POWER和ARM不能有效地支持同步加载？).

Answer 4

这意味着标准现在定义了多线程,它定义了多线程上下文中发生的事情.当然,人们使用不同的实现,但这就像问我们为什么应该有一个std::string什么时候我们都可以使用自制的string类.

当你谈论POSIX线程或Windows线程时,这实际上是一个幻想,因为它实际上是在谈论x86线程,因为它是一个并发运行的硬件功能.C++ 0x内存模型可以保证,无论您使用的是x86,还是ARM,MIPS,还是其他任何你能想到的东西.

Answer 5

对于未指定内存模型的语言,您将编写由处理器体系结构指定的语言和内存模型的代码.处理器可以选择重新排序存储器访问以获得性能.因此,如果您的程序有数据竞争(数据竞争是多个核心/超线程可能同时访问同一内存),那么您的程序不是跨平台的,因为它依赖于处理器内存模型.您可以参考英特尔或AMD软件手册,了解处理器如何重新排序内存访问.

非常重要的是,锁(以及带锁定的并发语义)通常以跨平台的方式实现......因此,如果您在没有数据争用的多线程程序中使用标准锁,那么您不必担心跨平台内存模型.

有趣的是,用于C++的Microsoft编译器具有针对volatile的获取/发布语义,这是一个C++扩展,用于处理C++中缺少内存模型的问题http://msdn.microsoft.com/en-us/library/12a04hfd(v=vs .80).aspx.但是,鉴于Windows仅在x86/x64上运行,这并不多说(英特尔和AMD内存模型可以轻松高效地在一种语言中实现获取/发布语义).

Answer 6

如果您使用互斥锁来保护所有数据,那么您真的不必担心.互斥锁始终提供足够的订购和可见性保证.

现在,如果您使用原子或无锁算法,则需要考虑内存模型.存储器模型精确地描述了原子提供排序和可见性保证的时间,并为手动编码保证提供了便携式栅栏.

以前,原子会使用编译器内在函数或一些更高级别的库来完成.Fences将使用特定于CPU的指令(内存屏障)完成.

Answer 7

以上答案涉及 C++ 内存模型的最基本方面。在实践中，std::atomic<>“just work”的大多数用法，至少在程序员过度优化之前（例如，通过试图放松太多事情）。

有一个地方仍然常见错误：序列锁。https://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf 上有关于挑战的出色且易于阅读的讨论。序列锁很有吸引力，因为读取器避免写入锁字。以下代码基于上述技术报告的图 1，它突出了在 C++ 中实现序列锁时的挑战：

atomic<uint64_t> seq; // seqlock representation
int data1, data2;     // this data will be protected by seq

T reader() {
    int r1, r2;
    unsigned seq0, seq1;
    while (true) {
        seq0 = seq;
        r1 = data1; // INCORRECT! Data Race!
        r2 = data2; // INCORRECT!
        seq1 = seq;

        // if the lock didn't change while I was reading, and
        // the lock wasn't held while I was reading, then my
        // reads should be valid
        if (seq0 == seq1 && !(seq0 & 1))
            break;
    }
    use(r1, r2);
}

void writer(int new_data1, int new_data2) {
    unsigned seq0 = seq;
    while (true) {
        if ((!(seq0 & 1)) && seq.compare_exchange_weak(seq0, seq0 + 1))
            break; // atomically moving the lock from even to odd is an acquire
    }
    data1 = new_data1;
    data2 = new_data2;
    seq = seq0 + 2; // release the lock by increasing its value to even
}

一开始看起来很不直观，data1而且data2需要如此atomic<>。如果它们不是原子的，那么它们可以在reader()写入 (in writer()) 的同时被读取(in )。根据 C++ 内存模型，即使reader()从不实际使用数据，这也是一场竞赛。此外，如果它们不是原子的，那么编译器可以在寄存器中缓存每个值的第一次读取。很显然，你不会想...你想在每次迭代重新读取while的循环reader()。

制作它们atomic<>并使用memory_order_relaxed. 这样做的原因是 seq (in reader())的读取只有获取语义。简单来说，如果X和Y是内存访问，X在Y之前，X不是acquire或release，Y是acquire，那么编译器可以将Y重新排序在X之前。如果Y是seq的第二次读取，而X是读取数据，这样的重新排序会破坏锁实现。

论文给出了一些解决方案。今天表现最好的一个可能是一个使用了一个atomic_thread_fence与memory_order_relaxed 之前的顺序锁的第二次读取。在论文中，它是图 6。我不在这里复制代码，因为任何读到这里的人都应该阅读这篇论文。它比这篇文章更精确和完整。

最后一个问题是使data变量原子化可能是不自然的。如果你不能在你的代码中，那么你需要非常小心，因为从非原子到原子的转换只对原始类型是合法的。C++20 应该添加atomic_ref<>，这将使这个问题更容易解决。

总结一下：即使您认为您了解 C++ 内存模型，在滚动您自己的序列锁之前也应该非常小心。