深入理解计算机系统_第四章_处理器体系结构

电玩女神 2022-03-26 04:04 284阅读 0赞

现代微处理器可以称得上是人类创造出的最复杂的系统之一。一块手指甲大小的硅片上，可以容纳一个完整的高性能处理器、大的高速缓存，以及用来连接到外部设备的逻辑电路。从性能上来说，今天在一块芯片上实现的处理器已经使 20 年前价值 1000 万美元、房间那么大的超级计算机相形见绌了。即使是在像手机、导航系统和可编程恒温器这样的日常设备中的嵌入式处理器，也比早期计算机开发者所能想到的强大很多。

到目前为止，我们看到的计算机系统只限于机器语言程序级。我们知道处理器必须执行一系列指令，每条指令执行某个简单操作，例如两个数相加。指令被编码为由一个或多个字节序列组成的二进制格式。一个处理器支持的指令和指令的字节级编码称为它的`指令集体系结构（Instruction-Set Architecture，ISA）`。不同的处理器“家族”，例如 Intel IA32 和 x86-64、IBM/Freescale Power 和 ARM 处理器家族，都有不同的 ISA。一个程序编译成在一种机器上运行，就不能在另一种机器上运行。另外，同一个家族里也有很多不同型号的处理器。虽然每个厂商制造的处理器性能和复杂性不断体改，但是不同的型号在 ISA 级别上都保持着兼容。一些常见的处理器家族（例如 x86-64）中的处理器分别由多个厂商提供。因此，ISA 在编译器编写者和处理器设计人员之间提供了一个概念抽象层，编译器编写者只需要知道允许哪些指令，以及它们是如何编码的；而处理器设计者必须建造出执行这些指令的处理器。

本章将简要介绍处理器硬件的设计。我们将研究一个硬件系统执行某种 ISA 指令的方式。这会使你能更好地理解计算机是如何工作的，以及计算机制造商们面临的技术挑战。一个很重要的概念是，现代处理器的实际工作方式可能跟 ISA 隐含的计算机模型大相径庭。ISA 模型看上去应该是`顺序`指令执行，也就是先取出一条指令，等到它执行完毕，再开始下一条。然而，与一个时刻只执行一条指令相比，通过同时处理多条指令的不同部分，处理器可以获得更好的性能【还记得第三章中，在一些情况下，把if条件的两种情况的结果都计算出来执行速度会更快吗】为了保证处理器能得到同顺序执行相同的结果，人们采用了一些特殊的机制。在计算机科学中，用巧妙的办法在提高性能的同时又保持了一个更简单、更抽象模型的功能，这种思想是众所周知的。在 Web 浏览器或平等二叉树和哈希表这样的信息检索数据结构中使用缓存，就是这样的例子。

你很可能永远都不会自己设计处理器，这是专家们的任务，他们工作在全球不到 100 家的公司里。那么为什么你还应该了解处理器设计呢？【这正是我想问的。。。】

*  `从智力方面来说，处理器设计是非常有趣而且很重要的。`学习事物是怎样工作的由其内在价值。了解作为计算机科学家和工程师日常生活一部分的一个系统的内部工作原理（特别是对很多人来说这还是个迷），是一件格外有趣的事情。处理器设计包括许多好的工程实践原理。它需要完成复杂的任务，而结构又要尽可能简单和规则。
 *  `理解处理器如何工作能帮助理解整个计算机系统如何工作。`在之后的第六章，我们讲述存储器系统，以及用来创建很大的内存映射同时又有快速访问时间的技术。看看处理器端的处理器——内存接口，会使那些讲述更加完整。
 *  `虽然很少有人设计处理器，但是许多人设计包含处理器的硬件系统。`将处理器嵌入到现实世界的系统中，如汽车和家用电器，已经变得非常普遍了。嵌入式系统的设计者必须了解处理器是如何工作的，因为这些系统通常在比桌面和基于服务器的系统更低抽象级别上进行设计和编程。
 *  `你的工作可能是处理器设计。`虽然生产处理器的公司很少，但是研究处理器的设计人员队伍已经非常巨大了，而且还在壮大。一个主要的处理器设计的各个方面大约涉及 1000 多人。

本章首先定义一个简单的指令集，作为我们处理器实现的运行示例。因为受 x86-64 指令集的启发，它被俗称为“x86”，所以我们称我们的指令集为 “y86-64”指令集。于 x86-64 相比，y86-64 指令集的数据类型、指令和寻址方式都要少一些。它的字节级编码也比较简单，机器代码没有相应的 x86-64 代码紧凑，不过设计它的 CPU 译码逻辑也要简单一些。虽然 y86-64 指令集很简单，它仍然足够完整，能让我们写一些处理整数的程序。设计一个实现 y86-64 的处理器要求我们解决许多处理器设计者同样会面对的问题。

接下来会提供一些数字硬件设计的背景。我们会描述处理器中使用的基本构件块，以及它们如何连接起来和操作。这些介绍是建立在第 2 章对布尔代数和位级操作的讨论的基础上的。我们还将介绍一种描述硬件系统控制部分的简单语言，HCL（Hardware Control Language，硬件控制语言）。然后，用它来描述我们的处理器设计。即使你已经有了一些逻辑设计的背景知识，也应该读读这个部分以了解我们的特殊符号表示方法。

作为设计处理器的第一步，我们给出一个基于顺序操作、功能正确但有点不实用的 y86-64 处理器。这个处理器每个时钟周期执行一条完整的 y86-64 指令。所以它的时钟必须足够慢，以允许一个周期内完成所有的动作。这样一个处理器是可以实现的，但是它的性能远远低于同样的硬件应该能达到的性能。

以这个顺序设计为基础，我们进行一系列的改造，创建一个`流水线化的处理器（pipelined processor）`。这个处理器将每条指令的执行分解成五步，每个步骤由一个独立的硬件部分或阶段（stage）来处理。指令步经流水线的各个阶段，且每个时钟周期有一条新指令进入流水线。所以，处理器可以同时执行五条指令的不同阶段。为了使这个处理器保留 y86-64 ISA 的顺序行为，就要求处理很多`冒险`或`冲突（hazard）`情况，冒险就是一条指令的位置或操作数依赖于其他仍在流水线中的指令。

我们设计了一些工具来研究和测试处理器设计。其中包括 y86-64 的汇编器、在你的机器上运行 y86-64 程序的模拟器，还有针对两个顺序处理器设计和一个流水线化处理器设计的模拟器。这些设计的控制逻辑用 HCL 符号表示的文件描述。通过编辑这些文件和重新编译模拟器，你可以改变和扩展模拟器的行为。我们还提供许多练习，包括实现新的指令和修改机器处理指令的方式。还提供测试代码以帮助你评价修改的正确性。这些练习将极大地帮助你理解所有这些内容，也能使你更理解处理器设计者面临的许多不同的设计选择。

旁注 ARCH：VLOG 给出了用 Verilog 硬件描述语言描述的流水线化的 y86-64 处理器。其中包括为基本的硬件构建块和整个的处理器结构创建模块。我们自动地将控制逻辑的 HCL 描述翻译成 Verilog。首先用我们的模拟器调试 HCL 描述，能消除很多在硬件设计中会出现的棘手问题。给定一个 Verilog 描述，有商业和开源工具来支持模拟和`逻辑合成（logic synthesis）`，产生实际的微处理器电路设计。因此，虽然我们在此花费大部分精力创建系统的图形和文字描述，写软件的时候也会花费同样的精力，但是这些设计能够自动地合成，这表明我们确实在创建一个能够用硬件实现的系统。

#### 1 Y86-64 指令集体系结构 ####

定义一个指令集体系结构包括定义各种状态单元、指令集和它们的编码、一组编程规范和异常事件处理。

###### 1.程序员可见的状态 ######

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70]

y86-64 程序中的每条指令都会读取或修改处理器状态的某些部分。这称为`程序员可见`状态，这里的“程序员”既可以是用汇编代码写程序的人，也可以是产生机器级代码的编译器。在处理器实现中，只要我们保证机器级程序能够访问程序员可见状态，就不需要完全按照 ISA 暗示的方式来表示和组织这个处理器状态。y86-64 的状态类似于 x86-64 。有 15 个程序寄存器。每个程序寄存器存储一个 64 位的字。寄存器 %rsp 被入栈、出栈、调用和返回指令作为栈指针。除此以外，寄存器没有固定的含义或固定值。有 3 个一位的条件码，它们保存着最近的算术或逻辑指令所造成影响的有关信息。程序计数器（PC）存放当前正在执行指令的地址。

`内存`从概念上来说就是一个很大的字节数组，保存着程序和数据。y86-64 程序用`虚拟地址`来引用内存位置。硬件和操作系统软件联合起来将地址翻译成实际或`物理地址`，指明数据实际存在内存中哪个地方。第 9 章将更详细地研究虚拟内存。现在，我们只认为虚拟内存系统向 y86-64 程序提供了一个单一的字节数组映像。

程序状态的最后一个部分是状态码 Stat，它表明程序执行的总体状态。它会指示是正常运行，还是出现了某种`异常`，例如当一条指令试图去读非法的内存地址时。

###### 2. Y86-64 指令 ######

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 1]

上图给出了 y86-64 ISA 中各个指令的简单描述。这个指令集就是我们处理器实现的目标。y86-64 指令集基本上是 x86-64 指令集的一个子集。它只包括 8 字节整数操作，寻址方式比较少，操作也少。因为我们只有 8 字节数据，所以称之为“字（Word）”不会有任何歧义。在这个图中，左边是指令的汇编码表示，右边是字节编码。

下面是 y86-64 指令的一些细节：

*  x86-64 的 movq 指令分成了 4 个不同的指令：irmovq、rrmovq、mrmov、rmmovq，分别显式的指明源和目的的格式。源可以是立即数（i）、寄存器（r）或内存（m）。指令名字的第一个字母就表明了源的类型。目的可以是寄存器（r）或内存（m）。指令名字的第二个字母指明了目的的类型。在决定如何实现数据传送时，显式的指明数据传送的这 4 中类型是很有帮助的。两个内存传送指令中的内存引用方式是简单的基址的偏移量形式。在地址计算中，我们不支持第二变址寄存器（second index register）和任何寄存器值的伸缩（scaling）。同 x86-64 一样，我们不允许从一个内存地址直接传送到另一个内存地址。另外，也不允许将立即数传送到内存。
 *  有 4 个整数操作指令，比如上图的 OPq。它们是 addq、subq、andq 和 xorq 。它们只对寄存器数据进行操作，而 x86-64 还允许对内存数据进行这些操作。这些指令会设置 3 个条件码 ZF、SF 和 OF（零、符号和溢出）。
 *  7 个跳转指令是 jmp、jle、jl、je、jne、jge 和 jg。根据分支指令的类型和条件代码的设置来选择分支。分支条件和 x86-64 的一样。
 *  有 6 个条件传送指令：cmovle、cmovl、cmove、cmovne、cmovge 和 cmovg。这些指令的格式与寄存器-寄存器传送指令 rrmovq 一样，但是只有当条件码满足所需的约束时，才会更新目的寄存器的值。
 *  call 指令将返回地址入栈，然后跳到目的地址。ret 指令从这样的调用中返回。
 *  pushq 和 popq 指令实现了入栈和出栈，就像在 x86-64 中一样。
 *  halt 指令停止指令的执行。x86-64 中有一个与之相当的指令 hlt。x86-64 的应用程序不允许使用这条指令，因为它会导致整个系统暂停运行。对于 y86-64 来说，执行 halt 指令会导致处理器停止，并将状态码设置为 HLT。

###### 3.指令编码 ######

上图还给出了指令的字节级编码。每条指令需要 1 ~ 10 个字节不等，这取决于需要哪些字段。每条指令的第一个字节表明指令的类型。这个字节分为两个部分，每部分 4 位：高 4 位是代码（code）部分，低 4 位是 功能（function）部分。如上图所示，代码值位 0 ~ 0xB。功能值只有在一组相关指令共用一个代码时才有用。下图给出了整数操作、分支和条件传送指令的具体编码。可以观察到，rrmovq 与条件传送有同样的指令代码。可以把它看作是一个“无条件传送”，就好像 jmp 指令是无条件跳转一样，它们的功能代码都是 0。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 2]

如下图，15 个程序寄存器中每个都有一个相对应的范围在 0 到 0xE之间的`寄存器标识符（register ID）`。y86-64 中的寄存器编号跟 x86-64 中的相同。程序寄存器存在 CPU 中的一个 `寄存器`文件中，这个寄存器文件就是一个小的、以寄存器 ID 作为地址的随机访问存储器。在指令编码中以及在我们的硬件设计中，当需要指明不应访问任何寄存器时，就用 ID 值 0xF 来表示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 3]

有的指令只有一个字节长，而有的需要操作数的指令编码就更长一些。首先，可能有附加的`寄存器指示符字节（register specifier byte）`，指定一个或两个寄存器。在上上图中，这些寄存器字段成为 rA 和 rB。从指令的汇编代码表示中可以看到，根据指令类型，指令可以指定用于数据源和目的的寄存器，或是用于地址计算的基址寄存器。没有寄存器操作数的指令，例如分支指令和 call 指令，就没有寄存器指示符字节。那些只需要一个寄存器操作数的指令（irmovq、pushq 和 popq）将另一个寄存器指示符设为 0xF。这种约定在我们的处理器实现中非常有用。

有些指令需要一个附加 4 字节`常数字（constant word）`。这个字能作为 irmovq 的立即数数据，rmmovq 和 mrmovq 的地址指示符的偏移量，以及分支指令和调用指令的目的地址。注意，分支指令和调用指令的目的是一个绝对地址，而不像 IA32 中那样使用 PC 相对寻址方式。处理器使用 PC 相对寻址方式，分支指令的编码会更简洁，同时这样也能允许代码从内存的一部分复制到另一部分而不需要更新所有的分支目标地址。因为我们更关心描述的简单性，所以就使用了绝对寻址方式。同 IA32 一样，所有整数采用小端法编码。当指令按照反汇编格式书写时，这些字节就以相反的顺序出现。

用十六进制来表示指令 rmmovq %rsp，0x12345678abcd（%rdx）的字节编码。rmmovq 的第一个字节位 40。源寄存器 %rsp 应该编码放在 rA 字段中，而基址寄存器 %rdx 应该编码放在 rB 字段中。所以得到寄存器指示符字节 42。最后，偏移量编码放在 8 字节的常数字中。首先在 0x123456789abcd 的前面填充上 0 变成 8 个字节，变成字节序列 00 01 23 45 67 89 ab cd 。写成按字节反序就是 cd ab 89 867 45 23 01 00。将它们都连接起来就得到指令的编码 4042cdab896745230100。

指令集的一个重要性质就是字节编码必须有唯一的解释。任意一个字节序列要么是一个唯一的指令序列的编码，要么就不是一个合法的字节序咧。y86-64 就具有这个性质，因为每条指令的第一个字节有唯一的代码和功能组合，给定这个字节，我们就可以决定所有其他附加字节的长度和含义。这个性质保证了处理器可以无二义性地执行目标代码程序。即使代码嵌入在程序的其他字节中，只要从序列的第一个字节开始处理，我们让然可以很容易确定指令序列。反过来说，如果不知道一段代码序列的起始位置，我们就不能准确地确定怎样将序列划分成单独的指令。对于试图直接从目标代码字节序列中抽取出机器级程序的反汇编程序和其他一些工具来说，这就带来了问题。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 5]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][20190115141942474.png]

###### 4.Y86-64 异常 ######

对 y86-64 来说，程序员可见的状态包括状态码 Stat，它描述程序执行的总体装填。这个代码可能的值如下图。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 8]  
代码值 1，命名为 AOK，表示程序执行正常，而其他一些代码则表示发生了某种类型的一场。代码2，命名为 HLT，表示处理器执行了一条 halt 指令。代码3，命名为 ADR，表示处理器试图从一个非法内存地址读或者向一个非法内存地址写，可能是当取指令的时候，也可能是当读或者写数据的时候。我们会限制最大的地址，任何访问超出这个限定值的地址都会引发 ADR 异常。代码4，命名为 INS，表示遇到了非法的指令代码。

对于 y86-64 ，当遇到这些异常的时候，我们就简单地让处理器停止执行指令。在更完整的设计中，处理器通常会调用一个`异常处理程序（exception handler）`，这个过程被指定用来处理遇到的某种类型的异常。就像在第 8 章中讲述的，异常处理程序可以被配置成不同的结果，例如，中止程序或者调用一个用户自定义的`信号处理程序（signal handler）`

###### 5.y86-64 程序 ######

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 10]

x86-64 代码是由 GCC编译器产生的。y86-64代码与之泪洗，但有以下不同点：

*  y86-64 将常数加载到寄存器（第 2~3行），因为它在算术指令中不能使用立即数。
 *  要实现从内存读取一个数值并将其与一个寄存器相加，y86-64 代码需要两条指令（第 8~9 行），而 x86-63 只需要一条 addq 指令（第 5 行）
 *  手工编写的 y86-64 实现有一个优势，即 subq 指令（第 11 行）同时还设置了条件码，因此 GCC 生成代码中的 testq 指令（第 9 行）就不是必需的。不过为此，y86-64 代码必须用 andq 指令（第 5 行）在进入循环之前设置条件码。

下图给出了用 y86-64 汇编代码编写的一个完整的程序文件的例子。这个程序既包括数据，也包括指令。伪指令（directive）指明应该将代码或数据放在什么位置，以及如何对齐。这个程序详细说明了栈的放置、数据初始化、程序初始化和程序结束等问题。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 12]

在这个程序中，以“·”开头的词是`汇编器伪指令（assembler directives）`，它们告诉汇编器调整地址，以便在那儿产生代码或插入一些数据。伪指令.pos 0（第 2 行）告诉汇编器应该从地址 0 处开始产生代码。这个地址是所有 y86-64 程序的起点。接下来的一条指令（第 3 行）初始化栈指针。我们可以看到程序结尾处（第 40 行）声明了标号 stack，并且用一个 .pos 伪指令（第 39 行）指明地址 0x200。因此栈会从这个地址开始，向低地址增长。我们必须保证栈不会增长得太大以至于覆盖了代码或者其他程序数据。

程序的第 8 ~ 13 行声明了一个 4 个字的数组，值分别为  
![在这里插入图片描述][20190115145224290.png]

标号 array 表明了这个数组的起始，并且在 8 字节边界处对齐（用.align伪指令指定）。第 16 ~ 19行给出了 “main”过程，在过程中对那个四字数组调用了 sum 函数，然后停止。

正如例子所示，由于我们创建 y86-64 代码的唯一工具是汇编器，程序员必须执行本来通常交给编译器、链接器和运行时系统来完成的任务。型号我们只用 y86-64 来写一些小的程序，对此一些简单的机制就足够了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 13]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 14]

上图是 YAS 的汇编器对代码进行汇编的结果。为了便于理解，汇编器的输出结果是 ASCII码格式。

我们实现了一个`指令集模拟器`，称为 YIS，它的目的是模拟 y86-64 机器代码程序的执行，而不用试图去模拟任何具体处理器实现的行为。这种形式的模拟有助于在有实际硬件可用之前调试程序，也有助于检查模拟硬件或者在硬件上运行程序的结果。用 YIS 运行例子的目标代码，产生输出如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 15]

模拟输出的第一行总结了执行以及 PC 和程序状态的结果值。模拟器只打印出在模拟过程中被改变了的寄存器或内存中的字。左边是原始值（这里都是 0），右边是最终的值。从输出我们可以看到，寄存器 %rax 的值为 0x0000abcdabcdabcd，即传给子函数 sum 的四元素数组的和。另外，我们还能看到栈从地质 0x200 开始，向下增长，栈的使用导致内存地址 0x1f0 ~ 0x1f8 发生了变化。可执行代码的最大地址为 0x090，所以数值的入栈和出栈不会破坏可执行代码。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 17]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 18]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 19]  
![在这里插入图片描述][20190115151606697.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 20]  
![在这里插入图片描述][20190115151920683.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 21]

###### 6.一些 y86-64 指令的详情 ######

大多数 y86-64 指令是以一种直接明了的方式修改程序状态的，所以定义每条指令想要达到的结果并不困难。不过，两个特别的指令的组合需要特别注意一下。

pushq 指令会把栈指针减 8 ，并且将一个寄存器值写入内存中。因此，当执行 pushq %rsp 指令时，处理器的行为是不确定的，因为要入栈的寄存器会被同一条指令修改。通常有两种不同的约定：1.压入 %rsp 的原始值，2.压入减去 8 的 %rsp 的值。

对于y86-64 处理器来说，我们采用和 x86-64 一样的做法，就像下面这个练习题确定出的那样。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 22]  
![在这里插入图片描述][2019011515240818.png]

对 popq %rsp 指令也有类似的歧义。可以将 %rsp 置为从内存中读出的值，也可以置为增加了增量后的栈指针。  
![在这里插入图片描述][20190115152559994.png]  
![在这里插入图片描述][20190115152604122.png]  
![在这里插入图片描述][20190115152609215.png]

#### 2 逻辑设计和硬件控制语言 HCL ####

在硬件设计中，用电子电路来计算对位进行运算的函数，以及在各种存储器单元中存储位。大多数现代电路技术都是用信号线上的高电压或低电压来表示不同的位置。在当前的技术中，逻辑 1 是用 1.0 V 左右的高电压表示，而逻辑 0 是用 0.0 V 左右的低电压表示。要实现一个数字系统需要三个主要的组成部分：计算对位进行操作的函数的组合逻辑、存储位的存储器单元，以及控制存储器单元更新的时钟信号。

本节简要描述这些不同的组成部分。我们还将介绍 HCL（Hardware Control Language，硬件控制语言），用这种语言来描述不同处理器设计的控制逻辑。

曾经，硬件 设计者通过描绘是示意性的逻辑电路图来进行电路设计（最早是用纸和笔，后来是用计算机图形终端）。现在，大多数设计都是用硬件描述语言（Hardware Description Language，HDL）来表达的。HDL 是一种文本表示，看上去和编程语言类似，但是它是用来描述硬件结构而不是程序行为的。最常用的语言是 Verilog，它的语法类似于 C；另一种是 VHDL，它的语法类似于编程语言 Ada。这些语言本来就是用来表示数字电路的模拟模型的。20 世纪 80 年代中期，研究者开发出了逻辑合成（logic synthesis）程序，它可以根据 HDL 的描述生成有效的电路设计。现在有许多商用的合成程序，已经成为产生数字电路的主要技术。从手工设计电路到合成生成的转变就好像从写汇编程序到写高级语言程序，再用编译器来产生机器代码的转变一样。

我们的 HCL 语言只表达硬件设计的控制部分，只有有限的操作集合，也没有模块化。不过，正如我们会看到的那样，控制逻辑是设计微处理器中最难的部分。

###### 1.逻辑门 ######

逻辑门是数字电路的基本计算单元。它们产生的输出，等于它们输入位值的某个布尔函数。下图是布尔函数 AND、OR 和 NOT 的标准符号，C 语言中运算符的逻辑门下面是对应的 HCL 表达式： AND 用 && 表示，OR 用 || 表示，而 NOT 用 ！ 表示。我们用这些符号而不用 C 语言中的位运算符 &、| 和 ~ ，这是因为逻辑门只对单个位的数进行操作，而不是整个字。虽然图中只说明了 AND 和 OR 的两个输入的版本，但是常见的是它们作为 n 路操作，n >2。不过，在 HCL 中我们还是把它们写作二元运算符，所以，三个输入的 AND 门，输入为 a、b 和 c，用 HCL 表示就是 a && b && c。

逻辑门总是活动的（active）。一旦一个门的输入变化了，在很短的时间内，输出就会相应地变化。![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 23]

###### 2.组合电路和 HCL 布尔表达式 ######

将很多的逻辑门组合成一个网，就能构建计算块（computational block），称为`组合电路（combinational circuits）`。如何构建这些网有几个限制：

*  每个逻辑门的输入必须连接到下述选项之一：一个系统输入，某个存储器单元的输出，某个逻辑门的输出
 *  两个或多个逻辑门的输出不能连接在一起。否则可能会使线上的信号矛盾，可能会导致一个不合法的电压或电路故障
 *  这个网必须是无环的。也就是在网中不能有路径经过一系列的门而形成一个回路，这样的回路会导致该网络计算的函数有歧义  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 24]  
    上图是一个我们觉得非常有用的简单这电路的例子。它有两个输入 a 和 b，有唯一的输出 eq，当 a 和b 都是 1 或都是 0 时，输出为 1。用 HCL 来写这个网的函数就是：  
    bool eq = （a && b）||（！a && ！b）；

这段代码简单地定义了位级信号 eq，它的输入 a 和 b 的函数。从这个例子可以看出 HCL 使用了 C 语言风格的语法，‘ = ’ 将一个信号名与一个表达式联系起来。不过同 C 不一样，我们不把它看成执行了一次计算并把结果放入内存中某个位置，它只是给表达式一个名字。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 25]

上图给出了另一个简单但很有用的组合电路，称为`多路复用器（multiplxor，通常称为“MUX”）`。多路复用器根据输入控制信号的值，从一组不同的数据信号中选出一个。在这个单个位的多路复用器中，两个数据信号是输入位 a 和 b，控制信号是输入位 s。当 s 为 1 时，输出等于 a；而当 s 为 0 时，输出等于 b。在这个电路中，我们可以看出两个 AND 门决定了是否将它们相对应的数据输入传送到 OR 门。当 s 为 1 时，上面的 AND 门将传送信号 b，当 s 为 1 时，下面的 AND 门将传送信号 a。接下里，我们来写输出信号的 HCL 表达式，使用的就是逻辑中相同的操作：

bool out = （s && a）||（！s && b）；

HCL 表达式很清楚地表明了组合逻辑电路和 C语言中逻辑表达式的对应之处。它们都是用布尔操作来对输入进行计算的函数。值得注意的是，这良种化表达计算的方法之间有以下区别：

*  因为组合电路是由一系列的逻辑门组成，它的属性是输出会持续地响应输入的变化。如果电路的输入变化了，在一定的延迟之后，输出也会相应地变化。相比之下，C 表达式只会在程序执行过程中被遇到时才进行求值
 *  C 的逻辑表达式允许参数是任意整数，0 表示 FALSE，其他任何值都表示 TRUE。而逻辑门只对位置 0 和 1 进行操作
 *  C 的逻辑表达式有个属性就是它们可能只被部分求值。如果一个 AND 或 OR 操作的结果只用对第一个参数求值就能确定，那么就不会对第二个参数求值了。例如下面的 C 表达式：（a && ！a） && func（b，c），这里函数 func 是不会被调用的，因为表达式（a && ！a）求值是 0 。而逻辑组合没有部分求值这条规则，逻辑门只是简单地响应输入的变化。

###### 3.字级的组合电路和 HCL 整数表达式 ######

通过将逻辑门组合成大的网，可以构造出能计算更加复杂函数的组合电路。通常，我们设计能对数据`字（word）`进行操作的电路。有一些位级信号，代表一个整数或一些控制模式。例如，我们的处理器设计将包含很多字，字的大小范围为 4 到 64 位，代表整数、地址、指令代码和寄存器标识符。

执行字级计算的组合电路根据输入的字的各个位，用逻辑门来计算输出字的各个位。例如下图中的一个组合电路，它测试两个 64 位字 A 和 B 是否相等。也就是，当且仅当 A 的每一位都和 B 的相应位相等时，输出才为 1。这个电路时用 64 个单个位相等电路实现的。这些单个位电路的输出用一个 AND 门连起来，形成了这个电路的输出。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 26]  
在 HCL 中，我们将所有字级的信号都声明为 int，不指定字的大小。这样做是为了简单。在全功能的硬件描述语言中，每个字都可以声明为特有的位数。HCL 允许比较字是否相等，因此上图的函数可以在字级上表达成 bool Eq = （A == B）；

这里参数 A 和 B 是 int 型的。注意我们使用和 C 语言中一样的语法习惯，‘ = ’表示赋值，而 ‘ == ’ 是相等运算符。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 27]  
上图是字级的多路复用器电路。这个电路根据控制输入位 s，产生一个 64 位的字 Out，等于两个输入字 A 或者 B 中的一个。这个电路由 64 个相同的子电路组成，每个子电路的结构都类似于位级多路复用器。不过这个字级的电路并没有简单的复制 64 次位级多路复用器，它只产生一次 ！s，然后在每个位的地方都重复使用它，从而减少非门（inverters）的数量。

处理器中会遇到很多种多路复用器，使得我们能根据某些控制条件，从许多源中选出一个字。在 HCL 中，多路复用函数是用`情况表达式（case expression）`来描述的。情况表达式的通用格式如下：  
![在这里插入图片描述][20190116202828176.png]  
这个表达式包含一系列的情况，每种情况 i 都有一个布尔表达式 select，和一个整数表达式 expr，前者表明什么时候该选择这种情况，后者指明的是得到的值。

同 C 的 switch 语句不同，我们不要求不同的选择表达式之间互斥。从逻辑上讲，这些选择表达式是顺序求值的，且第一个求值为 1 的情况会被选中。例如，上图的字级多路复用器用 HCL 来描述就是：  
![在这里插入图片描述][20190116203325894.png]  
在这段代码中，第二个选择表达式就是 1，表明如果前面没有情况被选中，那就选择这种情况。这是 HCL 中一种指定默认情况的方法。几乎所有的情况表达式都是以此结尾的。

允许不互斥的选择表达式使得 HCL 代码的可读性更好。实际的硬件多路服用器的信号必须互斥，它们要控制哪个输入字应该被传送到输出，就像 s 和 ！s。要将一个 HCL 情况表达式翻译成硬件，逻辑合成程序需要分析选择表达式集合，并解决任何可能的冲突，确保只有第一个满足的情况才会被选中。

选择表达式可以是任意的布尔表达式，可以有任意多的情况。这就使得情况表达式能描述带复杂选择标准的、多路输入信号的块。这个电路根据控制信号 s1 和 s0，从 4 个输入字 A、B、C 和 D 中选择一个，将控制信号看作一个两位的二进制数。我们可以用 HCL 来表示这个电路。用布尔表达式描述控制位模式的不同组合：  
![在这里插入图片描述][20190116203741920.png]  
![在这里插入图片描述][20190116203745630.png]  
右边的注释（任何以 \# 开头到行尾结束的文字都是注释）表明了 s1 和 s0 的什么组合会导致该种情况会被选中。可以看到选择表达式有时可以简化，因为只有 一个匹配的情况才会被选中。例如，第二个表达式可以写成 ！s1，而不用写的更完整 ！s1 && s0，因为另一种可能 s1 等于 0 已经出现在第一个选择表达式中了。类似的，第三个表达式可以写作 ！s0，而第四个可以简单得写成 1。

来看最后一个例子，假设我们想设计一个逻辑电路来找一组字 A、B 和 C 中的最小值，如下：  
![在这里插入图片描述][20190116204037149.png]  
用 HCL 来表达就是：  
![在这里插入图片描述][20190116204040870.png]  
![在这里插入图片描述][20190116204323936.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 28]

组合逻辑电路可以设计成字级数据上执行许多不同类型的操作。`算术/逻辑单元（ALU）`是一种很重要的组合电路，下图是它的一个抽象的图示。这个电路由三个输入：标号为 A 和 B 的两个数据输入，以及一个控制输入。根据控制输入的设置，电路会对数据输入执行不同的算术和逻辑操作。可以看到，这个 ALU 中画的四个操作对应于 y86-64 指令集支持的四种不同的整数操作，而控制值和这些操作的功能码相对应。我们还注意到减法的操作数顺序，是输入 B 减去输入 A。之所以这样做，是为了使这个顺序于 subq 指令的参数顺序一致。  
![在这里插入图片描述][20190116204810814.png]

###### 4.集合关系 ######

在处理器设计中，很多时候都需要将一个信号与许多可能匹配的信号做比较，以此来检测正在处理的某个指令代码是否属于某一类指令代码。下面来看个例子，假设想从一个两位信号 code 中选择高位和低位来产生四路复用器的控制信号 s1 和 s0  
![在这里插入图片描述][20190116205025187.png]  
在这个电路中，两位的信号 code 就可以用来控制对 4 个数据字 A、B、C 和 D 做选择。根据可能的 code 值，可以用相等测试来表示信号 s1 和 s0 的产生：  
![在这里插入图片描述][20190116205029175.png]  
还有一种更简洁的方式来表示这样的属性：当 code 在集合 \{2，3\} 中时 s1 为 1  
，而 code 在集合 \{1，3\}中时 s0 为 1：  
![在这里插入图片描述][20190116205032587.png]

###### 5.存储器和时钟 ######

组合电路本质上将，不存储任何信息。相反，它们只是简单地响应输入信号，产生等于输入的某个函数的输出。为了产生`时序电路（sequential circuit）`，也就是有状态并且在这个状态上进行计算的系统。我们必须引入按位存储信息的设备。存储设备都是由同一个`时钟`控制的，时钟是一个周期性信号，决定什么时候要把新值加载到设备中。考虑两类存储器设备：

*  `时钟寄存器（简称寄存器）`存储单个位或字。时钟信号控制寄存器加载输入值。
 *  随机访问存储器（简称内存）存储多个字，用地址来选择该读或该写哪个字。随机访问存储器的例子包括：1.处理器的虚拟内存系统，硬件和操作系统软件结合起来使处理器可以在一个很大的地址空间内访问任意的字；2.寄存器文件，在此，寄存器标识符作为地址。在 IA32 或 y86-64 处理器中，寄存器文件 15 个程序寄存器（%rax ~ %r14）。

正如我们看到的那样，在说到硬件和机器级编程时，“寄存器”这个词是两个有细微差别的事情。在硬件中，寄存器直接将它的输入和输出线连接到电路的其他部分。在机器级编程中，寄存器代表的是 CPU 中为数不多的可寻址的字，这里的地址是寄存器 ID。这些字通常都存在寄存器文件中，虽然我们会看到硬件有时直接将一个字从一个指令传送到另一个指令，以避免先写寄存器文件再读出来的延迟。需要避免歧义时了，我们会分别称呼这两类寄存器为“硬件寄存器”和“程序寄存器”。  
![在这里插入图片描述][20190116210422422.png]  
上图更详细地说明了一个硬件寄存器以及它是如何工作的。大多数时候，寄存器都保持在稳定状态（用 x 表示），产生的输出等于它的当前状态。信号沿着寄存器前面的组合逻辑传播，这时，产生了一个新的寄存器输入（用 y 表示），但是只要时钟是低电位的，寄存器的输出就仍然保持不变。当时钟变成高电位时候，输入信号就加载到寄存器中，成为下一个状态 y，直到下一个时钟上升沿，这个状态就一直是寄存器的新输出。关键是寄存器是作为电路不同部分中的组合逻辑之间的屏障。每当每个时钟到达上升沿时，值才会从寄存器的输入传送到输出。我们的 y86-64 处理器会用时钟寄存器保存程序计数器 PC、条件代码 CC 和程序状态 Stat。

下图展示了一个典型的寄存器文件：  
![在这里插入图片描述][20190116210827915.png]  
寄存器文件有两个`读端口（A 和 B）`，还有一个`写端口（W）`。这样一个`多端口`随机访问存储器允许同时进行多个读和写操作。图中所示的寄存器文件中，电路可以读两个程序寄存器的值，同时更新第三个寄存器的状态。每个端口都有一个地址输入，表明该选择哪个程序寄存器，另外还有一个数据输出或对应该程序寄存器的输入值。两个读端口有地址输入 srcA 和 srcB（“source A”和“source B”的缩写）和数据输出 valA 和 valB（“value A” 和 “value B”的缩写）。写端口有地址输入 dstW（“destination W”的缩写），以及数据输入 valW（“value W”的缩写）。

虽然寄存器文件不是组合电路，因为它有内部存储。不过，在我们的实现中，从寄存器文件读数据就好像它是一个以地址为输入、数据为输出的一个组合逻辑块。当 srcA 或 srcB 被设成某个寄存器 ID 时，在一段延迟之后，存储在相应程序寄存器的值就会出现在 valA 或 valB 上。例如，将 src A 设为 3，就会读出程序寄存器 %rbx 的值，然后这个值就会出现在输出 valA 上。

向寄存器文件写入字是由时钟信号控制的，控制方式类似于将值加载到时钟寄存器。每次时钟上升时，输入 valW 上的值会被写入输入 dstW 上的寄存器 ID 指示的程序寄存器。当 dstW 设为特殊的 ID 值 0xF 时，不会写任何程序寄存器。由于寄存器文件既可以读也可以写，一个很自然的问题就是“如果我们同时读和写同一个寄存器会怎么样？”，答案很简单：如果更新一个寄存器，同时在读端口上用同一个寄存器 ID，我们会看到一个从旧值到新值的变化。当我们把这个寄存器文件加入到处理器设计中，我们保证会考虑这个属性的。

处理器有一个随机访问存储器来存储数据数据，如下图：  
![在这里插入图片描述][2019011621180951.png]  
这个内存有一个地址输入，一个写的数据输入，以及一个读的数据输出。同寄存器文件一样，从内存中读的操作方式类似于组合逻辑：如果我们在输入 address 上提供一个地址，并将 write 控制信号设置为 0，那么在经过一些延迟以后，存储在那个地址上的值会出现在输出 data 上。如果地址超出了范围，error 信号会设置为 1，否则就设置为 0。写内存是由时钟控制的： 我们将 address 设置为期望的地址，将 data in 设置为i期望的值，而 write 设置为 1。然后当我们控制时钟时，只要地址是合法的，就会更新内存中指定的位置。对于读操作来说，如果地址是不合法的，error 信号会被设置为 1.这个信号是由组合逻辑产生的，因为所需要的边界检查纯粹就是地址输入的函数，不涉及保存任何状态。

我们的处理器还包括另外一个只读存储器，用来读指令。在大多数实际系统中，这两个存储器被合并为一个具有双端口的存储器：一个用来读指令，另一个用来读或者写数据。

#### 3. y86-64 的顺序实现 ####

现在已经有了实现 y86-64 处理器所需要的部件。首先，我们描述一个称为 SEQ（“sequential” 顺序的）的处理器。每个时钟周期上，SEQ 执行处理一条完整指令所需的所有步骤。不过，这需要一个很长的时钟周期时间，因此时钟周期频率可能会低到不可接受。我们开发 SEQ 的目标就是提供实现最终目的的第一步，我们的最终目的是实现一个高效的、流水线化的处理器。

###### 1.将处理组织成阶段 ######

通常，处理一条指令包括很多操作。将它们组织成某个特殊的阶段序列，即使指令的动作差异很大，但所有的指令都遵循统一的序列。每一步的具体处理取决于正在执行的指令。创建这样一个框架，我们就能够设计一个充分利用硬件的处理器。下面是关于各个阶段以及各阶段内执行操作的简略描述：

*  `取指（fetch）`：取指阶段从内存读取指令字节，地址为 PC 的值。从指令中抽取出指令指示符字节的两个四位部分，称为 icode（指令代码）和 ifun（指令功能）。它可能取出一个寄存器指示符字节，指明一个或两个寄存器操作数指示符 rA 和 rB。它还可能取出一个四字节常数字 valC。它按顺序方式计算当前指令的下一条指令的地址 valP。也就是说，valP 等于 PC 的值加上已取出指令的长度。
 *  `译码（decode）`：译码阶段从寄存器文件读入最多两个操作数，得到值 valA 和 / 或 valB。通常，它读入指令 rA 和 rB 字段指明的寄存器，不过有些指令是读寄存器 %rsp 的。
 *  `执行（execute）`：在执行阶段，算术/逻辑单元（ALU）要么执行指令指明的操作（根据 ifun 的值），计算内存引用的有效地址，要么增加或减少栈指针。得到的值我们称为 valE 。在此，也可能设置条件码。对一条条件传送指令来说，这个阶段会检验条件码和传送条件（由 ifun 给出），如果条件成立，则更新木雕寄存器。同样，对一条跳转指令来说，这个阶段会决定是不是应该选择分支。
 *  `访存（ memory）`：访存阶段可以将数据写入内存，或者从内存读出数据。读出的值为 valM。
 *  `写回（write back）`：写回阶段最多可以写两个结果到寄存器文件。
 *  `更新 PC（PC update）`：将 PC 设置成下一条指令的地址。

处理器无限循环，执行这些阶段。在我们简化的实现中，发生任何异常时，处理器就会停止：它执行 halt 指令或非法指令，或它试图读写非法地址。在更完整的设计中，处理器会进入异常处理模式，开始执行由异常的类型决定的特殊代码。

从前面的讲述中可以看出，执行一条指令是需要进行很多处理的。我们不仅必须执行指令所表明的操作，还必须计算地址、更新栈指针，以及确定下一条指令的地址。幸好每条指令的整个流程都比较相似。因为我们想使得硬件数量尽可能少，并且最终将把它映射到一个二维的集成电路芯片的表明，在设计硬件时，一个非常简单而一致的结构是非常重要的。降低复杂度的一种方法是让不同的指令共享尽量多的硬件。例如，我们的每个处理器设计都只含有一个算术/逻辑单元，根据所执行的指令类型的不同，它的使用方式也不同。在硬件上复制逻辑块的成本比软件中有重复代码的成本大得多。而且在硬件系统中处理许多特殊情况和特性要比用软件来处理困难得多。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 29]  
我们面临的一个挑战是将每条不同指令所需要的计算放入到上述那个通用框架中。我们会使用上图所示的代码来描述不同 y86-64 指令的处理。阅读时可以把它看成是从上至下的顺序求值。当我们将这些计算映射到硬件时，会发现其实并不需要严格按照顺序来执行这些求值。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 30]  
上图给出了对 OPq（整数和逻辑运算）、rrmovq（寄存器-寄存器传送）和irmovq（立即数-寄存器传送）类型的指令所需的处理。让我们先来考虑一下整数操作。我们小心地选择了指令编码，这样四个整数操作（addq、subq、andq 和 xorq）都有相同的 icode 值。我们可以以相同的步骤顺序来处理它们，除了 ALU 计算必须根据 ifun 中编码的具体的指令操作来设定。

整数操作指令的处理遵循上面列出的通用模式。在取指阶段，我们不需要常数字，所以 valP 就计算为 PC + 2。在译码阶段，我们要读两个操作数。在执行阶段，它们的功能指示符 ifun 一起再提供给 ALU，这样一来 valE 就成了指令结果。这个计算是用表达式 valB OP valA 来表达的，这里 OP 代表 ifun 指定的操作。要注意两个参数的顺序——这个顺序与 y86-64 的习惯是一致的。例如，指令 subq %rax，%rdx 计算的是 R\[%rdx\] - R\[%rax\] 的值。这些指令在访存阶段什么也不做，而在回写阶段，valE 被写入寄存器 rB，然后 PC 设为 valP，整个指令的执行就结束了。

作为一个例子，我们来看看一条 subq 指令的处理过。前面两条指令分别将寄存器 %rdx 和 %rbx 初始化成 9 和 21，指令位于地址 0x014，由两个字节组成，值分别为 0x61 和 0x23 。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 31]  
这个跟踪表明我们达到了理想的效果，寄存器 %rbx 设成了 12，三个条件码都设成了 0 ，而 PC 加了 2。

执行 rrmovq 指令和执行算术运算类似。不过，不需要取第二个寄存器操作数。我们将 ALU 的第二个输入设为 0，先把它和第一个操作数相加，得到 valE = valA，然后再把这个值写到寄存器文件。对 irmovq 的处理与此类似，除了 ALU 的第一个输入位常数值 valC。另外是长指令格式，对于 irmovq ，PC 必须加 10。所有这些指令都不改变条件码。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 32]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 33]  
下图给出了内存读写指令 rmmovq 和 mrmovq 所需要的处理。基本流程也和前面的一样，不过是用 ALU 来加 valC 和 valB ，得到内存操作的有效地址（偏移量于基址寄存器之和）。在访存阶段，会将寄存器值 valA 写到内存，或从内存中读出 valM。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 34]  
再看个例子，这个例子中寄存器 %rsp 初始化成了 128，而 %rbx 仍然是 subq 指令算出来的结果 12。指令位于地址 0x020，有 10 个字节。前两个值为 0x40 和 0x43，后 8 个是数字 0x0000000000000064 按字节反过来得到的数。各个阶段的处理如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 35]  
下图给出了处理 pushq 和 popq 指令所需的步骤。它们可以算是最难实现的指令了，因为它们既设计访问内存，又要 增加或减少栈指针。虽然这两天指令的流程比较相似，但是它们还是有很重要的区别。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 36]  
pushq 指令开始时很像我们前面讲过的指令，但是在译码阶段，用 %rsp 作为第二个寄存器操作数的标识符，将栈指针赋值为 valB。在执行阶段，用 ALU 将栈指针减 8。减过 8 的值就是内存写的地址，在写回阶段还会存回到 %rsp 中。将 valE 作为写操作的地址，是遵循 y86-64 的惯例，也就是在写之前，pushq 应该先让栈指针减去 8，即使栈指针的更新实际上是在内存操作完成之后才进行的。

下面这个例子中寄存器 %rdx 的值为 9，而寄存器 %rsp 的值为 128。我们还可以看到指令是位于地址 0x02a，有两个字节，值分别是 0xa0 和 0x2f。各个阶段的处理如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 37]  
popq 指令的执行与 pushq 的执行类似，除了在译码阶段要读两次栈指针以外。这样做看上去狠多余，但是我们会看到让 valA 和 valB 都存放栈指针的值，会使后面的流程跟其他的指令更相似，增强设计的整体一致性。在执行阶段，用 ALU 给栈指针加 8，但是没加过 8 的原始值作为内存操作的地址。在写回阶段，要用加过 8 的值作为内存读地址，保持了 y86-64 的惯例，popq 应该首先读内存，再增加栈指针。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 38]  
![在这里插入图片描述][20190117122452758.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 39]  
![在这里插入图片描述][20190117122502412.png]  
![在这里插入图片描述][20190117122508417.png]  
![在这里插入图片描述][20190117122513322.png]  
![在这里插入图片描述][20190117122517861.png]  
下图表明了三类控制转移指令的处理：各种跳转、call 和 ret 。可以看到，我们能用同前面指令一样的整体流程来实现这些指令。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 40]  
同对整数操作一样，我们更够以一种统一的方式处理所有的跳转指令，因为它们的不同只在于判断是否要选择分支的时候。除了不需要一个寄存器指示符字节以外，跳转指令在取指和译码阶段都和前面讲的其他指令类似。在执行阶段，检查条件码和跳转条件来确定是否要选择分支，产生出一个一位信号 Cnd。在更新 PC 阶段，检查这个标志，如果这个标志位 1，就将 PC 设为 valC （跳转目标），如果为 0，就设为 valP（下一条指令的地址）。我们的表示法 x? a : b 类似于C语句中的条件表达式——当 x 非零时，它等于 a，当 x 为零时，等于 b。

下面的例子中，指令位于地址 0x02e，有 9 个字节。第一个字节的值为 0x73，而剩下的 8 个字节是数字 0x0000000000000040 按字节反过来得到的数，也就是跳转的目标。各个阶段的处理如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 41]  
指令 call 和 ret 指令 pushq 和 popq 类似，除了我们要将 PC 的值入栈和出栈以外。对指令 call ，我们要将 valP，也就是 call 指令后紧跟着的那条指令的地址，压入栈中。在更新 PC 阶段，将 PC 设为 valC，也就是调用的目的地。对指令 ret，在更新 PC 阶段，我们将 valM ，即从栈中取出的值，赋值给 PC。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 42]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 43]  
我们创建了一个统一的框架，能处理所有不同类型的 y86-64 指令。虽然指令的行为大不相同，但是我们可以将指令的处理组织成 6 个阶段。现在我们的任务是创建硬件设计来实现这些阶段，并把它们连接起来。

下面这个例子中，指令的地址是 0x041，只有一个字节的编码，0x90。前面的 call 指令将 %rsp 置为了 120，并将返回地址 0x040 存放在了内存地址 120 中。各个阶段的处理如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 44]

###### 2. SEQ硬件结构 ######

实现所有 y86-64 所需要的计算可以被组织成 6 个基本阶段：取指、译码、执行、访存、写回 和 更新 PC。下图给出一个能执行这些计算的硬件结构的抽象表示。程序计数器放在寄存器中，在图中左下角（PC）。然后，信息沿着线流动（多条线组合在一起就用宽一点的灰线来表示），先向上，在向右。同各个阶段相关的`硬件单元（hardware units）`负责执行这些处理。在右边，反馈线路向下，包括要写到寄存器文件的更新值，以及更新的 PC 值。在 SEQ 中，所有硬件单元的处理都在一个时钟周期内完成。这张图省略了一些小的组合逻辑块，还省略了所有用来操作各个硬件单元以及将相应的值路由到这些单元的控制逻辑。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 45]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 46]  
硬件单元与各个处理阶段相关联：  
`取指`：将 PC 寄存器作为地址，指令内存读取指令的字节。PC 增加器（PC incrementer）计算 valP，即增加了的 PC。  
`译码`：寄存器文件有两个读端口 A 和 B，从这两个端口同时读寄存器值 valA 和 valB。  
`执行`：执行阶段会根据指令的类型，将算术/逻辑单元（ALU）用于不同的目的。对证书操作，它要执行指令所指定的运算。对其他指令，它会作为一个加法器来计算增加或减少栈指针，或者计算有效地址，或者只是简单的加 0 ，将一个输入传递到输出。

条件码寄存器（CC）有三个条件码位。ALU 负责计算条件码的新值。当执行条件传送指令时，根据条件码和传送条件来计算决定是否更新目标寄存器。同样，当执行一条跳转指令时，会根据条件码和跳转类型来计算分支信号 Cnd。  
`访存`：在执行访存操作时，数据内存读出或写入一个内存字。指令和数据内存访问的是相同的内存位置，但是用于不同的目的。  
`写回`：寄存器文件有两个写端口。端口 E 用来写 ALU 计算出来的值，而端口 M 用来写从数据内存中读出的值。  
`PC 更新`：PC 的新值选择自：valP，下一条指令的地址：valC，调用指令或跳转指令指定的目标地址：valM，从内存读取的返回地址。

下面更详细的给出了实现 SEQ 所需要的硬件：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 47]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 48]  
我们看到一组和前面一样的硬件单元，但是现在线路更看得清楚了，下面是画图惯例  
【颜色看不清。。。】：

*  `白色方框表示时钟寄存器。`PC 是 SEQ 中唯一的时钟寄存器。
 *  `浅蓝色方框表示硬件。`这包括内存、ALU等。在我们所有的处理器实现中，都会使用这一组基本的单元。我们把这些单元当做“黑盒子”，不关心它们的细节设计。
 *  `控制逻辑块用灰色圆角矩形表示。`这些块用来从一组信号源中进行选择，或者用来计算一些布尔函数。我们会非常详细地分析这些块，包括给出 HCL 描述。
 *  `宽度为字长的数据连接用中等粗度的线表示。`每条这样的线实际上都代表一簇 64 根线，并列地连在一起，将一个字从硬件的一个部分传送到另一部分。
 *  `宽度为字节或更窄的数据连接用细线表示。`根据线上要携带的值的类型，每条这样的线实际上都代表一簇 4 或 8 根线。
 *  `单个位的连接用虚线来表示。`这代表芯片上单元于块之间传递的控制值。

下图展示出了之前展示的意外，还列出了四个寄存器 ID 信号：srcA、valA 的源；srcB、valB 的源；dstE，写入 valE 的寄存器；以及 dstM，写入 valM 的寄存器。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 49]  
上图中，右边两栏给出的是指令 OPq 和 mrmovq 的计算，来说明要计算的值。要将这些计算映射到硬件上，我们要实现控制逻辑，它能在不同硬件单元之间传送数据，以及操作这些单元，使得对每个不同的指令执行指定的运算。这就是控制逻辑块的目标，我们的任务就是依次经过每个阶段，创建这些块的详细设计。

###### 3.SEQ 的时序 ######

介绍之前的表格时，曾说过要把它们看成是用程序符号写的，那些赋值是从上到下顺序执行的。然而，硬件结构的操作运行根本完全不同，一个时钟变化会引发一个经过组合逻辑的流，来执行整个指令。接下来看看这些硬件怎么实现表中列出的这一行为。

SEQ 的实现包括组合逻辑和两种存储设备：时钟寄存器（PC 和 条件码寄存器），随机访问存储器（存储器文件，指令内存 和 数据内存）。组合逻辑不需要任何时序或控制——只要输入变化了，值就通过逻辑门网络传播。正如提到过的那样，我们也将随机访问存储器看成和组合逻辑一样的操作，根据地址出入产生输出字。对于较小的存储器来说（例如寄存器文件），这是一个合理的假设，而对于较大的电路来说，可以用特殊的时钟电路来模拟这个效果。由于指令内存只用来读指令，因此我们可以将这个单元看成是组合逻辑。

现在还剩四个硬件单元需要对它们的时序进行明确的控制——PC、条件码寄存器、数据内存 和 寄存器文件。这些单元通过一个时钟信号来控制，它触发将新值装载到寄存器以及将值写到随机访问存储器。每个时钟周期，PC 都会装载新的指令地址。只有在执行整数运算指令时，才会装载条件码寄存器。只有在执行 rmmovq 、 pushq 或 call 指令时，才会写数据内存。寄存器文件的两个写端口允许每个时钟周期更新两个程序寄存器，不过我们可以用特殊的寄存器 ID 0xF作为端口地址，来表明此端口不应该执行写操作。

要控制处理器中活动的时序，只需要寄存器和内存的时钟控制。硬件获得了上面表格中所示的那些赋值顺序执行一样的效果，即使所有的状态更新实际上同时发生，且只在时钟上升开始下一个周期时。之所以能保持这样的等价性，是由于 y86-64 指令集的本质，因为我们遵循以下原则组织计算：

原则：从不回读  
`处理器从来不需要为了完成一条指令的执行而去读由该指令更新了的状态。`

这条原则对实现的成功来说至关重要。为了说明问题，假设我们对 pushq 指令的实现是先将 %rsp 减 8，再将更新后的 %rsp 值作为写操作的地址。这种同前面所说的那个原则相违背。为了执行内存操作，它需要先从寄存器文件中读更新过的栈指针。然而，我们的实现产生出减后的栈指针值，作为信号 valE，然后再用这个信号既作为寄存器写的数据，也作为内存写的地址。因此，在时钟上升开始下一个周期时，处理器就可以同时执行寄存器写和内存写了。

再举个例子，我们可以看到有些指令（整数运算）会设置条件码，有些指令（跳转指令）会读取条件码，但没有指令必须既设置又读取条件码。虽然要到时钟上升开始下一个周期时，才会设置条件码，但是在任何指令试图读之前，它们都会更新。

以下是汇编代码，左边列出的是指令地址。  
![在这里插入图片描述][20190117160635364.png]  
标号为 1 ~ 4 的各个图给出了 4 个状态单元，还有组合逻辑，以及状态单元之间的连接。组合逻辑被条件码寄存器环绕着，因为有的组合逻辑（例如 ALU）产生输入到条件码寄存器，而其他部分（例如分支计算和 PC 选择器）又将条件码寄存器作为输入。图中寄存器文件和数据内存有独立的读连接和写连接，因为读操作沿着这些单元传播，就好像它们是组合逻辑，而写操作是由时钟控制的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 50]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 51]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 52]  
上图中的不同颜色的代码表明电路信号是如何与正在被执行的不同指令相联系的。我们假设处理是从设置条件码开始的，按照 ZF、SF 和 OF 的顺序，设为 100。在时钟周期 3 开始的时候（点1），状态单元保持的是第二条 irmovq 指令更新过的状态，该指令用浅灰色表示。组合逻辑用白色表示，表明它还没有来得及对变化了的状态做出反应。时钟周期开始时，地址 0x014 载入PC中。这样就会取出和处理 addq 指令。值沿着组合逻辑流动，包括读随机访问存储器。在这个周期末尾（点2），组合逻辑为条件码产生了新的值（000），程序寄存器 %rbx 的更新值，以及 PC 的新值（0x016）。在此时，组合逻辑已经根据 addq 指令被更新了，但是状态还是保持着第二条 irmovq 指令（浅灰色）设置的值。

当时钟上升开始周期4时（点3），会更新 PC、寄存器文件和条件码寄存器，因此我们用蓝色来表示，但是组合逻辑还没有对这些变化做出反应，所以用白色表示。在这个周期内，会取出并执行 je 指令，在图中用深灰色表示。因为条件码 ZF 为0，所以不会选择分支。在这个周期末尾（点4），PC 已经产生了新值 0x01f。组合逻辑已经根据 je 指令被更新过了，但是直到下一个周期开始之前，状态还是保持着 addq 设置的值。

如此例，用时钟来控制状态单元的更新，以及值通过组合逻辑来传播，足够控制我们 SEQ 实现中每条指令执行的计算了。每次时钟由低变高时，处理器开始执行一条新指令。

###### 4.SEQ 阶段的实现 ######

本节会设计实现 SEQ 所需要的控制逻辑块的 HCL 描述。

我们使用的常数如下：![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 53]  
nop 指令只是简单的经过各个阶段，除了要将 PC 加 1，不进行任何处理。halt 指令使得处理器状态被设置为 HLT，导致处理器停止运行。

`1.取指阶段`  
如下图，取指阶段包括指令内存硬件单元。以 PC 作为第一个字节（字级 0）的地址，这个单元一次从内存读出 10 个字节。第一个字节被解释成指令字节，（标为 Split 单元）分成两个 4 位的数。然后，标号为 icode 和 ifun 的控制逻辑块计算指令和功能码，或者使之等于从内存读出的值，或者当指令地址不合法时（由信号 imem\_error 指明），使这些值对应于 nop 指令。根据 icode 的值，我们可以计算三个一位的信号（用虚线表示）：  
instr\_valid： 这个字节对应于一个合法的指令吗？这个信号是用来发现不合法的指令。  
need\_regids：这个指令包括一个寄存器指示符字节吗  
need\_valC：这个指令包括一个常数字吗？  
（当指令地址越界时会产生的）信号 instr\_valid 和 imem\_error 在访存阶段被用来产生状态码。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 54]

让我们再来看一个例子，need\_regids 的 HCL 描述只是确定了 icode 的值是否为一条带有寄存器指示值字节的指令。  
![在这里插入图片描述][20190117162924645.png]  
![在这里插入图片描述][20190117163014532.png]  
![在这里插入图片描述][20190117163019958.png]  
如图所示，从指令内存中读出的剩下 9 个字节是寄存器指示符字节和常数字的组合编码。标号为 Align 的硬件单元会处理这些字节，将它们放入寄存器字段和常数字中。当被计算出的信号 need\_regids 为 1 时，字节 1 被分开装入寄存器指示符 rA 和 rB 中。否则，这两个字段会被设为 0xF（NONE），表明这条指令没有指明寄存器。回想一下，任何只有一个寄存器操作数的指令，寄存器指示值字节的另一个字段都设为 0xF。因此，可以将信号 rA 和 rB 看成，要么放着我们想要访问的寄存器，要么表明不需要访问任何寄存器。这个标号为 Align 的单元还产生常数字 valC。根据信号 need\_regids 的值，要么根据字节 1 ~ 8 来产生 valC，要么根据字节 2 ~ 9 来产生。

PC 增加器硬件单元根据当前的 PC 以及两个信号 need\_regids 和 need\_valC 的值，产生信号 valP。对于 PC 值p、need\_regids值 r 以及 need\_valC 值 i，增加器产生值 p + 1 + r + 8i。

`2.译码和写回阶段`  
下图给出了 SEQ 中实现译码和写回阶段的逻辑的详情。把这两个阶段联系在一起是因为它们都要访问寄存器文件。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 55]  
寄存器文件有四个端口。它支持同时进行两个读（在端口 A 和 B上）和两个写（在端口 E 和 M 上）。每个端口都有一个地址连接和一个数据连接，地址连接是一个寄存器 ID，而数据连接是一组 64 根线路，既可以作为寄存器文件的输出字（对读端口来说），也可以作为它的输入字（对写端口来说）。两个读端口的地址输入位 srcA 和 srcB，而两个写端口的地址输入位 dstE 和 dstM。如果某个地址端口上的值为特殊标识符 0xF，则表明不需要访问寄存器。

根据指令代码 icode 以及寄存器指示值 rA 和 rB，可能还会根据执行阶段计算出的 Cnd 条件信号，上上图底部的四个块产生出四个不同的寄存器文件的寄存器 ID。寄存器 ID srcA 表明应该读哪个寄存器以产生 valA。srcA 的 HCL 描述如下（回想 RRSP 是 %rsp 的寄存器 ID）：  
![在这里插入图片描述][20190117164413290.png]  
![在这里插入图片描述][20190117164508225.png]  
![在这里插入图片描述][20190117164513771.png]  
寄存器 ID dstE 表明写端口 E 的目的寄存器，计算出来的值 valE 将放在那里。dstE 的 HCL 描述：  
![在这里插入图片描述][20190117164610672.png]  
我们查看执行阶段时，会重新审视这个信号，看看如何实现条件传送。  
![在这里插入图片描述][20190117164659480.png]![在这里插入图片描述][20190117164719959.png]  
`3.执行阶段`  
执行阶段包括算术/逻辑单元（ALU）。这个单元根据 alufun 信号的设置，对输入 aluA 和 aluB 执行 ADD、SUBTRACT、AND 或 EXCLUSIVE-OR 运算。如下图，这些数据和控制信号是由三个控制块产生的。ALU 的输出就是 valE 信号。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 56]  
列出操作数 ALUB 在前面，后面是 ALUA，这样是为了保证 subq 指令是 valB 减去 valA。可以看到，根据指令的类型， ALUA 的值可以是 valA、valC，或者 -8 或 +8。因此我们可以用下面的方式来表达产生 ALUA 的控制块的行为：  
![在这里插入图片描述][20190117165817857.png]  
![在这里插入图片描述][20190117165858706.png]![在这里插入图片描述][20190117165902684.png]  
观察 ALU 在执行阶段的操作，可以看到它通常作为加法器来使用。不过，对于 OPq 指令，我们希望它使用指令 ifun 字段中编码的操作。因此，可以将 ALU 控制的 HCL 描述写成：  
![在这里插入图片描述][20190117170019975.png]  
执行阶段还包括条件码寄存器。每次运行时，ALU 都会产生三个与条件码相关的信号——零、符号 和 溢出。不过，我们只希望在执行 OPq 指令时才设置条件码。因此产生了一个信号 set\_cc 来控制是否该更新条件码寄存器：  
![在这里插入图片描述][20190117170258130.png]  
标号为 cond 的硬件单元会根据条件码和功能码来确定是否进行条件分支或者条件数据传送。它产生信号 Cnd，用于设置条件传送的 dstE，也用在条件分支的下一个 PC 逻辑中。对于其他指令，取决于指令的功能码和条件码的设置，Cnd 信号可以被设置为 1 或者 0。但是控制逻辑会忽略它。我们省略这个单元的详细设计。  
![在这里插入图片描述][20190117170952577.png]  
![在这里插入图片描述][20190117170957733.png]  
`4.访存阶段`  
访存阶段的任务就是读或者写程序数据。如下图，两个控制块产生内存地址和内存输入数据（为写操作）的值。另外两个块产生表明应该执行读操作还是写操作的控制信号。当执行读操作时，数据内存产生值 valM。

内存读写的地址总是 valE 或 valA。这个块用 HCL 描述就是：  
![在这里插入图片描述][20190117171301386.png]![在这里插入图片描述][20190117171351422.png]  
![在这里插入图片描述][20190117171423991.png]  
我们希望只为从内训读数据的指令设置控制信号 mem\_read ，用 HCL 代码表示就是：  
![在这里插入图片描述][20190117171520954.png]  
![在这里插入图片描述][20190117171638758.png]  
![在这里插入图片描述][20190117171702128.png]  
访存阶段最后的功能是根据取值阶段产生的 icode、imem\_error、instr\_valid 值以及数据内存产生的 dmem\_error 信号，从指令执行的结果来计算状态码 Stat。  
![在这里插入图片描述][20190117171848367.png]  
![在这里插入图片描述][20190117171852989.png]  
`5.更新 PC 阶段`  
SEQ 中最后一个阶段会产生 PC 的新值。新的 PC 可能是 valC、valM 或 valP。用 HCL 来描述这个选择就是：  
![在这里插入图片描述][20190117185446833.png]![在这里插入图片描述][20190117185450998.png]  
`6. SEQ 小结`  
现在我们已经浏览了 y86-64 处理器的一个完整的设计。可以看到，通过将执行每条不同指令所需的步骤组织成一个统一的流程，就可以用很少量的各种硬件单元以及一个时钟来控制计算的顺序，从而实现整个处理器。不过这样一来，控制逻辑就必须要在这些单元之间路由信号，并根据指令类型和分支条件产生适当的控制信号。

SEQ 唯一的为题就是它太慢了。时钟必须非常慢，以使信号能在一个周期内传播所有的阶段。让我们来看看处理一条 ret 指令的例子。在时钟周期起始时，从更新过的 PC 开始，要从指令内存中读出指令，从寄存器文件中读出栈指针，ALU 将栈指针加 8，为了得到 PC 的下一个值，还要从内存中读出返回地址。所以这一切都必须在这个周期结束之前完成。

这种实现方法不能充分利用硬件单元，因为每个单元只在整个时钟周期的一部分时间内才被使用。我们会看到引入流水线能获得更好的性能。

#### 4 流水线的通用原理 ####

在试图设计一个流水线化的 y86-64 处理器之前，让我们先来看看流水线化的系统的一些通用属性和原理。对于曾经在自助餐厅的服务线上工作过或者开车通过自动汽车清洗线的人，都会非常熟悉这种系统。在流水线化的系统中，待执行的任务被划分成了若干个独立的阶段。在自助餐厅，这些阶段包括提供沙拉、主菜、甜点以及饮料。在一个典型的自助餐厅流水线上，顾客按照相同的顺序经过各个阶段，即使他们并不需要某些菜。在汽车清洗的情况中，当前面一辆汽车从喷水阶段进入擦洗阶段时，下一辆就可以进入喷水阶段了。通常，汽车必须以相同的速度通过这个系统，避免撞车。

流水线化的一个重要特性就是提高了系统的`吞吐量（throughput）`，也就是单位时间内服务的顾客总数，不过它也会轻微地增加`延迟（latency）`，也就是服务一个用户所需要的时间。例如，自助餐厅里的一个需要甜点的顾客，能很快通过一个非流水线化的系统，只在甜点阶段停留。但是在流水线化的系统中，这个顾客如果试图直接去甜点阶段就有可能招致其他顾客的愤怒了。

###### 1.计算流水线 ######

让我们把注意力放到计算流水线上来，这里的“顾客”就是指令，每个阶段完成指令执行的一部分。下图a中的给出了一个很简单的非流水线化的硬件系统例子。它是由一些执行计算的逻辑以及一个保存计算结果的寄存器组成的。时钟信号控制在每个特定的时间间隔加载寄存器。CD 播放器中的译码器就是这样的一个系统。输入信号是从 CD 表面读出的位，逻辑电路对这些位进行译码，产生音频信号。图中的计算块是用组合逻辑来实现的，意味着信号会穿过一系列的逻辑门，在一定时间的延迟之后，输出就成为了输入的某个函数。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 57]  
在现代逻辑设计中，电路延迟以`皮秒（简称“ps”）`，也就是10的-12次方秒为单位来计算。在这个例子中，我们假设组合逻辑需要 300 ps，而加载寄存器需要 20 ps。上图还给出了一种时序图，称为`流水线图`。在图中，时间从左向右流动。从上到下写着一组操作。实心的长方形表示这些指令执行的时间。这个实现中，在开始下一条指令之前必须完成前一个。因此，这些方框在垂直方向上并没有相互重叠。下面这个公式给出了运行这个系统的最大吞吐量：  
![在这里插入图片描述][20190117191458768.png]  
我们以每秒千兆条指令（GIPS），也就是每秒十亿条指令，为单位来描述吞吐量。从头到尾执行一条指令所需要的时间称为`延迟（latency）`。在此系统中，延迟为 320 ps，也就是吞吐量的倒数。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 58]  
假设将系统执行的计算分成三个阶段（A、B和C），每个阶段需要 100 ps，如下图。然后在各个阶段之间放上`流水线寄存器（pipeline register）`，这样每条指令都会按照三步经过这个系统，从头到尾需要三个完整的时钟周期。上图中的流水线图所示，只要 I1 从 A 进入到 B，就可以让 I2 进入阶段 A 了，以此类推。在稳定状态下，三个阶段都应该是活动的，每个时钟周期，一条指令离开系统，一条新的进入。从流水线图中第三个时钟周期就能看出这一点，此时， I1 是在阶段 C， I2 是在阶段 B，而 I3 是在阶段 A。在这个系统中，我们将时钟周期设为 100 + 20 = 120 ps，得到的吞吐量大约为 8.33 GIPS。因为处理一条指令需要 3 个时钟周期，所以这条流水线的延迟就是 3 \* 120 = 360 ps。我们将系统吞吐量提高到原来的 8.33 / 3.12 = 2.67 倍，代价是增加了一些硬件，以及延迟的少量增加。延迟变大是由于增加的流水线寄存器的时间开销。

###### 2.流水线操作的详细说明 ######

为了更好地理解流水线是怎样工作的，让我们来详细看看流水线计算的时序和操作。下图给出了前面看到过的三阶段流水线的流水线图。就像流水线图上方指明的那样，流水线阶段之间的指令转移是由时钟信号来控制的。每隔 120 ps，信号从 0 上升至 1，开始下一组流水线阶段的计算，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 59]  
下图跟踪了时刻 240 ~ 360 之间的电路活动，指令 I1 经过阶段 C， I2 经过阶段 B，而 I3 经过阶段 A。就在时刻 240（点1）时钟上升之前，阶段 A 中计算的指令 I2 的值已经到达第一个流水线寄存器的输入，但是该寄存器的状态和输出还保持为指令 I1 在阶段 A 中计算的值。指令 I1 在阶段 B 中计算的值已经到达第二个流水线寄存器的输入。当时钟上升时，这些输入被加载到流水线寄存器中，称为寄存器的输出（点2）。另外，阶段 A 的输入被设置成发起指令 I3 的计算。然后信号传播通过各个阶段的组合逻辑（点3）。就像图中点 3 处的曲线化的波阵面表明的那样，信号可能以不同的速率通过各个不同的部分。在时刻 360 之前，结果值到达流水线寄存器的输入（点4）。当时刻 360 时钟上升时，各条指令会前进经过一个流水线阶段。![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 60]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 61]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 62]  
从这个对流水线操作详细的描述中，我们可以看到减缓时钟不会影响流水线的行为。信号传播到流水线寄存器的输入，但是直到时钟上升时才会改变寄存器的状态。另一方面，如果时钟运行的太块，就会有灾难性的后果。值可能会来不及通过组合逻辑，因此当时钟上升时，寄存器的输入还不是合法的值。

根据对 SEQ 处理器时序的讨论，我们看到这种在组合逻辑块之间采用时钟寄存器的简单机制，足够控制流水线中的指令流。随着时钟周而复始地上升和下降，不同的指令就会通过流水线的各个阶段，不会相互干扰。

###### 3.流水线的局限性 ######

上面的例子给出了一个理想的流水线化的系统，在这个系统中，我们可以将计算分成三个相互独立的阶段，每个阶段需要的时间是原来逻辑需要时间的三分之一。不幸的是，会出现其他一些因素，降低流水线的效率。

`1.不一致的划分`  
下图展示的系统和前面不一样，我们将计算划分为三个阶段，但是通过这些阶段的延迟从 50 ps 到 150 ps 不等。通过所有阶段的延迟和仍然为 300 ps。不过，运行时中的速率是由最慢的阶段的延迟限制的。流水线图表明，每个时钟周期，阶段 A 都会空闲 100 ps，而阶段 C 会空闲 50 ps。只有阶段 B 会一直处于活动状态。我们必须将时钟周期设为 150 + 20 = 170 ps，得到吞吐量为 5.88 GIPS。另外，由于时钟周期减慢了，延迟也增加到了 510 ps。

对硬件设计这来说，将系统计算设计划分成一组具有相同延迟的阶段时一个严峻的挑战。通常，处理器中的某些硬件单元，如 ALU 和 内存，是不能被划分成多个延迟较小的单元的。这就使得创建一组平衡的阶段非常困难。在设计流水线化的 y86-64 处理器中，我们不会过多关注这一层细节，但是理解时序优化在实际系统设计中的重要性还是非常重要的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 63]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 64]  
`2.流水线过深，收益反而下降`  
下图说明了流水线技术的另一个局限性。在这个例子中，我们把计算分成了 6 个阶段，每个阶段需要 50 ps。在每对阶段之间插入流水线寄存器就得到一个六阶段流水线，这个系统的最小时钟周期为 50 + 20 = 70 ps，吞吐量为 14.29 GIPS。因此，通过将流水线的阶段书加倍，我们将性能提高了 14.29 / 8.33 = 1.71 。虽然我们将每个计算时钟的时间缩短了两倍，但是由于通过流水线寄存器的延迟，吞吐量并没有加倍。这个延迟成了流水线吞吐量的一个制约因素。在我们的新设计中，这个延迟占到了整个时钟周期的 28.6 %。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 65]  
为了提高时钟频率，现代处理器采用了很深的流水线（15或者更多）。处理器架构师将指令的执行划分成很多非常简单的步骤，这样一来每个阶段的延迟就很小。电路设计者小心地设计流水线寄存器，使其延迟尽可能的小。芯片设计者也必须小心的设计时钟传播网络，以保证时钟在整个芯片上同时改变。所有这些都是设计高速微处理器面临的挑战。  
![在这里插入图片描述][20190117195544478.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 66]

###### 4.带反馈的流水线系统 ######

到目前为止，我们只考虑一种系统，其中穿过流水线的对象，不论是汽车、人活着指令，相互都是完全独立的。但是，相邻指令之间很可能是相关的。比如：  
![在这里插入图片描述][20190117195833355.png]  
在这个包含三条指令的序列中，每对相邻的指令之间都有`数据相关（data dependency）`，用带圈的寄存器名字和它们之间的箭头来表示。irmovq 指令将它的结果存放在 %rax 中，然后 addq 指令要读这个值；而 addq 指令将它的结果存放在 %rbx 中，mrmovq 指令要读这个值。

另一种相关是由于指令控制流造成的顺序相关。看看下面这个指令序列：  
![在这里插入图片描述][20190117195836763.png]  
jne 指令产生了一个`控制相关（control dependency）`，因为条件测试的结果会决定要执行的新指令是 irmovq 指令还是 halt 指令。在我们的 SEQ 设计中，这些相关都是由反馈路径来解决的，这些反馈将更新了的寄存器值向下传送到寄存器文件，将新的 PC 值向下传送到 PC 寄存器。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 67]  
上图举例说明了将流水线引入含有反馈路径的系统中的危险。在原来的系统中，每条指令的结果都反馈给下一条指令。流水线图就说明了这个情况， I1 的结果成为 I2 的输入，以此类推。如果试图以最直接的方式将它转换成一个三阶段流水线，我们将改变系统的行为。如上图c，I1 的结果成为 I4 的输入。为了通过流水线技术加速系统，我们改变了系统的行为。

当我们将流水线技术引入处理器时，必须正确处理反馈的影响。很明显，想上图中的例子那样改变系统的行为是不可接受的。我们必须以某种方式来处理指令间的数据和控制相关，以使得到的行为于 ISA 定义的模型相符。

#### 5 y86-64 的流水线实现 ####

我们终于准备好开始本章的主要任务——设计一个流水线化的 y86-64 处理器。首先，对顺序的 SEQ 处理器做一点小的改动，将 PC 的计算挪到取指阶段。然后，在各个阶段之间加上流水线寄存器。到这个时候，我们的尝试还不能正确处理各种数据和控制相关。不过，做一些修改，就能实现我们的目标——一个高效的、流水线化的实现 y86-64 ISA 处理器。

###### 1. SEQ+ ： 重新安排计算阶段 ######

作为实现流水线化设计的一个过渡步骤，我们必须稍微调整一下 SEQ 中五个阶段的顺序，使得更新 PC 阶段在一个时钟周期开始执行，而不是结束时才执行。只需要对整体硬件结构做最小的改动，对于流水线阶段中的活动的时序，它能工作的更好。我们称修改过的设计为 “ SEQ +”。

我们移动 PC 阶段，使得它的逻辑在时钟周期开始时活动，使它计算当前指令的 PC 值。下图给出了 SEQ 和 SEQ+ 在 PC 计算上的不同之处。在 SEQ 中，PC 计算发生在时钟周期结束的时候，根据当前时钟周期计算出的信号值来计算 PC 寄存器的新值。在 SEQ+ 中，我们创建状态寄存器来保存在一条指令执行过程中计算出来的信号。然后，当一个新的时钟周期开始时，这些信号值通过同样的逻辑来计算当前指令的 PC。我们将这些寄存器标号为 pIcode、pCnd 等等，来指明在任意给定的周期，它们保存的是前一个周期中产生的控制信号。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 68]

`SEQ+ 中的 PC 在哪里`  
SEQ + 有一个很奇怪的特色，那就是没有硬件寄存器来存放 PC。而是根据从前一条指令保存下俩的一些状态信息动态地计算 PC。这就是一个小小的证明——我们可以以一种与 ISA 隐含着的概念模型不同的方式来实现处理器，只要处理器能够正确执行任意的机器语言程序。我们不需要将状态编码成程序员可见的状态指定的形式，只要处理器能够为任意的程序员可见状态产生正确的值。在创建流水线化的设计中，我们会更多地使用到这条原则。之后描述的乱序（out-of-order）处理技术，以一种完全不同于机器级程序中出现的顺序的次序来执行指令，将这一思想发挥到了极致。

SEQ 到 SEQ+ 中队状态单元的改变是一种很通用的改进的例子，这种改进称为`电路重定时（circuit retiming）`。重定时改变了一个系统的状态表示，但是并不改变它的逻辑行为。通常用它来平衡一个流水线系统中各个阶段之间的延迟。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 69]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 70]

###### 2.插入流水线寄存器 ######

在创建一个流水线化的 y86-64 处理器的最初尝试中，我们要在 SEQ+ 的各个阶段之间插入流水线寄存器，并对信号重新排列，得到 PIPE-处理器，这里的“ - ”代表这个处理器和最终的处理器设计相比，性能要差一点。PIPE - 的抽象结构如下图。流水线寄存器在该图中用黑色方框表示，每个寄存器包括不同的字段，用白色方框表示。每个流水线寄存器可以存放多个字节和字。同两个顺序处理器的硬件结构中的圆角方框不同，这些白色的方框表示实际的硬件组成。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 71]

可以看到，PIPE - 使用了与顺序设计 SEQ 几乎一样的硬件单元，但是有流水线寄存器分隔开这些阶段。两个系统中信号的不同之处在之后讨论。

流水线寄存器按如下方式标号：  
F ： 保存 PC 的预测值  
D ： 位于取指和译码阶段之间。它保存关于最新取出的指令的信息，即将由译码阶段进行处理  
E ： 位于译码和执行阶段之间。它保存关于最新译码的指令和寄存器文件读出的值的信息，即将由执行阶段进行处理  
M ： 位于执行和访存阶段之间。它保存最新执行的指令的结果，即将由访存阶段进行处理。它还保存关于处理条件转移的分支条件和分支目标的信息  
W ： 位于访存阶段和反馈路径之间，反馈路径将计算出来的值提供给寄存器文件写，而当完成 ret 指令时，它还要向 PC 选择逻辑提供返回地址

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 72]  
图中右边给出了这个指令序列的流水线图。这个图描述了每条指令通过流水线各个阶段的行进过程，时间从左往右增大。上面一条数字表明各个阶段发生的时钟周期。例如，在周期 1 取出指令 I1，然后它开始通过流水线各个阶段，到周期 5 结束后，其结果写入寄存器文件。在周期 2 取出指令 I2，到周期 6 结束后，其结果写回，以此类推。在最下面，我们给出了当周期为 5 时的流水线的扩展图。此时，每个流水线阶段中各有一条指令。

从上图还可以判断我们画处理器的习惯是合理的，这样，指令是自底向上的流动的。周期 5 时的扩展图表明的流水线阶段，取指阶段在底部，写回阶段在最上面。如果看看流水线各个阶段中指令的顺序，会发现它们出现的顺序与在程序中列出的顺序一样。因为正常的程序是从上到下列出的，我们保留这种顺序，让流水线从下到上进行。

###### 3.对信号进行重新排列和标号 ######

顺序实现 SEQ 和 SEQ+ 在一个时刻只处理一条指令，因此诸如 valC、srcA 和 valE 这样的信号值有唯一的值。在流水线化的设计中，与各个指令相关联的这些值由多个版本，会随着指令一起流过系统。例如，在 PIPE - 的详细结构中，由 4 个标号为 Stat 的白色方框，保存着 4 条不同指令的状态码。我们需要很小心以确保使用的是正确版本的信号，否则会有很严重的错误，例如，将一条指令计算出的结果存放到了另一条指令指定的目的寄存器。我们采用的命名机制，通过在信号名前面加上大写的流水线寄存器名字作为前缀，存储在流水线寄存器中的信号可以唯一地被标志。例如，4 个状态码可以被命名为 D\_stat、E\_stat、M\_stat 和 W\_stat。我们还需要引用某些在一个阶段内刚刚计算出来的信号。它们的命名是在信号名前面加上小写的阶段名的第一个字母作为前缀。以状态码为例，可以看到在取指和访存阶段中标号为 Stat 的控制逻辑块，因而，这些块的输出被命名为 f\_stat 和 m\_stat 。我们还可以看到整个处理器的实际状态 Stat 是根据流水线寄存器 W 中的状态值，由写回阶段中的块计算出来的。

*  信号 M\_stat 和 m\_stat 的差别  
    在命名系统中，大写的前缀 D、E、M 和 W 指的是流水线寄存器，所以 M\_stat 指的是流水线寄存器 M 的状态码字段。小写的前缀 f、d、e、m 和 w 指的是流水线阶段，所以 m\_stat 指的是在访存阶段中由控制逻辑块产生出的状态信号。

SEQ+ 和 PIPE - 的译码阶段都产生信号 dstE 和 dstM，它们指明值 valE 和 valM 的目的寄存器。在 SEQ+ 中，我们可以将这些信号直接连到寄存器文件写端口的地址输入。在 PIPE - 中，会在流水线中一直携带这些信号穿过执行和访存阶段，直到写回阶段才送到寄存器文件。我们这样做是为了确保写端口的地址和数据输入是来自同一条指令。否则，会将处于写回阶段的指令的值写入，而寄存器 ID 却来自处于译码阶段的指令。作为一条通用原则，我们要保存处于一个流水线阶段中的指令的所有信息。

PIPE - 中有一个块在相同表示形式的 SEQ+ 中时没用的，那就是译码阶段中标号为 Select A 的块。我们可以看出，这个块会从来自流水线寄存器 D 的 valP 或从寄存器文件 A 端口中读出的值中选择一个，作为流水线寄存器 E 的值 valA。包括这个块是为了减少要携带给流水线寄存器 E 和 M 的状态数量。在所有的指令中，只有 call 在访存阶段需要 valP 的值。只有跳转指令在执行阶段（当不需要进行跳转）需要 valP的值。而这些指令又都不需要从寄存器文件中读出的值。因此我们合并这两个信号，将它们作为信号 valA 携带穿过流水线，从而可以减少流水线寄存器的状态数量。这样做就消除了 SEQ 和 SEQ+ 中标号为 Data 的块，这个块完成的是类似的功能。在硬件设计上，像这样仔细确认信号是如何使用的，然后通过合并信号来减少寄存器状态和线路的数量，是很常见的。

我们的流水线寄存器包括一个状态码 stat 字段，开始时是在取指阶段计算出来的，在访存阶段有可能会被修改。在讲完正常指令执行的实现之后，我们会在之后讨论如何实现异常事件的处理。到目前为止我们可以说，最系统的方法就是让每条指令关联的状态码与指令一起通过流水线。

###### 4.预测下一个 PC ######

在 PIPE - 设计中，我们采取了一些措施来正确处理控制相关。流水线化设计的目的就是每个时钟周期都`发射`一条新指令，也就是说每个时钟周期都有一条新指令进入执行阶段并最终完成。要是达到这个目的就意味着吞吐量是每个时钟周期一条指令。要做到这一点，我们必须在取出当前指令之后，马上确定下一条指令的位置。不幸的是，如果取出的指令是条件分支指令，要到几个周期后，也就是指令通过执行阶段之后，我们才能知道是否要选择分支。类似地，如果取出的指令是 ret，要到指令通过访存阶段，才能确定返回地址。

除了条件转移指令 和 ret 以外，根据取指阶段中计算出的信息，我们能够确定下一条指令的地址。对于 call 和 jmp 来说，下一条指令的地址是指令中常数字 valC，而对于其他指令来说就是 valP。因此，通过预测 PC 的下一个值，在大多数情况下，我们能达到每个时钟周期发射一条新指令的目的。对于大多数指令类型来说，我们的预测是完全可靠的。对条件转移来说，我们既可以预测选择了分支，那么新 PC 值应为 valC ，也可以预测没有选择分支，那么新 PC 值应为 valP。无论哪种情况，我们都必须以某种方式来处理预测错误的情况，因为此时已经取出并部分执行了错误的指令。我们在之后来讨论这个问题。

猜测分支方向并根据猜测开始取指的技术成为`分支预测`。实际上所有的处理器都采用了某种形式的此类技术。对于预测是否选择分支的有效策略已经进行了广泛的研究。有的系统花费了大量硬件来解决这个任务。我们的设计只使用了简单的策略，即总是预测选择了条件分支，因而预测 PC 的新值为 valC。

我们还没有讨论预测 ret 指令的新 PC 值。同条件转移不同，此时可能的返回值几乎是无限的，因为返回地址是位于栈顶的字，其内容可以是任意的。在设计中，我们不会试图对返回地址做任何预测。只是简单地暂时处理新指令，直到 ret 指令通过写回阶段。

`使用栈的返回地址预测`  
对于大多数程序来说，预测返回值很容易，因为过程调用和返回时成对出现的。大多数函数调用，会返回到调用后的那条指令。高性能处理器中运用了这个属性，在取指单元中放入一个硬件栈，保存过程调用指令产生的返回地址。每次执行过程调用指令时，都将其返回地址压入栈中。当取出一个返回指令时，就从这个栈中弹出顶部的值，作为预测的返回值。同分支预测一样，在预测错误时必须提供一个恢复机制，因为还是有调用和返回不匹配的时候。通常，这种预测很可靠。这个硬件栈对程序员来说是不可见的。

PIPE - 的取指阶段，负责预测 PC 的下一个值，以及为取指选择实际的 PC。我们可以看到，标号为 Predict PC 的块会从 PC 增加器计算出的 valP 和取出的指令中得到的 valC 中进行选择。这个值存放在流水线寄存器 F 中，作为 PC 的`预测值`。标号为 Select PC 的块类似于 SEQ+ 的PC 选择阶段中标号为 PC 的块。它从三个值中选择一个作为指令内存的地址：预测的 PC，对于到达流水线寄存器 M 的不选择分支的指令来说是 valP 的值（存储在寄存器 M\_valA 中），或是当 ret 指令到达流水线寄存器 W（存储在 W\_valM）时的返回地址的值。

###### 5.流水线冒险 ######

PIPE - 结构是创建一个流水线化的 y86-64 处理器的好开端。不过，将流水线基础引入一个带反馈的系统，当相邻指令间存在相关时会导致出现问题。在完成设计之前必须解决这个问题。有些相关有两种形式：1.`数据相关`，下一条指令会用到这一条指令计算出的结果 2.`控制相关`，一条指令要确定下一条指令的位置，例如在执行跳转、调用或返回指令时。这些相关可能会导致流水线产生计算错误，称为`冒险（hazard）`。同相关一样，冒险也可以分为两类：`数据冒险（data hazard）`he `控制冒险（control hazard）`。我们首先关心的是数据冒险，然后再考虑控制冒险。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 73]  
上图描述的是 PIPE- 处理器处理 prog1 指令序列的情况。假设在这个例子以及后面的例子中，程序寄存器初始值都为 0。这段代码将值 10 和 3 放入程序寄存器 %rdx 和 %rax，执行三条 nop 指令，然后将寄存器 %rdx 加到 %rax 。我们重点关注两条 irmovq 指令和 addq 指令之间的数据相关造成的可能的数据冒险。图的右边是这个指令序列的流水线图。图中显示了周期 6 和 7 的流水线阶段。流水线图的下面是周期 6 中写回活动和周期 7 中译码活动的扩展说明。在周期 7 开始以后，两条 irmovq 都已经通过写回阶段，所以寄存器文件保存着更新过的 %rdx 和 %rax 的值。因此，当 addq 指令在周期 7 经过译码阶段时，它可以读到源操作数的正确值。在此示例中，两条 irmovq 指令 和 addq 指令之间的数据相关没有造成数据冒险。

我们看到prog1 通过流水线得到了正确的结果，因为 3 条 nop 指令在有数据相关的指令之间创造了一些延迟。让我们来看看如果去掉这些 nop 指令会发生些什么。下图描述的是 prog2 程序的流水线程序，在两条产生寄存器 %rdx 和 %rax 值的 irmovq 指令和以这两个寄存器作为操作数的 addq 指令之间有两条 nop 指令。在这种情况下，关键步骤发生在周期 6，此时 addq 指令从寄存器文件中读取它的操作数。该图底部是这个周期内流水线活动的扩展描述。第一个 irmovq 指令已经通过了写回阶段，因此程序寄存器 %rdx 已经在寄存器文件中更新过了。在该周期内，第二个 irmovq 指令处于写回阶段，因此对程序寄存器 %rax 的写要到周期 7 开始，时钟上升时，才会发生。结果，会读出 %rax 的错误值（回想一下，我们假设所有的寄存器的初始值为 0），因为对寄存器的写还未发生。很明显，我们必须改进流水线让它能正确处理这样的冒险。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 74]  
下图是当 irmovq 指令和 addq 指令之间只有一条 nop 指令，即为程序 prog3 时，发生的情况。现在我们检查周期 5 内流水线的行为，此时 addq 指令通过译码阶段。不幸的是，对寄存器 %rdx 的写仍处在写回阶段，而对寄存器 %rax 的写还处在访存阶段，因此，addq 指令会得到两个错误的操作数。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 75]  
下图去掉了所有的 nop 指令。现在检查周期 4 内流水线的行为，此时 addq 指令通过译码阶段，不幸的是，对寄存器 %rdx 的写仍处在访存阶段，而执行阶段正在计算寄存器 %rax 的新值。因此，addq 指令的两个操作数都是不正确的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 76]  
这些例子说明，如果一条指令的操作数被它前面三条指令中的任意一条改变的话，都会出现数据冒险。之所以会出现这种冒险，是因为我们的流水线化的处理器是在译码阶段从寄存器文件中读取指令的操作数，而要到三个周期以后，指令经过写回阶段时，才会将指令的结果写到寄存器文件中。

`数据冒险的类型`  
当一条指令更新后面指令会读到的那些程序状态时，就有可能出现冒险。对于 y86-64 来说，程序状态包括程序寄存器、PC、内存、条件码寄存器和状态寄存器。

*  程序寄存器：刚刚的例子已经认识这种冒险了。出现这种冒险是因为寄存器文件的读写实在不同的阶段进行的，导致不同指令之间可能出现不希望的相互作用
 *  PC：更新和读取 PC 之间的冲突导致了控制冒险。当我们取指阶段逻辑在取下一条指令之前，正确预测了 PC 的新值时，就不会产生冒险。预测错误的分支和 ret 指令需要特殊的处理
 *  内存：对数据内存的读写都发生在访存阶段。在一条读内存的指令到达这个阶段之前，前面所有要写内存的指令都已经完成这个阶段了。另外，在访存阶段中写数据的指令和取指阶段中读指令之间也有冲突，因为指令和数据内存访问的是同一个地址空间。只有包含自我修改代码的程序才会发生这种情况，在这样的程序中，指令写内存的一部分，过后会从中取出指令。有些系统有复杂的机制来检测和避免这种冒险，而有些系统知识简单地强制要求程序不应该使用自我修改代码。
 *  条件码寄存器：在执行阶段中，整数操作会写这些寄存器。条件传送指令会在执行阶段以及条件转移会在访存阶段读这些寄存器。在条件传送或转移到达执行阶段之前，前面所有的整数操作都已经完成这个阶段了。所以不会发生冒险。
 *  状态寄存器：指令流经流水线的时候，会影响程序状态。我们采用流水线中的每条指令都与一个状态码相关联的机制，使得当异常发生时，处理器能够有条理地停止。

这些分析表明我们只需要处理寄存器数据冒险、控制冒险，以及确保能够正确处理异常。当设计一个复杂系统时，这样的分类分析是很重要的。这样做可以确认出系统实现中可能的困难，还可以指导生成用于检查系统正确性的测试程序。

`1.用暂停来避免数据冒险`  
`暂停（stalling）`是避免冒险的一种常用技术，暂停时，处理器会停止流水线中一条或多条指令，直到冒险条件不再满足。让一条指令停顿在译码阶段，直到产生它的源操作数的指令通过了写回阶段，这样我们的处理器就能避免数据冒险。这种机制的细节之后讨论。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 77]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 78]  
上图中，当指令 addq 处于译码阶段时，流水线控制逻辑发现执行、访存或写回阶段中至少有一条指令会更新寄存器 %rdx 或 %rax。处理器不会让 addq 指令带着不正确的结果通过这个阶段，而是会暂停指令，将它阻塞在译码阶段，时间为一个周期或者三个周期。这样，addq 指令最终都会在周期 7 中得到两个源操作数的正确值，然后继续沿着流水线进行下去。

将 addq 指令阻塞在译码阶段时，我们还必须将紧跟其后的 halt 指令阻塞在取指阶段。通过将 PC 保持不变就能做到这一点，这样一来，会不断地对 halt 指令进行取指，直到暂停结束。

暂停技术就是让一组指令阻塞在它们所处的阶段，而允许其他指令继续通过流水线。那么在本该正常处理 addq 指令的阶段中，我们该做些什么呢？我们使用的处理方法是：每次要把一条指令阻塞在译码阶段，就在执行阶段插入一个气泡。气泡就像一个自动产生的 nop 指令——它不会改变寄存器、内存、条件码或程序状态。我们用一个 addq 指令的标号为 D 的方框到标号为 E的方框之间的箭头来表示一个流水线气泡，这些箭头表明，在执行阶段中插入气泡是为了代替 addq 指令，它本来应该经过译码阶段进入执行阶段。

虽然实现这一机制相当容易，但是得到的性能并不好。一条指令更新一个寄存器，紧跟其后的指令就使用被更新的寄存器，像这样的情况不胜枚举。这会导致流水线暂停长达三个周期，严重降低了整体的吞吐量。

`用转发来避免数据冒险`  
PIPE- 的设计是在译码阶段从寄存器文件中读入源操作数，但是对这些源寄存器的写有可能要在写回阶段才能进行。与其暂停知道写完成，哺乳简单地将要写的值传到流水线寄存器 E 作为源操作数。下图用 prog2 周期 6 流水线图的扩展描述来说明这一策略。译码阶段逻辑发现，寄存器 %rax 是操作数 valB 的源寄存器，而在写端口 E 上还有一个对 %rax 的未进行的写。它只要简单地将提供到端口 E 的数据字作为操作数 valB 的值，就能避免暂停。这种将结果值直接从一个流水现阶段传到较早阶段的技术成为`数据转发（data forwarding，简称转发，或旁路（bypassing））`。它使得 prog2 的指令能通过流水线而不需要任何暂停。数据转发需要在基本的硬件结构中增加一些额外的数据连接和控制逻辑。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 79]  
下图中，当访存阶段中有对寄存器未进行的写时，也可以使用数据转发，以避免程序 prog3 中的暂停。在周期 5 中，译码阶段逻辑发现，在写回阶段中端口 E 上有对寄存器 %rdx 未进行的写，以及在访存阶段中有会在端口 E 上对寄存器 %rax 未进行的写。它不会暂停知道这些写真正发生，而是用写回阶段汇总的值（W\_valE）作为操作数 valA，用访存阶段中的值（M\_valE）作为操作数 valB。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 80]

为了充分利用数据转发技术，我们还可以将新计算出来的值从执行阶段传到译码阶段，以避免程序 prog4 所需要的暂停，如下图。在周期 4 中，译码阶段逻辑发现在访存阶段中有对寄存器 %rdx 未进行的写，而且执行阶段中 ALU 正在计算的值稍后也会写入寄存器 %rax。它可以将访存阶段中的值（M\_valE）作为操作数 valA，也可以将 ALU 的输出（e\_valE）作为操作数 valB。注意，使用 ALU 的输出不会造成任何时序问题。译码阶段只要在时钟周期结束之前产生信号 valA 和 valB，这样在时钟上升开始下一个周期时，流水线寄存器 E 就能装载来自译码阶段的值了。而在此之前 ALU 的输出已经是合法的了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 81]  
程序 prog2 ~ prog4 中描述的转发技术的使用都是将 ALU 产生的以及其目标为写端口 E 的值进行转发，其实也可以转发从内存中读出的以及其目标为写端口 M 的值。从访存阶段，我们可以转发刚刚从数据内存中读出的值（m\_valM）。从写回阶段，我们可以转发对端口 M 未进行的写（w\_valM）。这样一共就有五个不同的转发源（e\_valE、m\_valM、M\_valE、W\_valM 和 W\_valE），以及两个不同的转发目的（valA 和 valB）。

译码阶段逻辑能够确定是使用来自寄存器文件的值，还是要转发过来的值。与每个要写回寄存器文件的值相关的是目的寄存器 ID。逻辑会将这些 ID 与源寄存器 ID srcA 和 srcB 相比较，以此来检测是否需要转发。可能有多个目的寄存器 ID 与 一个源 ID 相等。要解决这样的情况，我们必须在各个转发源中建立起优先级关系。

`3.加载/使用数据冒险`  
有一类数据冒险不能单纯用转发来解决，因为内存读在流水线发生的比较晚。下图说明了`加载/使用冒险（load/use hazard）`，其中一条指令（mrmovq）从内存中读出寄存器 %rax 的值，而下一条指令（addq）需要该值作为源操作数。图的下部是周期 7 和 8 的扩展说明，在此假设所有的程序寄存器都初始化为 0。addq 指令在周期 7 中需要该寄存器的值，但是 mrmovq 指令直到周期 8 才产生出这个值。为了从 mrmovq “转发到” addq，转发逻辑不得不将值送回到过去的时间！这显然不可能，我们必须找其他机制来解决这种形式的数据冒险。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 82]

如下图，我们可以将暂停和转发结合起来，避免加载/使用数据冒险。这个需要修改控制逻辑，但是可以使用现有的旁路路径。当 mrmovq 指令通过执行阶段时，流水线控制逻辑发现译码阶段中的指令（addq）需要从内存中读出的结果。它会将译码阶段中的指令暂停一个周期，导致执行阶段中插入一个气泡。如周期 8 的扩展说明所示，从内存中读出的值可以从访存阶段转发到译码阶段中的 addq 指令。寄存器 %rbx 的值也可以从访存阶段转发到译码阶段。就像流水线图，从周期 7 中标号为 D 的方框到周期 8 中标号为 E 的方框的箭头表明的那样，插入的气泡代替了正常情况下本来应该继续通过流水线的 addq 指令。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 83]  
这种用暂停来处理加载/使用冒险的方法称为`加载互锁（load interlock）`。加载互锁和转发技术结合起来足以处理所有可能类型的数据冒险。因为只有加载互锁会降低流水线的吞吐量，我们几乎可以实现每个时钟周期发射一条新指令的吞吐目标。

`4.避免控制冒险`  
当处理器无法根据处于取指阶段的当前指令来确定下一条指令的地址时，就会出现控制冒险。控制冒险只会发生在 ret 指令和跳转指令。而且，后一种情况只有在条件跳转方向预测错误时才会造成麻烦。

对于 ret 指令，考虑下面的示例程序。这个程序时用汇编代码表示的，左边是各个指令的地址  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 84]  
下图给出了我们希望流水线如何来处理 ret 指令。同前面的流水线图一样，这幅图展示了流水线的活动，时间从左向右增加。与前面不同的是，指令列出的顺序与它们在程序中出现的顺序并不相同，这是因为这个程序的控制流中指令并不是按线性顺序执行的。看看指令的地址就能看出它们在程序中的位置。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 85]  
在周期 3 中取出 ret 指令，并沿着流水线前进，在周期 7 进入写回阶段。在它经过译码、执行和访存阶段时，流水线不能做任何有用的活动。我们只能在流水线中插入三个气泡。一旦 ret 指令到达写回阶段， PC 选择逻辑就会将程序计数器设为返回地址，然后取指阶段就会取出位于返回点（0x013）处的 irmovq 指令。

要处理预测错误的分支，考虑下面这个用汇编代码表示的程序，左边是各个指令的地址  
![在这里插入图片描述][2019011815122442.png]  
下图表明是如何处理这些指令的。同前面一样，指令按照它们进入流水线的顺序列出的，而不是按照它们出现在程序中的顺序。因为预测跳转指令会选择分支，所以周期 3 中会取出位于跳转目标处的指令，而周期 4 中会取出该指令后的那条指令。在周期 4，分支逻辑发现不应该选择分支之前，已经取出了两条指令，它们不应该继续执行下去了。幸运的是，这两天指令都没有导致程序员可见的状态发生改变。只有到指令到达执行阶段时才会发生那种情况，在执行阶段中，指令会改变条件码。我们只要在下一个周期往译码和执行阶段中插入气泡，并同时去除跳转指令后面的指令，这样就能`取消`那两条预测错误的指令。这样一来，两条预测错误的指令就会简单地从流水线中消失，因此不会对程序员可见的状态产生影响。唯一的缺点就是两个时钟周期的指令处理能力被浪费了。

对于控制冒险的讨论表明，通过慎重考虑流水线的控制逻辑，控制冒险是可以被处理的。在出现特殊情况的时候，暂停和往流水线中插入气泡的技术可以动态调整流水线的流程。对基本时钟寄存器设计的简单扩展就可以让我们暂停流水段，并向作为流水线控制逻辑部分的流水线寄存器中插入气泡。

###### 6.异常处理 ######

处理器很多事情都会导致异常控制流，此时，程序执行的正常流程被破坏掉。异常可以由程序执行从内部产生，也可以由某个外部信号从外部产生。我们的指令体系结构包括三种不同的内部产生的异常：1. halt 指令，2.有非法指令和功能码组合的指令 3.取指或数据读写试图访问一个非法地址。一个更完整的处理器设计应该也能处理外部异常，例如当处理器的一个网络接口收到新包的信号，或是一个用户点击鼠标按钮的信号。正确处理异常时任何微处理器设计中很有挑战性的一方面。异常可能出现在不可预测的时间里，需要明确地中断通过处理器流水线的指令流。我们对这三种内部异常的处理只是让你对正确发现和处理异常的真实复杂性略有了解。

我们把导致异常的指令称为`异常指令（excepting instruction）`。在使用非法指令地址的情况中，没有实际的异常指令，但是想象在非法地址处有一种“虚拟指令”会有所帮助。在简化的 ISA 模型中，我们希望当处理器遇到异常时，会停止，设置适当的状态码，应该是到异常指令之前的所有指令都已经完成，而其后的指令都不应该对程序员可见的状态产生任何影响。在一个更完整的设计中，处理器会继续调用`异常处理程序（exception handler）`，这是操作系统的一部分，但是实现异常处理的这部分超出了本书讲述的范围。

在一个流水线化的系统中，异常处理包括一些细节问题。首先，可能同时有多条指令会引起异常。例如，在一个流水线操作的周期内，取指阶段中有 halt 指令，而数据内存会报告访存阶段中的指令数据地址越界。我们必须确定处理器应该向操作系统报告哪个异常，基本原则是：由流水线中最深的指令引起的异常，优先级最高。在上面那个例子中，应该报告访存阶段中指令的地址越界。就机器语言程序来说，访存阶段中的指令本来应该在取指阶段中的指令开始之前就结束的，所以，只应该向操作系统报告这个异常。

第二个细节问题是，当首先取出一条指令，开始执行时，导致了一个异常，而后来由于分支预测错误，取消了该指令。下面就是一个程序示例的目标代码：  
![在这里插入图片描述][20190118154453634.png]  
在这个程序中，流水线会预测选择分支，因此它会取出并以一个值为 0xFF 的字节作为指令（由汇编代码中.byte伪指令产生的）。译码阶段会因此发现一个非法指令异常。稍后，流水线会发现不应该选择分支，因此根本呢就不应该取出位于地址 0x016 的指令。流水线控制逻辑会取消该指令，但是我们想要避免出现异常。

第三个细节问题的产生是因为流水线化的处理器会在不同的阶段更新系统状态的不同部分。有可能出现这样的情况，一条指令导致了一个异常，它后面的指令在异常指令完成之前改变了部分状态。比如说，下面的代码序列，其中假设不允许用户程序访问 64 位范围的高端地址：  
![在这里插入图片描述][20190118154953808.png]  
pushq 指令导致一个地址异常，因为减小栈指针会导致它绕回到 0xfffffffffffffff8。访存阶段中会发现这个异常。在同一周期中，addq 指令处于执行阶段，而它会将条件码设置成新的值。这就会违反异常指令之后的所有指令都不能影响系统状态的要求。

一般地，通过在流水线结构中加入异常处理逻辑，我们既能够从各个异常中做出正确的选择，也能够避免出现由于分支预测错误取出的指令造成的异常。这就是为什么我们会在每个流水线寄存器中包括一个状态码 stat。如果一条指令在其处理中于某个阶段产生了一个异常，这个状态字段就被设置成指示异常的种类。异常状态和该指令的其他信息一起沿着流水线传播，直到它到达写回阶段。在此，流水线控制逻辑发现出现了异常，并停止执行。

为了避免异常指令之后的指令更新任何程序员可见的状态，当处于访存或写回阶段中的指令导致异常时，流水线控制逻辑必须禁止更新条件码寄存器或是数据内存。在上面的示例程序中，控制逻辑会发现访存阶段中的 pushq 导致了异常，因此应该禁止 addq 指令更新条件码寄存器。

让我们来看看这种处理异常的方法是怎样解决刚才提到的那些细节问题的。当流水线中有一个或多个阶段出现异常时，信息只是简单地存放在流水线寄存器的状态字段中。异常事件不会对流水线中的指令流有任何影响，除了会禁止流水线中后面的指令更新程序员可见的状态（条件码寄存器和内存），直到异常指令到达最后的流水线阶段。因为指令到达写回阶段的顺序与它们在非流水线化的处理器中执行的顺序相同，所以我们可以保证第一条遇到异常的指令会第一个到达写回阶段，此时程序执行会停止，流水线寄存器 W 中的状态码会被记录为程序状态。如果取出了某条指令，过后又取消了，那么所有关于这条指令的异常状态信息也都会被取消。所有导致异常的指令后面的指令都不能改变程序员可见的状态。携带指令的异常状态以及所有其他信息通过流水线的简单原则是处理异常的简单可靠的机制。

###### 7.PIPE 各阶段的实现 ######

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70]: /images/20220326/45d6b4cfcca840a2811fad9643e34840.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 1]: /images/20220326/dededed796aa41ae9680944bb357db2c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 2]: /images/20220326/36bc09027dee4197b18efd2c2c793283.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 3]: /images/20220326/2db8c5e90b334bfdac3c7cf1d693bb4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 4]: /images/20220326/046fcf8dce574b68a01a34e24eb00b9c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 5]: /images/20220326/585f31901fb74b23bc12fba4f7be35c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 6]: /images/20220326/0fd75a192a454602a9a5a7cd0c1181f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 7]: /images/20220326/c5e015c2d31f4abab7a20ff4a75a8de5.png
[20190115141942474.png]: /images/20220326/c1c750942b434b13bee20caefb8eb59e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 8]: /images/20220326/424b3b47474e44c48ff6f057bfc6bcc8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 9]: /images/20220326/aa8179255de247be8df105f552cd7c98.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 10]: /images/20220326/071198fc9b154340bfece6592a666d1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 11]: /images/20220326/45b472b7e08840d881b21ed93f9b1f3d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 12]: /images/20220326/f5a4b578990c4585bf43d45e457a9bdc.png
[20190115145224290.png]: /images/20220326/97c7c753d1844463aa32729a6478a28d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 13]: /images/20220326/dc675bf2676b4735a4dbad55bb2d12c7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 14]: /images/20220326/56baf2b805aa4db085b5a535dbc36c36.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 15]: /images/20220326/2f9c4f76d9bc4e73b8e347e13da4fccf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 16]: /images/20220326/a8e1b52262f6448e8a282688b23e8583.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 17]: /images/20220326/fec7f93aa9a245d5b15ccfefb370befa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 18]: /images/20220326/4d9f7da958084bb2bacbb73fb8fc9939.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 19]: /images/20220326/6ab138c30e1a4044a7e1fb80b99372d6.png
[20190115151606697.png]: /images/20220326/b367bcc42ed9496d8a9aa319decf3363.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 20]: /images/20220326/d4cfd5f27d8345abac7ce756313b2bb8.png
[20190115151920683.png]: /images/20220326/0cbf8f81b30b426187de19cd3c5314f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 21]: /images/20220326/ac033ee6ce544fc99603b7fd53d1d8a7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 22]: /images/20220326/2c66d1e8150b4d43aa4577b5f72c6922.png
[2019011515240818.png]: /images/20220326/3700d15da7b2486bb8f583f1022aa780.png
[20190115152559994.png]: /images/20220326/00a153db9c3147a396f4755395bf1e81.png
[20190115152604122.png]: /images/20220326/271f63f7bc784c93bfb5b05eca67cb11.png
[20190115152609215.png]: /images/20220326/6a30c4b349474a1bb24a3a999c7c229e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 23]: /images/20220326/46938e80192847efa0707d0af7f17e38.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 24]: /images/20220326/c301182eb6f944f4903d0e68141cd306.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 25]: /images/20220326/df1c2df232434e7fab45fee2d8696fa4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 26]: /images/20220326/a3b7e08d322245f5a7d342580a73e6a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 27]: /images/20220326/ff3af06c08ba4e3ca7f411f6fca9a00c.png
[20190116202828176.png]: /images/20220326/02de7fc8716749a2814e5ed1b327dff8.png
[20190116203325894.png]: /images/20220326/2f5677771b45468f95f90820caa475ad.png
[20190116203741920.png]: /images/20220326/dcd115c43cf24b9b82b73a8992bfb868.png
[20190116203745630.png]: /images/20220326/8c1cefe4e1934bfa99972f482d82a1b4.png
[20190116204037149.png]: /images/20220326/bfc1d782f22f41b78261bdda65e8bc45.png
[20190116204040870.png]: /images/20220326/3fb892c57b36497398bd1130a8cc3eef.png
[20190116204323936.png]: /images/20220326/09f71333b030419e97146058f40e33be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 28]: /images/20220326/cddc6c74b16d4941a728845a17accb55.png
[20190116204810814.png]: /images/20220326/231bbbfbbe6f42319d1516e827d73bf4.png
[20190116205025187.png]: /images/20220326/8a89386362bd4cafacf9e61b93b80ca1.png
[20190116205029175.png]: /images/20220326/22e10e74c6d24884b15d246a6dd5a302.png
[20190116205032587.png]: /images/20220326/5adc4559ef3c45d789526a33dc8a68cb.png
[20190116210422422.png]: /images/20220326/bc91226644ec464a91987f69f32114f3.png
[20190116210827915.png]: /images/20220326/905e9318a1bf41d291c3ed5ff82cea59.png
[2019011621180951.png]: /images/20220326/56e6a4bf58d84d988d1e3f50253f8111.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 29]: /images/20220326/f5e27213f62c489fa0cf48725917ad53.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 30]: /images/20220326/eb0812e50dc2432f943e68a2ed771180.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 31]: /images/20220326/15dff3d2d8064bb78daf9f4594fc01b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 32]: https://img-blog.csdnimg.cn/2019011711025927.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 33]: /images/20220326/b7b31f2a387649d6aa1f4ec74c47b619.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 34]: /images/20220326/2dbe5a78f68e45fcaffc6912b783d1ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 35]: /images/20220326/dd5532cd7d9441249f453fd1f3cb0a1e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 36]: /images/20220326/6e2b725280e54fb1be90782a4ace47be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 37]: /images/20220326/0ac7c4bbfc5548d4af9d752061224de5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 38]: /images/20220326/ca848c0a8ef94d2295ec73dc38a73c37.png
[20190117122452758.png]: /images/20220326/9b51c97e464840c8852b35b976d150de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 39]: /images/20220326/278a22cda2414f418f29d0da0b71f8a1.png
[20190117122502412.png]: /images/20220326/bdd627d71f154c22b31b70ff5967b02c.png
[20190117122508417.png]: /images/20220326/92d151d73c7b4b6da5f5c0eb9bb921fb.png
[20190117122513322.png]: /images/20220326/3b84dd2b6a1448d3b2cdf87939492f40.png
[20190117122517861.png]: /images/20220326/0ada53219e894059bc78211b8ea76901.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 40]: /images/20220326/bd996f597cd54df9af36970cd9cc7b40.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 41]: /images/20220326/8f485df0f2b94623bda4cadd2db8b2e1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 42]: /images/20220326/ac8ffb12891549ffbfa18ec0447727da.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 43]: /images/20220326/52367f40c50a45c9bd943a6c0387b9fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 44]: /images/20220326/f2c7c635eef1401d8fc250650d16357c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 45]: /images/20220326/852f427e1e17464aba1f7f7974f2f3ad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 46]: /images/20220326/47f33099b5704086ac98e497c10ae988.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 47]: /images/20220326/28bf14cd98614bceba04a52a4b3778ae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 48]: /images/20220326/d229a2307c4f4ba28c42697dd205318a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 49]: /images/20220326/f4e1ffaa570d4f2289efbc37685ba812.png
[20190117160635364.png]: /images/20220326/db88190741944f81af75318054add948.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 50]: /images/20220326/36c3a7078cac4c95b4c0acae62a001d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 51]: /images/20220326/cc923c75022444f19a672437a64b926c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 52]: /images/20220326/2f9afc6bfde84702b6231b812c851a05.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 53]: /images/20220326/0465adbd7c584d87acf34b72c0159a72.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 54]: /images/20220326/7ae21d6a11214310a3cc07e49ac7bc8b.png
[20190117162924645.png]: /images/20220326/0d419e1add324c47a688441f59026de8.png
[20190117163014532.png]: /images/20220326/1cf7d6f2629b424ba35fbea22551a466.png
[20190117163019958.png]: /images/20220326/1b38af9de3fa4511b08411bf5dd0d986.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 55]: /images/20220326/13d1f0ff976c4bf9b6157810c2ec70e2.png
[20190117164413290.png]: /images/20220326/82e37e6510844e87bfd90da41af56080.png
[20190117164508225.png]: /images/20220326/ec1f679255a0405aae91b110c124a20c.png
[20190117164513771.png]: /images/20220326/f530f02727804d028d0da3aff0f09d64.png
[20190117164610672.png]: /images/20220326/ffbd2a11d8a2495b9361216f70dc587d.png
[20190117164659480.png]: https://img-blog.csdnimg.cn/20190117164659480.png
[20190117164719959.png]: /images/20220326/ea2c4ee1a7bb4b3d94ccf0e96c65db7a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 56]: /images/20220326/0c1ed128a0d748f1bf0773c3a63811cd.png
[20190117165817857.png]: /images/20220326/09fc6e8da4054388883965dbc7bf2945.png
[20190117165858706.png]: https://img-blog.csdnimg.cn/20190117165858706.png
[20190117165902684.png]: /images/20220326/890d2e10571640d48cc4feec0ca9b03e.png
[20190117170019975.png]: /images/20220326/b569219559244a8985dccf6528802671.png
[20190117170258130.png]: /images/20220326/187bf2bd4db14990a61d17fc25438073.png
[20190117170952577.png]: /images/20220326/a78d02dee6484bae8987424e16da7413.png
[20190117170957733.png]: /images/20220326/248cc882def842ea831495841fb225ff.png
[20190117171301386.png]: https://img-blog.csdnimg.cn/20190117171301386.png
[20190117171351422.png]: /images/20220326/e1f77f99a90f452caebeed9b6f4682c9.png
[20190117171423991.png]: /images/20220326/549b7f0f7a8a4dccb124e5b48a900137.png
[20190117171520954.png]: /images/20220326/13f3e25125a6441598e809178ca7cfb9.png
[20190117171638758.png]: /images/20220326/984db8be04314e75b05ad4c2fc2880b5.png
[20190117171702128.png]: /images/20220326/7bb2e30eb54f402f9a37a02d7791b621.png
[20190117171848367.png]: /images/20220326/492318895f154a999d8b4eaca128942a.png
[20190117171852989.png]: /images/20220326/eccbab88898e4a859654061e36432226.png
[20190117185446833.png]: https://img-blog.csdnimg.cn/20190117185446833.png
[20190117185450998.png]: /images/20220326/09d8138cca3f4262acd009b50bfc9063.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 57]: /images/20220326/1cee076e2de1429e8f65d4e00ff16ad0.png
[20190117191458768.png]: /images/20220326/4e73e62575b14c6a9e7cc2e60fb5aedd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 58]: /images/20220326/9d9f5ce88d1f49ab9b491e0303f2aeb2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 59]: /images/20220326/14703ef8fd3d4434a9b8103bfc8d03cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 60]: https://img-blog.csdnimg.cn/20190117193154710.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 61]: https://img-blog.csdnimg.cn/20190117193158832.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 62]: /images/20220326/126a42b3ed224765b2aec6f10bb4ba6a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 63]: https://img-blog.csdnimg.cn/20190117194853916.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 64]: /images/20220326/fd73bbda7689471f8596467e2c8c1093.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 65]: /images/20220326/229560bdfaee4452bb798d64e5f3bfc5.png
[20190117195544478.png]: /images/20220326/ab5c178e1c214e1e8f8ef319f1e89bf4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 66]: /images/20220326/9ed55aba15324f72a7dac51e3b5adec0.png
[20190117195833355.png]: /images/20220326/16d765780f34406897b10dd16ca8b1d2.png
[20190117195836763.png]: /images/20220326/9e4e8e2fd5e349a1aee7274d5b2571e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 67]: /images/20220326/2389ba11cb574bb1a68e93d55ad73637.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 68]: /images/20220326/27b230c44c3d4185a22cd92e4cc88045.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 69]: /images/20220326/2bece59888de43bfb10936c3d880962e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 70]: /images/20220326/4f30a488ef7c479dbb3e486a83d785ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 71]: /images/20220326/dfbe28b683eb4d8a8f96133488b73154.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 72]: /images/20220326/c6d8404bbd1c4273bf100bbe7cf74e50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 73]: /images/20220326/7195c50e62ab456aa8517af6795e4f97.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 74]: /images/20220326/1207295345e34b7bb5b9a887c203035f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 75]: /images/20220326/ac29954f8ea14952b6b9df5eafb5db43.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 76]: /images/20220326/381ee9363d474cc8b67510e4645a0a2d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 77]: /images/20220326/523eb85d7a3447afa5542ebe173e619f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 78]: /images/20220326/fe48bea43e7d473885e45096fb23b815.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 79]: /images/20220326/e3f14fff68d84d229b5eddbbd2547e42.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 80]: /images/20220326/9181555d81194915a5761a1b40fd0bb1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 81]: /images/20220326/2cf7270bceab4b58a73d87101140c825.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 82]: /images/20220326/973858bd1f864fa987b917cd64fbdd67.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 83]: /images/20220326/c7a3553b5446481bb94d5d10394431a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 84]: /images/20220326/c755c684fb6844eeb1550a558be630b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDY1ODc1_size_16_color_FFFFFF_t_70 85]: /images/20220326/b33af2348f12411092b246c8fe96ef00.png
[2019011815122442.png]: /images/20220326/f76b428df72f4b348fffb55d3f02a07f.png
[20190118154453634.png]: /images/20220326/8a542f3cc892458dbb7d8b6e9885cc1e.png
[20190118154953808.png]: /images/20220326/6f563b902ed8412cacb7fd2156bb4a96.png