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

6 回答

• 297

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

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

  C 98 / C 03规范中的抽象机器基本上是单线程的 . 因此，编写与规范相关的"fully portable"的多线程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;
  

  Thread 2的输出可能是什么？

  在C 98 / C 03下，这甚至不是未定义的行为;问题本身毫无意义，因为标准没有考虑任何称为"thread"的东西 .

  在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标准化它们 . 但有时出于性能原因，您需要较低级别的原语（例如，经典double-checked locking pattern） . 新标准提供了高级小工具，如互斥锁和条件变量，还提供了原子类型和各种内存屏障等低级小工具 . 因此，现在您可以完全使用标准指定的语言编写复杂的高性能并发例程，并且您可以确定您的代码将在今天's systems and tomorrow'上编译并运行不变 .

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

  有关这些内容的更多信息，请参阅this blog post .

  回复于 2024-04-19T10:49:48+08:00
• 1885

  我将简单地给出我理解的内存一致性模型（或简称内存模型）的类比 . 它的灵感来自Leslie Lamport的开创性论文"Time, Clocks, and the Ordering of Events in a Distributed System" . 这个比喻很贴切，具有根本意义，但对许多人来说可能有些过分 . 但是，我希望它提供一个心理图像（图形表示），便于推理内存一致性模型 .

  让我们在时空图中查看所有存储器位置的历史，其中横轴表示地址空间（即，每个存储器位置由该轴上的点表示），纵轴表示时间（我们将看到，一般来说，没有一个普遍的时间概念） . 因此，每个存储器位置所保持的值的历史由该存储器地址处的垂直列表示 . 每个值更改都是由于其中一个线程将新值写入该位置 . 通过 memory image ，我们将表示 a particular thread 可观察到的所有内存位置的值的聚合/组合 at a particular time .

  引自"A Primer on Memory Consistency and Cache Coherence"

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

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

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

  [来自维基百科的图片]
  

  熟悉爱因斯坦 Special Theory of Relativity 的读者会注意到我所指的是什么 . 将Minkowski的单词翻译成内存模型领域：地址空间和时间是地址空间时间的阴影 . 在这种情况下，每个观察者（即线程）会将事件的阴影（即内存存储/加载）投影到他自己的世界线（即他的时间轴）和他自己的同时平面（他的地址空间轴）上 . . C 11中的主题内存模型对应于在狭义相对论中相对移动的 observers . 顺序一致性对应于 Galilean space-time （即，所有观察者都同意事件的一个绝对顺序和全局同时性意义） .

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

  在相对论中，一些秩序被恢复到看似混乱的部分有序事件的图像，因为所有观察者都同意的唯一时间顺序是“时间”事件之间的排序（即，那些原则上可由任何粒子变得更慢的事件可以连接的事件而不是真空中的光速） . 只有时间相关的事件才是不变的 . Time in Physics, Craig Callender .

  在C 11内存模型中，使用类似的机制（获取 - 释放一致性模型）来 Build 这些 local causality relations .

  为了提供内存一致性的定义和放弃SC的动机，我将引用"A Primer on Memory Consistency and Cache Coherence"

  对于共享内存计算机，内存一致性模型定义其内存系统的体系结构可见行为 . 单个处理器核心的正确性标准在“一个正确结果”和“许多不正确的备选方案”之间划分行为 . 这是因为处理器的体系结构要求线程的执行将给定的输入状态转换为单个明确定义的输出状态，即使在无序核心上也是如此 . 但是，共享内存一致性模型涉及多个线程的加载和存储，并且通常允许许多正确的执行，同时禁止许多（更多）不正确的执行 . 多次正确执行的可能性是由于ISA允许多个线程同时执行，通常有许多可能的来自不同线程的指令的合法交错 . 轻松或弱内存一致性模型的动机是强大模型中的大多数内存排序是不必要的 . 如果一个线程更新十个数据项然后更新一个同步标志，程序员通常不关心数据项是否按照彼此的顺序更新，而只是更新所有数据项在更新标志之前（通常使用FENCE指令实现） ） . 轻松的模型试图捕获这种增加的订购灵活性，并仅保留程序员“需要”的订单，以获得更高的性能和SC的正确性 . 例如，在某些体系结构中，每个核心使用FIFO写入缓冲区来保存已提交（已淘汰）存储的结果，然后再将结果写入高速缓存 . 此优化可提高性能但违反SC . 写缓冲区隐藏了为存储未命中提供服务的延迟 . 因为商店很常见，能够避免大多数商店停滞是一个重要的好处 . 对于单核处理器，通过确保对地址A的加载将最新存储的值返回到A，即使A的一个或多个存储位于写缓冲区中，也可以在体系结构上使写缓冲区不可见 . 这通常通过绕过A的最新存储的值到A的负载来完成，其中“最近的”由程序顺序确定，或者如果A的存储在写缓冲区中则停止A的加载 . . 当使用多个内核时，每个内核都有自己的旁路写缓冲区 . 如果没有写缓冲区，硬件就是SC，但是使用写缓冲区则不是，这使得写缓冲区在多核处理器中在架构上可见 . 如果核心具有非FIFO写入缓冲区，允许存储以与其输入顺序不同的顺序离开，则可能发生存储 - 存储重新排序 . 如果第一个商店在高速缓存中未命中而第二个商店未命中，或者如果第二个商店可以与早期商店合并（即，在第一个商店之前），则可能发生这种情况 . 负载重新排序也可能发生在执行程序指令之外的指令的动态调度核心上 . 这可能与在另一个核心上重新排序存储的行为相同（你能想出两个线程之间的交错示例吗？） . 使用以后的存储重新排序较早的加载（加载存储重新排序）可能会导致许多不正确的行为，例如在释放保护它的锁之后加载值（如果存储是解锁操作） . 请注意，存储负载重新排序也可能由于在通常实现的FIFO写缓冲区中的本地旁路而产生，即使核心按程序顺序执行所有指令也是如此 .

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

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

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

  回复于 2024-04-19T10:49:48+08:00
• 23

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

  当你're talking about POSIX threads or Windows threads, then this is a bit of an illusion as actually you'谈论x86线程时，因为's a hardware function to run concurrently. The C++0x memory model makes guarantees, whether you'在x86，或ARM，或MIPS，或者其他任何你可以提出的 .

  回复于 2024-04-19T10:49:48+08:00
• 88

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

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

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

  回复于 2024-04-19T10:49:48+08:00
• 69

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

  非常重要的是，锁（以及带锁定的并发语义）通常以跨平台的方式实现......因此，如果您在没有数据竞争的多线程程序中使用标准锁，那么您 don't have to worry about cross platform memory models .

  有趣的是，用于C的Microsoft编译器具有针对volatile的获取/释放语义，这是C扩展来处理C http://msdn.microsoft.com/en-us/library/12a04hfd(v=vs.80).aspx中缺少的内存模型 . 但是，鉴于Windows仅在x86 / x64上运行，这并不是很多（英特尔和AMD内存模型使得在一种语言中实现获取/发布语义变得简单而有效） .

  回复于 2024-04-19T10:49:48+08:00
• 50

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

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

  • 优化，种族和记忆模型

  • 订购 - 内容：获取和发布

  • 订购 - 如何：互斥锁，原子和/或栅栏

  • 编译器和硬件的其他限制

  • 代码生成和性能：x86 / x64，IA64，POWER，ARM

  • 轻松的原子学

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

  回复于 2024-04-19T10:49:48+08:00