架构学习之AArch64内存模型

Posted 2023-03-31 linux解码者

本文翻译自文档Learn the architecture_aarch64 memory model

1 Overview

        本指导介绍Armv8-A中的内存模型。它开始于解释描述内存的属性来自哪里以及它们是如何被赋予给内存区域。然后它介绍有效的不同属性和memory order的基础。

        这些信息对任何开发底层代码的开发者有用，像启动代码或驱动。特别是对管理或建立MMU的开发者相关。

        在文档的最后，你可以检查下你学到的知识。你将学习到不同的内存类型和它们的关键不同点。你将能够对Normal和Device内存类型的内存order规则进行描述。并且你能够列出给定地址的内存属性。

2 什么是内存模型以及为什么需要它

        内存模型是组织和定义内存行为的方式。当你在配置地址或地址区域是如何访问或使用的，它提供了一组结构体和一组规则用来遵守。

        内存模型提供了将应用到地址的属性且定义与内存访问顺序相关的规则。

        考虑一个简单系统的地址空间，如下图所示：\\

        地址空间中的内存区域布局被称为地址映射。这里，映射包括：

1. 内存和外设
2. 在内存中的代码和数据
3. OS的资源和用户应用的资源

        处理器与外设交互的方式与处理器与内存交互不一样。通常你会缓存内存但你不会缓存外设。缓存是将内存中的信息的拷贝到一个位置，这被称为一个缓存。Cache更接近于core，因此对于core的访问更快。类似的，通常处理器会阻塞用户访问到内核资源。

        下图描述了应用于内存区域的不同内存属性的地址映射：

         需要能够对处理器描述不同的属性，因此处理器合适的访问每个位置。

3 AArch64中描述内存

        虚拟地址和物理地址之间的映射被定义在一组转换表中，通常被称为页表。对于虚拟地址的每个block或页，转换表提供了相对应的物理地址和访问该页的属性。

        每个转换表项被称为block或页描述符。在大多数情况下，属性来自于这些描述符。

        下图描述了一个block描述符的例子，它里面包含属性域：

        重要的属性如下：

1. SH：shareable属性
2. AP：访问属性
3. UXN和PXN：执行权限

        记住这些属性，后面我们还会再分析它们。

Hierarchical属性

        一些内存属性可以在更高级别的表中的table描述符中被指定。这就是hierarchical属性。这可以应用于访问权限，执行权限和物理地址空间。

        如果这些位被设置，然后更低级别的表项也会被覆盖，如果这些位被清除，更低级别的表项也不会修改。使用PXNTable执行权限的例子如下：

         对于Armv8.1-A，可以禁用设置访问权限和执行权限的支持，这些属性被使用table描述符中hierarchical属性。通过TCR_ELx寄存器进行控制。当禁用时，之前用于hierarchical控制的位可用于软件来作其他功能。

MMU禁用

        总之，地址的属性来自于转换表。转换表位于内存中，被用于保存虚拟地址和物理地址的映射。该表也包含物理内存的属性。

        可以通过MMU访问转换表。

        如果MMU禁用时会发生什么呢？当在写复位后运行的代码时，这个问题对于地址非常重要。

        当stage1 MMU被禁用时：

1. 所有的数据访问都是Device_nGnRnE
2. 所有获取的指令被当作cacheable
3. 所有地址都有读写访问和执行权限

        对于虚拟化覆盖的Exception level，当stage2被禁止时，stage1的属性不会修改。

4内存访问序

        在Armv8-A指令组架构中，我们介绍了简单时序执行SSE。SSE是指令序的概念模型。内存访问序和指令序两者不同，但相关。理解两者的区别非常重要。

        SSE描述了处理器执行指令的顺序。总之，现代处理器存在较长且复杂的流水线。这些流水线通常可以重排指令或并行的执行多个指令来实现最大的性能。SSE意味着处理器必须像在一个时刻只执行一条指令，以程序代码中的顺序。这意味着硬件的任何指令的重排或多个发送必须对软件不可见。

        内存序是内存系统中内存访问的顺序。因为一些机制如write-buffer和cache，即使当指令顺序访问时，相关的内存访问访问可能不会顺序访问。这就是为什么即使处理器遵守SSE模型内存序仍十分重要。

5 内存类型

        系统中没有被标记为fault的所有地址被赋予一个内存类型。内存类型是处理器是如何与地址区域交互的高层描述。在Armv8-A中存在两个内存类型：Normal内存和Device内存。

6 Normal内存

        Normal内存类型用于内存的行为，包括RAM，Flash，或ROM。代码应该被放置于Normal内存的位置。

        在系统中Normal内存为使用最广泛的内存，如下图所示：

 

访问顺序

        通常计算机处理器以指令在程序中的位置顺序执行指令。事件以程序中指定的次数产生，且每次产生一个。这被称为简单时序执行模型SSE。大多数现代处理器可能会遵守该模型，但在现实中会进行一些优化来提升性能。我们这里将介绍一些优化。

        当Normal内存被访问时不会有直接副作用。这意味着读该内存仅返回数据，而不会造成数据修改或直接触发另一个处理。因为这些原因，对于Normal内存，处理器可能：

1. 访问合并。代码可能访问某个内存多次，或访问多个连续的内存。为了效率，允许处理器检测并合并这些访问到一个访问中。比如，如果软件写某个变量多次，处理器可能仅将最后一次写放到内存中。
2. 预测访问。允许处理器读取Normal内存，而不专门需要软件进行请求。比如，处理器可能在软件请求数据之前通过模式识别预取数据，基于之前访问的模式。该技术通过预测行为来加速访问。
3. 重排访问。内存系统中访问的顺序可能与软件发送的访问顺序并不相同。比如，处理器可能重排两个读以允许它产生一个更有效率的总线访问。访问同一个位置不能被重排但可以合并。考虑这些优化，允许处理器采用技术来加速性能和改进电源效率。这意味着Normal内存类型通常能够给出最优性能。

重排的限制

        总之，Normal内存可以被重排。让我们来考虑三个内存访问的时序，两个store和一个load：

        如果处理需要重排这些访问，可能会导致内存中出现错误的值，这是不允许的。

        对于访问相同的byte，必须维持顺序。处理器需要检测危险并保证正常的期预期结果。

        这并不意味着在这个例子中没有优化的可能。处理器可能合并两个store，将合并的store放入到内存系统中。它也可以检测到load操作来自于store指令写的byte，因此它返回新的值而不需要从内存中重读。

        还有其他强制命令的情况，比如地址依赖。一个地址依赖为load或store使用之前load的结果作为地址。在这个代码例子中，第二个指令依赖于第一个指令的结果：

        这个例子也呈现了一个地址依赖，第二个指令依赖于第一个指令结果。

        当在两个内存访问时存在地址依赖时，处理器必须维持这个顺序。

        该规则不应用于控制依赖。一个控制依赖为之前load的值用于作决定。下面代码显示了一个load后跟随Compare和Branch的Zero操作，它依赖于load的值：

        存在在Normal内存之间访问或访问Normal和Device内存之间需要强制顺序的情况。可以通过barrier指令完成。 

7 Device内存

        Device内存类型用于描述外设。外设寄存器通常被提及为MMIO。这里我们可以看到在地址映射中被标记为Device。

        通常Normal内存类型意味着访问时没有副作用。对于Device类型内存则相反。Devcie内存类型用于有副作用的内存。

        比如，读取FIFO通常会导致它前进到下一个数据片。这意味着对FIFO的一些访问非常重要，因此处理器必须遵守程序指定的内容。

        Device区域不会cacheable。这是你不太希望缓存对外设的访问。

        预测数据访问也不允许对Device区域。处理器只有在架构访问时才访问这些位置。这意味着在架构上执行的指令可以访问这些区域。

        指令不能放置于Device区域。我们建议Device区域通常被认为不可执行的。否则，处理器可能预取指令，这会导致对读敏感的设备如FIFO出问题。

设备的子类

        这里有四个Device子类，它们有不同的限制。这些子类为：

1. Device_GRE
2. Device_nGRE
3. Device_nGnRE
4. Device_nGnRnE

Device后面的字母代表着属性的联合：

1. G=Gathering指定访问是否可以合并。可以将对相同位置的多个访问合并到一次访问或合并多个小的访问合并成一个大的访问。
2. R=Re-ordering指定对相同的外设的访问是否可以重排。当重排被允许时，如Normal类型一样存在相同的限制。
3. E=Early Write Acknowlegement决定何时写被认为完成。如果允许E，一旦该访问被其他观察者看到该访问被认为完成，其实它没有到目的地。比如，一旦写在总线上到达write buffer上，该写变成可见。当不允许E时，写必须到达目的地。

        这里有两个例子：

1. Device_GRE。它允许合并，重排，以及早期写响应。
2. Device_nGnRnE。它不允许合并，不允许重排，不允许早期写响应。

        我们已经知道重排是如何工作的，但我们没有介绍合并或早期写响应。Gathering允许对相同的位置内存访问被合并到单个总线事务，优化了访问。早期写响应表明内存系统中的buffer在总线上任何点都可以发送写响应。

对于每种类型处理需要处理不同么？

        内存类型描述了对某个内存一组允许的行为。例如Device类型，下图表明允许的行为：

 

        你可以看到Device_nGnRnE为限制最多的子类，也具有最少允许的行为。Device_GRE为限制最少的子类，因此有最多允许的行为。

        特别是，Device_nGnRnE允许的所有行为也可以被Device_GRE允许。比如，对于Device_GRE内存，使用Gathering并不是需求，它是被允许的。因此，允许处理器将Device_GRE当作Device_nGnRnE。

        对于ARM Cortex-A处理器，这个例子比较极端且不太可能发生。但是处理器不去区分所有的类型和子类型也是常见的，比如将Device_GRE和Device_nGRE当作相同。如果类型或子类通常有更多限制，这是被允许的。

8 描述内存类型

内存类型不直接编码进转换表项。相反，转换表项中的index域用来从MAIR_ELx（内存属性间接寄存器）从选择表项。

         选择的域决定了内存类型和cacheability信息。

        为什么寄存器使用index，而不是将内存类型直接编码入转换表项中？因为转换表项中的位数受限制。它要求8位来编码内存类型，但仅用3位来编码MAIR_ELx的index。它允许架构有效的使用表项中更少位。

9 Cacheability和shareability属性

        标记为Normal的内存也有cacheability和shareability属性。这些属性控制该内存是否可以被缓存。如果内存被缓存，这些属性控制哪个其他agent需要查看内存的一致性拷贝。它也允许复杂的配置，这超过了本文档的范围。

        你可以了解更多cacheability和shareability。

10 权限属性

        AP访问权限属性控制是否内存可以读或写，以及需要什么特权级。下表呈示了AP位的设置：

        如果访问破坏指定的权限，比如对只读区域进行写，会产生异常（也称为权限fault）。

特权级访问非特权数据

        标准的权限模型为一个更高特权entity可以访问属于更低特权entity的任何内容。另一种方法解释，OS可以看到应用分配的所有资源。比如，hypervisor可以看到分配给虚拟机的所有资源。这是因为执行在更高异常级别意味着特权级别也更高。

        但是，这也并不是总是可取的。恶意的应用可能尝试代表OS访问数据，而这些数据它本不应该看到。这就要求OS在系统调用检查指针。

        ARM架构提供了多种控制让这更简单。首先，存在PSTATE.PAN（Privileged Access Never）位。当该位被设置时，从EL1到非特权区域的load和store将产生异常（权限fault），如下图所示：

 

        PAN允许对非特权数据的意外访问被trap。比如，OS发出访问认为目的地是特权的。实际上，目的地是非特权的。这意味着OS的期望与实际是不一致的。它的产生可能是由于编程错误，或系统中攻击。无论哪种情况，PAN允许在错误产生之前捕获该访问，并保证安全操作。

        有时OS需要访问非特性区域，比如，写应用的buffer。为了支持它，指令组提供了LDTR和STTR指令。

        LDTR和STTR为非特权load和store。即使被EL1或EL2的OS执行，根据EL0权限对其进行检查。因为存在明确的非权限访问，它们不会被PAN阻塞，如下图所示：

 

        这允许OS能够区分试图访问特权数据的访问和被期望访问非特权数据的访问。它也允许硬件使用该信息检查访问。

执行权限

        除了访问权限，也还有执行权限。这些属性让你指定指令不能从地址获取指令：

1. UXN。User Execute Never
2. PXN。Privileged Execute Never

        存在Execute Never位。这意味着设置该位将使内存不可执行。

        存在分开的特权和非特权位，因为应用代码需要在EL0执行，但不会在内核权限EL1/EL2执行，如下图所示：

 

        架构也在SCTLR_ELx提供控制位将所有可写地址非执行。

        EL0内存的写权限在EL1不会被执行。

11 访问标志

        你可以使用AF访问标志来跟踪转换表所指向的区域是否被访问。你可以设置AF标志：

1. AF=0表示该区域没有被访问
2. AF=1表示该区域被访问

        AF标志对操作系统非常有用，因为你可以使用它来区分哪个页当前没有被使用且可以将其page-out。

更新AF位

        当AF位被使用时，创建转换表时会初始化清AF位。当一个页被访问时，它的AF位被设置。软件可以分析转换表检查AF位是否被设置或清除。AF=0的页没有被访问，是被paged-out的更好的选择。

        在访问时有两种方式来设置AF位：

1. 软件更新：访问页会导致一个同步异常（Access Flag Fault）。在异常处理中，软件负责对相关软件表中的AF位进行设置；
2. 硬件更新：访问页会导致硬件自动设置AF位而不需要产生异常。该行为在Armv8.1-A中被使能和添加。

dirty状态

        Armv8.1-A引入了处理器管理block页或page页的dirty状态的能力。Dirty状态记录该block或page页是否被写。这非常有用，因为如果block或page页被paged-out，dirty状态告诉管理软件RAM的内容是否需要写入到存储设备中。

        比如，让我们考虑一个text文件。初始化时文件从disk加载到RAM中。当后面它被从内存中移除时，OS需要知道RAM中的内容是否比disk中的内容更新。如果RAM中的内容更新，disk中的内容需要被更新。如果不是，RAM中的内容可以放弃。

        当使能管理dirty状态时，软件初始化时创建访问权限为只读的转换表项且设置DBM位。如果该页被写，硬件自动更新访问权限为读写。

        设置DBM位为1会修改访问权限位（AP[2]和S2AP[1]）的功能，因此它们记录dirty状态替换记录访问权限。这意味着当DBM位被设置为1时，访问权限位不会导致访问fault。

12 对齐和大小端

        本节介绍对齐和大小端。

对齐

        如果地址为element大小的多倍，该访问是对齐的。

        对于LDR和STR指令，element大小为访问的大小。比如，一个LDRH指令加载一个16位值，必须来自一个16位倍数的地址，才能被当作对齐。

        LDP和STP指令load和store一组element。为了对齐，地址必须为element大小的倍数，而不是两个element的联合大小。比如

LDP X0, X1, [X2]

        例子中加载两个64位值，因此总共128位。X2的地址需要为64位的倍数，这被称为对齐。

        相同的规则也被应用于vector load和store。

        当地址不为element大小的倍数，访问为不对齐。不对齐的访问允许访问normal内存，但不允许访问Device区域。对Device区域的不对齐访问将触发异常（alignment fault）。

        对Normal区域不对齐的访问可以通过设置SCTLR_ELx.A被捕捉。如果该位被设置，对Normal区域的不对齐访问也会产生对齐错误。

大小端

        在Armv8-A中，获取的指令通常被当作小端。

        对于数据访问，由实现决定是否小端和大端被支持。如果仅其中一个被支持，由实现决定哪个被支持。

        对于支持大端和小端的处理器，大小端对每个exception level配置。

        Arm Cortex-A处理器即支持大端也支持小端。

13 内存别名和不匹配内存类型

        当物理地址空间的一个给定位置有多个虚拟地址，这称为别名。

        属性是基于虚拟地址的。这是因为属性来自于转换表。当一个物理位置存在多个别名，虚拟别名有兼容的属性非常重要。我们描述兼容如下：

1. 相同的内存类型，对于Device类型有相同的子类
2. 对于Normal内存，相同的cacheability和shareability

        如果属性不兼容，内存访问可能不会像你期望的那样，它会影响性能。

        下图描述了别名的两个例子。内存A的两个别名存在兼容的属性。这是推荐的方法。内存B的两个别名的属性不兼容，它会影响到一致性和性能。

 

 

        Arm强烈推荐软件不要将不兼容的属性赋予相同位置的不同别名。

14 stage1和stage2属性的联合

        当使用虚拟化时，一个虚拟地址会经历转换的两个stage。一个stage是由OS控制，一个stage是由hypervisor控制。两者都包含属性，它们是如何联合的？

        下图呈示了一个例子，stage1中一块内存被标记为Device，但相对应的stage2中被标记为Normal。它的最终结果类型是什么？

 

        在Arm架构中，默认使用受限最多的类型。在这个例子中，Device类型比Normal类型更受限。因此最终的类型为Device。

        对于类型和cacheability，额外的控制HCR_EL2.FWB允许这个行为被覆盖。当FWB被设置，stage2可以覆盖stage1类型和cacheability设置，而不是使用联合行为。

错误处理

        让我们来看下图中两个例子：

        在上面两个例子中，最终属性为RO即只读。如果软件想写该位置，错误permission fault将会产生。但在第一个例子中会产生stage1 fault，而第二个例子中会产生stage2 fault。在这个例子中，stage1的错误会走到EL1的OS，但stage2的错误会走到EL2并由hypervisor处理。

        最后，我们看个stage1和stage2属性相同的例子：

         这里，最后的属性是RO。但是如果软件想写这个内存，stage1和stage2错误会产生么？答案是stage1会产生。如果stage1和stage2产生不同错误类型，这个答案也是一样。Stage1错误通常会优先于stage2的错误。

 

JUC学习之共享模型之内存

JUC学习之共享模型之内存

• Java 内存模型
• 可见性
• • 退不出的循环
  • 解决方法
• 两阶段终止模式
• • interrupt实现
  • volatile实现
  • 同步模式之 Balking
  • • 定义
    • 实现
• 指令重排
• • 有序性
  • 指令级并行原理
  • • 名词
    • • Clock Cycle Time
      • CPI
      • IPC
    • 鱼罐头的故事
    • 指令重排序优化
    • 支持流水线的处理器
    • SuperScalar 处理器
  • CPU 缓存结构原理
  • • 1. CPU 缓存结构
    • 2.CPU 缓存读
    • 3. CPU 缓存一致性
  • 诡异的结果
  • 解决方法
  • volatile 原理
  • 内存屏障
  • • 1. 如何保证可见性
    • 2.如何保证有序性
    • volatile 不能解决指令交错问题
    • double-checked locking 问题
    • 误区
    • double-checked locking 解决
  • happens-before
  • 案例
  • • balking 模式习题
    • 线程安全单例习题
    • 不能给null值上面加上synchronized同步锁
• 本章小结

---

• 前言导读

Monitor 主要关注的是访问共享变量时，保证临界区代码的原子性

这一章我们进一步深入学习共享变量在多线程间的【可见性】问题与多条指令执行时的【有序性】问题

---

Java 内存模型

JMM 即 Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、
CPU 指令优化等。

JMM 体现在以下几个方面

• 原子性 - 保证指令不会受到线程上下文切换的影响
• 可见性 - 保证指令不会受 cpu 缓存的影响
• 有序性 - 保证指令不会受 cpu 指令并行优化的影响

---

可见性

退不出的循环

先来看一个现象，main 线程对 run 变量的修改对于 t 线程不可见，导致了 t 线程无法停止：

package share;

import static java.lang.Thread.sleep;

public class Main

    static boolean run = true;

    public static void main(String[] args) throws InterruptedException 
        Thread t = new Thread(()->
            while(run)
                // ....
            
        );
        t.start();
        sleep(1);
        run = false; // 线程t不会如预想的停下来
    

为什么呢？分析一下：

• 初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存。

• 因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，
  减少对主存中 run 的访问，提高效率

• 1 秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读取这个变量
  的值，结果永远是旧值

---

解决方法

volatile（易变关键字）

它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取
它的值，线程操作 volatile 变量都是直接操作主存

---

两阶段终止模式

interrupt实现

复习interrupt实现两阶段终止模式: 正常线程被打断是设置打断标记为true,阻塞线程被打断会抛出异常，并清除打断标记

package share;

/**
*interrput实现两阶段终止模式
 */
public class Main

    public static void main(String[] args)
    
      Thread thread=new Thread(()->
         while(true)
         
             //获取当前线程
             Thread currentThread = Thread.currentThread();
             //打断标记是否为true
             if(currentThread.isInterrupted())
             
                 System.out.println("呜呜呜，被打了");
                 break;
             
             System.out.println("准备入睡");
             try 
                 Thread.sleep(3*1000);
              catch (InterruptedException e)
             
                 System.out.println("重新设置打断标记");
                 //重新设置打断标记为true
                 currentThread.interrupt();
             
         
      ,"大忽悠一号");

      thread.start();

        //主线程打断
        try 
            Thread.sleep(2*1000);
         catch (InterruptedException e) 
            e.printStackTrace();
        
        System.out.println("主线程执行打断操作");
        thread.interrupt();
    

---

volatile实现

package share;

/**
*停止标记用 volatile 是为了保证该变量在多个线程之间的可见性
 * 我们的例子中，即主线程把它修改为 true 对 t1 线程可见
 */
public class Main

    private volatile static boolean stop=false;
    public static void main(String[] args)
    
      Thread thread=new Thread(()->
         while(true)
         
             //获取当前线程
             Thread currentThread = Thread.currentThread();
             //打断标记是否为true
             if(stop)
             
                 System.out.println("呜呜呜，被打了");
                 break;
             
             System.out.println("准备入睡");
             try 
                 Thread.sleep(3*1000);
              catch (InterruptedException e)
             
             
         
      ,"大忽悠一号");

      thread.start();

        //主线程打断
        try 
            Thread.sleep(1000);
         catch (InterruptedException e) 
            e.printStackTrace();
        
        System.out.println("主线程执行打断操作");
        stop=true;
        thread.interrupt();
    

---

同步模式之 Balking

定义

Balking （犹豫）模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做
了，直接结束返回

实现

public class MonitorService 
 // 用来表示是否已经有线程已经在执行启动了
 private volatile boolean starting;
 public void start() 
 log.info("尝试启动监控线程...");
 synchronized (this) 
 if (starting) 
 return;
 
 starting = true;
 
 
 // 真正启动监控线程...
 

当前端页面多次点击按钮调用 start 时

输出

[http-nio-8080-exec-1] cn.itcast.monitor.service.MonitorService - 该监控线程已启动?(false)
[http-nio-8080-exec-1] cn.itcast.monitor.service.MonitorService - 监控线程已启动...
[http-nio-8080-exec-2] cn.itcast.monitor.service.MonitorService - 该监控线程已启动?(true)
[http-nio-8080-exec-3] cn.itcast.monitor.service.MonitorService - 该监控线程已启动?(true)
[http-nio-8080-exec-4] cn.itcast.monitor.service.MonitorService - 该监控线程已启动?(true)

这里synchronized 锁是防止多线并发执行，导致指令交错发生，而volatile是确保变量对于多个线程的可见性，而不是用来处理并发交错问题的

---

它还经常用来实现线程安全的单例

public final class Singleton 
 private Singleton() 
 

 private static Singleton INSTANCE = null;

 public static synchronized Singleton getInstance() 
  if (INSTANCE != null) 
   return INSTANCE;
  

  INSTANCE = new Singleton();
  return INSTANCE;
 

对比一下保护性暂停模式：保护性暂停模式用在一个线程等待另一个线程的执行结果，当条件不满足时线程等待。

---

指令重排

有序性

JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，思考下面一段代码

static int i;
static int j;
// 在某个线程内执行如下赋值操作
i = ...; 
j = ...;

可以看到，至于是先执行 i 还是 先执行 j ，对最终的结果不会产生影响。所以，上面代码真正执行时，既可以是

i = ...; 
j = ...;

也可以是

j = ...;
i = ...;

这种特性称之为『指令重排』，多线程下『指令重排』会影响正确性。为什么要有重排指令这项优化呢？从 CPU
执行指令的原理来理解一下吧

---

指令级并行原理

名词

Clock Cycle Time

• 主频的概念大家接触的比较多，而 CPU 的 Clock Cycle Time（时钟周期时间），等于主频的倒数，意思是 CPU 能够识别的最小时间单位，比如说 4G 主频的 CPU 的 Clock Cycle Time 就是 0.25 ns，作为对比，我们墙上挂钟的Cycle Time 是 1s
• 例如，运行一条加法指令一般需要一个时钟周期时间

CPI

• 有的指令需要更多的时钟周期时间，所以引出了 CPI （Cycles Per Instruction）指令平均时钟周期数

IPC

• IPC（Instruction Per Clock Cycle） 即 CPI 的倒数，表示每个时钟周期能够运行的指令数 CPU
  执行时间

程序的 CPU 执行时间，即我们前面提到的 user + system 时间，可以用下面的公式来表示

程序 CPU 执行时间 = 指令数 * CPI * Clock Cycle Time

---

鱼罐头的故事

加工一条鱼需要 50 分钟，只能一条鱼、一条鱼顺序加工…

可以将每个鱼罐头的加工流程细分为 5 个步骤：

• 去鳞清洗 10分钟
• 蒸煮沥水 10分钟
• 加注汤料 10分钟
• 杀菌出锅 10分钟
• 真空封罐 10分钟

即使只有一个工人，最理想的情况是：他能够在 10 分钟内同时做好这 5 件事，因为对第一条鱼的真空装罐，不会
影响对第二条鱼的杀菌出锅…

---

指令重排序优化

事实上，现代处理器会设计为一个时钟周期完成一条执行时间最长的 CPU 指令。为什么这么做呢？可以想到指令
还可以再划分成一个个更小的阶段，例如，每条指令都可以分为： 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 这 5 个阶段

术语参考：

• instruction fetch (IF)
• instruction decode (ID)
• execute (EX)
• memory access (MEM)
• register write back (WB)

在不改变程序结果的前提下，这些指令的各个阶段可以通过重排序和组合来实现指令级并行，这一技术在 80’s 中
叶到 90’s 中叶占据了计算架构的重要地位。

提示：
分阶段，分工是提升效率的关键！

---

指令重排的前提是，重排指令不能影响结果，例如

// 可以重排的例子
int a = 10; // 指令1
int b = 20; // 指令2
System.out.println( a + b );
// 不能重排的例子
int a = 10; // 指令1
int b = a - 5; // 指令2

---

支持流水线的处理器

现代 CPU 支持多级指令流水线，例如支持同时执行 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 的处理
器，就可以称之为五级指令流水线。这时 CPU 可以在一个时钟周期内，同时运行五条指令的不同阶段（相当于一
条执行时间最长的复杂指令），IPC = 1，本质上，流水线技术并不能缩短单条指令的执行时间，但它变相地提高了指令地吞吐率。

提示：
奔腾四（Pentium 4）支持高达 35 级流水线，但由于功耗太高被废弃

---

SuperScalar 处理器

大多数处理器包含多个执行单元，并不是所有计算功能都集中在一起，可以再细分为整数运算单元、浮点数运算单
元等，这样可以把多条指令也可以做到并行获取、译码等，CPU 可以在一个时钟周期内，执行多于一条指令，即IPC>1

---

CPU 缓存结构原理

1. CPU 缓存结构

查看 cpu 缓存

⚡ root@yihang01 ~ lscpu
Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
CPU(s): 1
On-line CPU(s) list: 0
Thread(s) per core: 1
Core(s) per socket: 1
Socket(s): 1
NUMA node(s): 1
Vendor ID: GenuineIntel
CPU family: 6
Model: 142
Model name: Intel(R) Core(TM) i7-8565U CPU @ 1.80GHz
Stepping: 11
CPU MHz: 1992.002
BogoMIPS: 3984.00
Hypervisor vendor: VMware
Virtualization type: full
L1d cache: 32K
L1i cache: 32K
L2 cache: 256K
L3 cache: 8192K
NUMA node0 CPU(s): 0

速度比较

查看 cpu 缓存行

⚡ root@yihang01 ~ cat /sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size
64

cpu 拿到的内存地址格式是这样的

[高位组标记][低位索引][偏移量]

---

2.CPU 缓存读

读取数据流程如下

• 根据低位，计算在缓存中的索引
• 判断是否有效

0 去内存读取新数据更新缓存行

1 再对比高位组标记是否一致

• 一致，根据偏移量返回缓存数据
• 不一致，去内存读取新数据更新缓存行

---

3. CPU 缓存一致性

MESI 协议

1. E、S、M 状态的缓存行都可以满足 CPU 的读请求
2. E 状态的缓存行，有写请求，会将状态改为 M，这时并不触发向主存的写
3. E 状态的缓存行，必须监听该缓存行的读操作，如果有，要变为 S 状态

4. M 状态的缓存行，必须监听该缓存行的读操作，如果有，先将其它缓存（S 状态）中该缓存行变成 I 状态（即 6的流程），写入主存，自己变为 S 状态

5. S 状态的缓存行，有写请求，走 4. 的流程

6. S 状态的缓存行，必须监听该缓存行的失效操作，如果有，自己变为 I 状态

7. I 状态的缓存行，有读请求，必须从主存读取

---

诡异的结果

  boolean ready = false;
    int num = 0;
    // 线程1 执行此方法
    public void actor1(I_Result r) 
        if(ready) 
            r.r1 = num + num;
         else 
            r.r1 = 1;
        
    
    // 线程2 执行此方法
    public void actor2(I_Result r) 
        num = 2;
        ready = true;
    

I_Result 是一个对象，有一个属性 r1 用来保存结果，问，可能的结果有几种？

有同学这么分析

• 情况1：线程1 先执行，这时 ready = false，所以进入 else 分支结果为 1
• 情况2：线程2 先执行 num = 2，但没来得及执行 ready = true，线程1 执行，还是进入 else 分支，结果为1
• 情况3：线程2 执行到 ready = true，线程1 执行，这回进入 if 分支，结果为 4（因为 num 已经执行过了）

但我告诉你，结果还有可能是 0 😁😁😁，信不信吧！

这种情况下是：线程2 执行 ready = true，切换到线程1，进入 if 分支，相加为 0，再切回线程2 执行 num = 2

相信很多人已经晕了 😵😵😵

这种现象叫做指令重排，是 JIT 编译器在运行时的一些优化，这个现象需要通过大量测试才能复现：

借助 java 并发压测工具 jcstress

3.JUC整理笔记三之测试工具jcstress
Java中jcstress 高并发测试框架简单使用教程

mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jcstress -
DarchetypeArtifactId=jcstress-java-test-archetype -DarchetypeVersion=0.5 -DgroupId=cn.dhy-
DartifactId=ordering -Dversion=1.0

创建 maven 项目，提供如下测试类

@JCStressTest
@Outcome(id = "1", "4", expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest 
    int num = 0;
    boolean ready = false;
    @Actor
    public void actor1(I_Result r) 
        if(ready) 
            r.r1 = num + num;
         else 
            r.r1 = 1;
        
    
    @Actor
    public void actor2(I_Result r) 
        num = 2;
        ready = true;
    

执行

mvn clean install 
java -jar target/jcstress.jar

会输出我们感兴趣的结果，摘录其中一次结果：

*** INTERESTING tests 
 Some interesting behaviors observed. This is for the plain curiosity. 
 2 matching test results. 
 [OK] test.ConcurrencyTest 
 (JVM args: [-XX:-TieredCompilation]) 
 
 Observed state Occurrences Expectation Interpretation 
 0 1,729 ACCEPTABLE_INTERESTING !!!! 
 1 42,617,915 ACCEPTABLE ok 
 4 5,146,627 ACCEPTABLE ok 
 [OK] test.ConcurrencyTest 
 (JVM args: []) 
 
 Observed state Occurrences Expectation Interpretation 
 0 1CUDA学习之使用共享内存（shared memory）进行归约求和

 armv8 memory translation
 华为发布AArch64/Arm64 硬件的 Linux 镜像内存支持
 华为发布AArch64/Arm64 硬件的 Linux 镜像内存支持
 python学习之计算机基础详解
 JUC学习之共享模型之内存