指令集基本原理

引言

本附录主要介绍指令集体系结构。我们主要关注四个主题。

• 第一，对各种指令集进行了分类并对各种方法的优势和劣势进行某种量化评估。
• 第二，给出一些指令集测量数据，并对其进行分析，这些数据大体与特定的指令集无关。
• 第三，讨论语言与编译器问题以及它们对指令集体系结构的影响。
• 最后，展示这些思想如何在MIPS指令集中得到反映，MIPS 指令集是-种典型的RISC体系结构。
• 在附录的末尾是有关指令集设计的一些谬论和易犯错误。

在这个附录中，我们将研究大量体系结构方面的测试结果。显然，这些测量结果依赖于被测程序和用于进行这些测量的编译器。

指令集体系结构的分类

处理器中的内部存储类型是最基本的区别，所以在这一节，我们将主要关注体系结构中这一部分的各种选项。主要选项包括栈、累加器或寄存器组。操作数可以显式命名，也可以隐式命名：在栈体系结构中，操作数隐式位于栈的顶部，而在累加器体系结构中，操作数隐式为累加器。通用寄存器体系结构只有显式操作数，或者为寄存器，或者为存储器位置。图A-1显示了此类体系结构的框图，表A-1显示了代码序列 C=A+B 在这三类指令集中通常是如何显示的。显式操作数也许可以直接从存储器访问，也可能需要首先加载到临时存储中，具体取决于体系结构的类别及特定指令的选择。

图A-1 4类指令集体系结构的操作数位置。这些箭头指示操作数是算术逻辑单元（ALU）操作的输入还是结果，或者既是输入又是结果。较浅的阴影表示输入，深色阴影表示结果。在（a）中，栈顶寄存器（TOS）指向顶部输入操作数，它与下面的操作数合并在一起。第一个操作数从栈中移走，结果占据第二个操作数的位置，对TOS进行更新，以指向结果值。所有操作数都是隐式的。在（b）中，累加器既是隐式输入操作数，也是结果。在（c）中，一个输入操作数是寄存器，一个在存储器中，结果保存在寄存器中。在（d）中，所有操作数都是寄存器，而且和栈体系结构类似，只能通过独立指令将其传送到存储器中：在（a）中为push或pop，在（d）中为1oad或store

• 注意，对于栈和累加器体系结构，Add指令拥有隐式操作数，对于寄存器体系结构拥有显式操作数。假定A、B和C都属于存储器，A和B的值不能被销毁。图A-1显示了针对每类体系结构的Add运算。

如上面的图和表所示，实际上有两种类型的寄存器计算机。一类可以用任意指令来访问存储器，称为寄存器-存储器体系结构，另一类则只能用载入和存储指令来访问存储器，称为载入-存储体系结构。第三类将所有操作数都保存在存储器中，称为存储器-存储器体系结构。一些指令集体系结构的寄存器要多于单个累加器，但对这些特殊寄存器的使用设置了一些限制。 此类体系结构有时被称为扩展累加器或专用寄存器计算机。

尽管大多数早期计算机都使用栈或累加器类型的体系结构，但在1980年之后的几乎所有新体系结构都使用了载入-存储寄存器体系结构。通用寄存器（GPR）计算机之所以会出现，其主要原因有两个。第一，寄存器（类似于处理器内部其他形式的存储器）快于存储器。第二，对编译器来说，使用寄存器要比使用其他内部存储形式的效率更高。例如，在寄存器计算机中，在对表达式（AXB） - （BXC） - （AXD）求值时，可以按任意顺序执行乘法计算，这种做法的效率更高一些，可能是操作数位置的原因，也可能是流水线因素的原因。不过，在栈计算机上，硬件只能按唯一的顺序对表达式进行求值， 这是因为操作数是隐藏在栈中的，它必须多次载入操作数。

更重要的是，寄存器可用于保存变量。当变量被分配到寄存器中时，可以降低存储器通信流量、加快程序速度（由于寄存器的速度快于存储器），提高代码密度（由于寄存器的名称位数少于存储器位置的名称位数）。

在A.8节将会解释，编译器编写入员希望所有寄存器都是等价的、无保留的。较早的计算机在满足这一期望方面打了折扣，将一些寄存器专门用于一些特殊应用，显著降低了通用寄存器的数量。如果真正通用寄存器的数目过小，那尝试将变量分配到寄存器中就没有什么好处。

编译器将所有未确认用途的寄存器保留给表达式求值使用。有多少个寄存器才是足够的呢?其答案当然取决于编译器的有效性。大多数编译器会为表达式求值保留一些寄存器，为参数传递使用一些，其余寄存器可用于保存变量。现代编译器技术能够有效地使用大量寄存器，从而增加了最新体系结构的寄存器数目。

有两个重要指令集特性可以用来区分GPR体系结构。这两个特性都关注一个典型算术或逻辑指令（ALU指令）操作的本质。第一个特性关注一个ALU指令是有两个还是三个操作数。在三操作数格式中，指令包含一个结果操作数和两个源操作数。在两操作数格式中，操作数之一既是运算的源操作数，又是运算的结果操作数。GPR体系结构的第二个区别是考虑ALU指令中可能有多少个操作数是存储器地址。一个典型ALU指令所支持的存储器操作数数量可以是
0~3个。表A-2给出了这两种特性的组合及其计算机示例。尽管共有7种可能组合方式，但其中3种就可以对几乎全部现有计算机进行分类。前面曾经提到，这3种是载入存储（也称为寄存器-寄存器）、寄存器-存储器和存储器-存储器。

ALU指令中没有存储器引用的计算机称为载入-存储或寄存器-寄存器计算机。每条典型ALU指令中有多个存储器操作数的指令称为寄存器-存储器或存储器-存储器，具体取决于它们是拥有一个还是 一个以上的存储器操作教。

表A-3显示了每一类型的优势和劣势。当然，这些优势和劣势不是绝对的：它们是定性的，它们的实际影响取决于编译器和实现策略。采用存储器存储器运算的GPR计算机很容易被编译器忽略，用作一种载入存储计算机。体系结构方面最普遍的影响之一是对指令编码和执行一项任务所需指令数的影响。在附录C和第3章中可以了解这些不同体系结构对实现方法的影响。

• 符号（m，n）表示存储器操作数有m个，共有n个操作数。一般来说，可选项较少的计算机简化了编译器的任务，因为编译器需要作出的决策较少。具有大量灵活指令格式的计算机减少了程序编码需要的位数。寄存器的数目对指令大小也有所影响，因为对于指令中的每个寄存器分类符，需要log2（寄存器个数）。因此，对于寄存器-寄存器体系结构而言，寄存器个数加倍需要增加3个位，大约是32位指令的10%。

存储器寻址

一个体系结构，无论是载入存储式，还是允许任何操作数都是存储器引用，它都必须定义如何解释存储器地址以及如何指定这些地址。这里给出的测量值大体与计算机无关，但并非绝对如此。在某些情况下，这些测量值受编译器技术的影响很大。由于编译器技术扮演着至关重要的角色，所以这些测量都是使用一种优化编译器测得的。

解释存储器地址

根据地址和长度会访问到什么对象呢?本书中讨论的所有指令集都是字节寻址的，提供对字节（8位）半字（16位）和字（32位）的访问方式。大多数计算机还提供了对双字（64位）的访问。关于如何对一个较大对象中的字节进行排序，有两种不同的约定方式。小端字节顺序将地址为“…x000” 的字节放在双字的最低有效位置（小端）。字节的编号为：

7 6 5 4 3 2 1 0

大端字节顺序将地址为“x.. .x000”的字节放在双字的最高有效位置（大端）。字节的编号为：

0 1 2 3 4 5 6 7

在同一台计算机内部进行操作时，字节顺序通常不会引起人们的注意——只有那些将相同位置同时作为字和字节进行访问的程序才会注意到这一区别。但是，在采用不同排序方式的计算机之间交换数据时，字节顺序就会成为一个问题。在对比字符串时，小端排序也不能与字的正常排序方式相匹配。字符串在寄存器中是反向表示的，如backwards显示为“SDRAWKCAB”。

第二个存储器问题是：在许多计算机中，对大于一字节的对象进行寻址时都必须是对齐的。大小为s字节的对象，字节地址为A，如果A mod s=0，则对该对象的寻址是对齐的。图A-2显示了寻址为对齐和不对齐时的地址。

图A-2在字节寻址计算机中，字节、半宇、字和双字对象的对齐与未对齐地址。对于每种未对齐示例，一些对象需要两次存储器访问才能完成。每个对齐对象总是可以在一次存储器访问中完成，只要存储器与对象的宽度相同即可。本图显示的存储器宽度为8个字节。标记各列的字节偏移指定了该地址的低3位

由于存储器通常与一个字或双字的倍数边界对齐，所以非对齐寻址会增加硬件复杂性。一个非对齐存储器寻址可能需要多个对齐的存储器引用。因此，即使在允许非对齐寻址的计算机中，采用对齐寻址的程序也可以运行得更快些。即使数据是对齐的，要支持字节、半字和字寻址也需要一个对齐网络来对齐64位寄存器中的字节、半字和字。例如，在表A-4中，假定从低3位取值为4的地址中读取一个字节。我们需要右移3个字节，对准64位寄存器中正确位置的字节。根据具体指令，计算机可能还需要对这个量进行符号扩展。存储过程很容易：只有存储器的寻址字节可被修改。在某些计算机中，字节、半字和字操作不会影响到寄存器的上半部分。尽管本书中讨论的所有计算机都允许对存储器进行字节、半字和字访问，但只有IBM 360/370、Intel 80x86和VAX支持对不足完整宽度的寄存器操作数进行ALU运算。

既然已经讨论了存储器寻址的各种解释方法，现在可以讨论指令用来指定地址的方式了，这些方式称为寻址方式。

寻址方式

给定地址后，我们就知道了去访问存储器的哪些字节。在这一小节中，我们将研究寻址方式——体系结构如何指定要访问对象的地址。除了存储器中的位置之外，寻址方式还指定常量和寄存器。在使用存储器位置时，由寻址方式指定的实际存储器地址称为有效地址。

表A-4显示了在最近计算机中用到的所有数据寻址方式。立即数或直接操作数寻址通常被看作存储器寻址模式（即使它们访问的值位于指令流中也是如此），不过，由于寄存器通常没有存储器地址，所以我们将它们分离出来。我们已经将那些依赖于程序计数器的寻址模式（称为PC相对寻址）分离出来。PC相对寻址主要用于在控制转移指令中指定代码地址，A.6 节将对此进行讨论。

• 在自动递增/递减和比例寻址方式中，变量d指定所访问数据项的大小（即，该指令访问的是1、2、4或8字节中的哪一种）。只有当被访问元素位于存储器中的连续位置时，这些寻址方式才有用。RISC计算机使用位移量寻址来模拟寄存器间接寻址（地址为0）和直接寻址（基址寄存器中为0）。在我们的测量结果中，使用为每种模式显示的第一个名称。在A.9.5节定义了用作硬件描述的C语言扩展。

Mem[Regs[R1]]是指存储器位置的内容，这一位置的地址由寄存器1（R1）的内容给出。对于小于一个字的数据 ，我们将在后面介绍用于访问和转移此类数据的扩展。

寻址模式能够大幅臧少指令数目，它们也会增加构建计算机的复杂度，对于实施这些方式的计算机，还可能增加每条指令的平均时钟周期数目（CPI）。 因此，各种寻址模式的使用对于帮助架构师选择包含哪些功能是十分重要的。

图A-3中给出在VAX体系结构上对3个程序中寻址方式使用样式的测量结果。在这个附录中，我们使用较旧的VAX体系结构进行一些测量， 这是因为它拥有最丰富的寻址方式，对存储器寻址的限制最少。例如，表A-2给出了VAX支持的所有方式。

图A-3 存储器寻址方式（包括立即数）的用法小结。几乎所有存储器访问都采用这几种主要寻址方式。一半的操作数引用采用寄存器寻址方式，而另一半则采用存储器寻址方式（包括立即数）。当然，编译器会影响到选用哪种寻址模式。VAX上的存储器间接寻址方式可使用位移量、自动递增或自动递减来形成初始存储器地址；在这些程序中，几乎所有存储器间接引用都以位移量寻址方式为基准方式。

位移量寻址方式，

在使用位移量类型的寻址方式时，一个主要问题就是所用位移量的范围。根据所使用的各种位移量大小，可以决定支持哪些位移量大小。由于位移量字段的大小直接影响到指令的长度，所以其选择非常重要。图A-4是利用基准测试程序对载入-存储体系结构中数据访问进行的测量结果。

图A-4 位移值的分布非常广泛。既存在大量小数值，又有相当数量的大数值。位移值的广泛分布是由于变量有多个存储区域，而且访问它们的位移量不同，而且编译器使用的总寻址机制也各不相同。x轴是位移量以2为底的对数值，即表示该位移量所需要的字节大小。x轴上的零表示位移值0的百分比。该曲线没有包含符号位，存储布局对它会有严重影响。大多数位移值是正数，但最大的位移值（14位以上）为负值。

立即数或直接操作数寻址方式

在进行算术运算、比较（主要用于分支）和移动时，如果希望将常量放在寄存器中，可以使用立即数。后一种情景可用于写在代码中的常量（这种常量较小）和地址常量（这种常量可能很大）。对于立即数的使用，重点是要知道是需要对所有运算都支持立即数，还是仅对一部分运算支持立即数。图A-5显示了在一个指令集中，立即数在一般类型的整数和浮点运算中的使用频率。

图A-5 大约有四分之一的数据传送和ALU运算拥有立即操作数。下面的长条表示整数程序在大约五分之一的指令中使用立即数，而浮点程序在大约六分之一的指令中使用立即数。对于载入操作，载入立即数指令将16位载入一个32位寄存器的任一半中。载入立即数并不是严格意义上的载入，因为它们并不访问存储器。偶尔会使用一对载入立即数来载入32位常量，但这种情况很少见。

另一个重要指令集测量是立即数的取值范围。与位移值相似，立即数取值的大小也影响到指令长度。如图A-6所示，小立即数的应用最多。不过，有时也会使用大型立即数，更多的是用在地址计算中。

图A-6 立即数值的分布。 x轴给出表示立即值取值大小所需要的位数——0表示立即数字段值为0。大多数立即数取值为正数。对于CINT2000，大约20%为负数，对于CFP2000，大约30%为负数。这些测量是在Alpha上执行的，其中最大立即数为16位，被测程序与图A-4中相同。对VAX进行的类似测量（它支持32位立即数）表明：大约20%~25%的立即数长于16位。因此，16 位的长度覆盖大约80%，8位可以覆盖大约50%

小结：存储器寻址

首先，我们预测一种新的体系结构至少支持以下寻址方式：位移量寻址、立即数寻址和寄存器间接寻址，这主要是因为它们非常普及。图A-3显示它们代表了我们测量中所使用的75%~99%的寻址方式。其次，我们预测位移量寻址方式中的地址大小至少为12~16位，根据图A-4的图题，这些大小将占到位移量的75%~99%。最后，我们预测立即数字段的大小至少为8~16位。这一说法在它提到的图题中没有得到证实。

我们已经介绍了指令集分类并决定采用寄存器-寄存器体系结构，再加上前面关于数据寻址模式的建议，下面将介绍数据的大小与意义。

操作数的类型与大小.

如何指定操作数的类型呢?通常，通过在操作码中进行编码来指定操作数的类型。或者，用一些可以被硬件解读的标签对数据进行标记。这些标签指定操作数的类型，并相应选择操作。

我们首先从台式机和服务器体系结构开始。通常操作数的类型（整数、单精度浮点、字符等）有效地确定了其大小。常见操作数类型包括字符（8位）半字（16位）字（32位）、单精度浮点（也是1个字）和双精度浮点（2个字）。整数几乎都是用二进制补码数字表示的。字符通常用ASCII表示，但随着计算机的国际化，16位Unicode（在Java中使用）也正在普及。几乎所有的计算机都遵循了相同的浮点标准——IEEE标准。

一些体系结构提供了对字符串的操作，不过这些操作通常都十分有限，将字符串中的每个字符都看作单个字符。支持对字符串执行的典型操作包括比较和移动。

对于商务应用程序，一些体系结构支持二进制格式，通常称为压缩十进制或二进制编码十进制——用4个位对0至9的数值进行编码，两个十进制数位被压缩到两个字节中。数值字符串有时称为非压缩十进制，通常提供在被称为压缩和解压缩的操作之间来回转换。

使用十进制操作数的一个理由是获得与二进制数字完全匹配的结果，这是因为一些十进制小数无法用二进制准确表示。十进制中的准确计算在二进制中可能十分接近但并非完全准确。

我们的SPEC基准测试使用字节或字符、半字（短整数）字（整数）双字（长整数）和浮点数据类型。图A-7给出了为这些程序引用存储器对象的大小动态分布。对不同数据类型的访问频率有助于确定哪些类型最为重要，应当加以高效支持。计算机是否应当拥有64位访问路径，或者用两个时钟周期来访向一个双字是否可行?我们前面曾经看到，字节访问需要一个对齐网络：将字节作为基元类型提供支持有多么重要?图A-7使用存储器引用来查看被访问数据
的类型。

图A-7 对于基准测试程序，所访问数据的大小分布。双字数据类型用于表示浮点程序中的双精度浮点值，还用于表示地址，这是因为该计算机使用64位地址。在采用32位地址的计算机上，64 位地址将被32位地址代替，所以整数程序中的几乎所有双字访问都变为单字访问

在一些体系结构中，寄存器中的对象可以作为字节或半字进行访问。但是，这种访问是非常罕见的——在VAX上，不超过12%的寄存器引用采用这种方式，也就是这些程序中所有操作数访问的大约6%。

指令集中的操作

大多数指令集体系结构支持的操作符可以如表A-5那样进行分类。关于所有体系结构的一条经验规律是：执行最多的指令是一个指令集中的简单操作。例如，表A-6给出了10种简单指令，对于一组在流行80x86上运行的整数程序，这10种简单指令占所执行指令的96%。因为它们很常见，所以这些指令的实现应当确保它们能够快速完成。

• 在不同体系结构中，指令集中对系统功能的支持有所不同，但所有计算机都必须对一些基本的系统功能提供指令支持。指令集对后4类的支持数量可能为0，也可能包含大量特殊指令。在任何计算机中都提供浮点指令，供那些大量使用浮点数的应用程序使用。这些指令有时是可选指令集的一部分。十进制和字符串指令有时是基元类型，比如在VAX或IBM360中，也可能是由编译器使用更简单的指令合成的。图形指令通常会对许多较小的数据项进行并行操作。例如，对2个64位操作数执行8个8位加法。

前面曾经提到，表A-6中的指令在每一台计算机的每个应用程序（台式机、服务器和嵌入式）中都可以找到，会对表A-5中的操作进行一些变化，而这主要取决于该指令集包含哪些数据类型。

• 简单指令是这个列表的主体，占所执行指令的96%。 这些百分数是5个SPECint92程序的均值。.

控制流指令

由于分支与跳转行为的测量在相当程度上与其他测量值和程序无关，所以我们现在研究控制流指令的使用，它与上一节的操作之间没有什么共同点。

关于改变控制流的指令，没有非常一致的术语。在20世纪50年代，它们通常被称为转移（transfer）。在20世纪60年代，开始使用分支（branch）一词。后来计算机还另外引入了一些名称。在本书中，当控制中的改变是无条件时，我们使用跳转（jump），当改变是有条件时，使用分支。

我们可以区分4种不同类型的控制流变化：

• 条件分支；
• 跳转；
• 过程调用；
• 过程返回；

由于每个事件都是不同的，可能使用不同指令，可能拥有不同行为，所以我们希望知道这些事件的相对频率。图A-8中给出了这些控制流指令在一个载入-存储计算机上的出现频率，我们就是在这种计算机上运行基准测试的。

图A-8 将控制流指令分为三类：调用或返回、跳转和条件分支。条件分支显然占绝大多数。每种类型的计数分别用三个长条来显示。用于收集这些统计数字的程序和计算机与图A-3中的数字相同

控制流指令的寻址方式

控制流指令中的目标地址在任何情况下都必须指定。在绝大多数情况下，这个目标是在指令中明确指定的，但过程返回是一个重要例外，这是因为在编译时无法知道要返回的目标位置。指定目标的最常见方法是提供一个将被加到程序计数器（PC）的位移量。这类控制流指令被称为PC相对指令。由于目标位置通常与当前指令的距离较近，而且，在指定相对于当前PC的位置时，需要的位数较少，所以PC相对分支或跳转具备一些优势。采用PC相对寻址还可以使代码的运行不受装载位置的影响。这一特性称为位置无关，可以在链接程序时减少一些工作，而且对于在执行期间进行动态链接的程序也比较有用。

如果在编译时不知道目标位置，为了实现返回和间接跳转，需要一种不同于PC相对寻址的方法。这时，必须有一种动态指定目标的方法，使目标能够在运行时发生变化。这种动态寻址可能非常简单，只需要给出包含目标地址的寄存器名称即可；跳转可能允许使用任意寻址方式来提供目标地址。

这些寄存器间接跳转对于其他4种重要功能也是有用的。

• case或switch语句，大多数编程语言中都会有这些语句（用于选择几种候选项之一）。
• 虚拟函数或虚拟方法，存在于诸如C++或Java之类的面向对象式语言中（允许根据参数类型调用不同例程）。
• 高阶函数或函数指针，存在于诸如C或C++等语言中（它允许以参数方式传递一些函数，提供面向对象编程的一种好处）。
• 动态共享库（允许仅当程序实际调用一个库时才在运行时加载和链接，而不是在运行程序之前进行静态加载和链接）。

在所有这4种情况下，目标地址在编译时都是未知的，因此，通常是在寄存器间接跳转之前从存储器加载到寄存器中。

由于分支通常使用PC相对寻址来指定其目标，一个重要的问题就是关注分支目标距离分支有多远。了解这些位移量的分布有助于选择支持哪些分支偏移量，从而会影响到指令长度和编码。图A-9给出了指令中PC相对分支的位移量分布。这些分支中大约有75%是正向的。

图A-9 分支距离（以目标与分支指令之间的指令数来表示）。整数程序中的最常见分支是转向可以用4~8位编码的目标地址。这一结果告诉我们，短位移量字段对于分支指令通常足够了，有了较小分支位移量的较短指令，设计者可以提高编码密度。这些测量结果是在载入-存储计算机上测得的，所有指令都与字边界对齐。对于同一程序，如果体系结构需要的指令较少（比如VAX），那分支距离就较短。但是，如果计算机的指令长度是变化的，可以与任意字节连接对齐，则表示该位移量所需要的位数可能会增加。

条件分支选项

由于大多数控制流改变都是分支，所以决定如何指定分支条件是很重要的。表A-7列出了当前使用的3种主要技术及其优缺点。

分支的最明显特性之一是大量比较都是简单的测试，其中有很多是与0进行比较。因此，一些体系结构选择将这些比较当作特殊情景进行处理，特别是在使用比较并分支指令中。图A-10给出了条件分支中用到的各种不同比较的频率。

• 尽管条件代码可以由ALU运算设定（用于其他目的），但对程序的测量显示，这种情况会很少发生。当条件代码由一大组指令或一组偶然选定的指令设定，而不是由指令中的一个比特来设定时，就会出现条件代码的重要实现问题。拥有比较和分支指令的计算机通常会限制比较范围，使用条件寄存器进行更复杂的比较。通常，对于根据浮点比较进行的分支和基于整数比较进行的分支会采用不同技术。由于根据浮点比较执行的分支数目要远小于根据整数比较进行的分支数目，所以这种做法是合理的。

图A-10 条件分支中不同比较类型的使用频率。编译器与体系结构的这种组合中，小于（或等于）分支占主导地位。这些测量值包含了分支中的整数和浮点比较。用于收集这些统计数字的程度和计算机与图A4中相同

过程调用选项

过程调用和返回包括控制转移，还可能涉及一些状态保存过程；至少必须将返回地址保存在某个地方，有时保存在特殊的链接寄存器中，有时只是保存在GPR中。一些较早的体系结构提供了一种用于保存许多寄存器的机制，而较新的体系结构需要编译器为所存储和恢复的每个寄存器生成存储和载入操作。

在保存寄存器时，有两种基本约定：要么保存在调用位置，要么保存在被调用的过程内部。调用者保存是指发出调用的过程必须保存它希望在调用之后进行访问的寄存器，因此，被调用的过程不需要为寄存器操心。被调用者保存与之相反：被调用过程必须保存它希望使用的寄存器，而调用者不受限制。在某些时间必须使用调用者保存方法，其原因在于两种不同过程中对全局可见变量的访向样式。例如，假定我们有一个过程P1，它调用过程P2，这两个过程都对全局变量x进行处理。如果P1已经将x分配给一个寄存器，它必须确保在调用P2之前将x保存到P2知晓的一个位置。编译器希望知道被调用过程可能在什么时候访问寄存器分配量，由于不同进程可能是分别编译的，所以增加了获知这一信息的难度。假定P2可能不会触及x，但可能调用另一个可能访向x的进程P3，而P2和P3是分别编译的。由于这些复杂性的存在，大多数编译器会采用比较稳健的方式，由调用者将所有可能在调用期间访问的变量都保存起来。

在可以采用任一约定的情况下，有些程序更适于采用被调用者保存，有些程序更适于采用调用者保存。结果，今天的大多数实际系统都采用这两种机制的组合方式。这一约定在应用程序二进制接口（ABI）中指定，它确定了一些基本规则，指出哪些寄存器应当由调用者保存，哪些应当由被调用者保存。

小结：控制流指令

控制流指令属于执行频率最高的一部分指令。尽管条件分支有许多选项，但我们希望新体系结构中的分支寻址能够跳转到分支指令之前或之后数百条指令处。这一要求意味着PC相对分支位移量至少为8位。我们还希望看到跳转指令采用寄存器间接和PC相对寻址，来支持过程返回和当前系统的许多其他功能。

我们现在已经从汇编语言程序员或编译器编写人员的层次，完成了对指令体系结构的浏览。我们介绍了一种采用位移量、立即数和寄存器间接寻址方式的载入-存储体系结构。所介绍的数据为8位、16位、32位和64位整数，还有32位和64位浮点数。指令包括简单操作、PC相对条件分支、用于过程调用的跳转和链接指令，还有用于过程返回的寄存器间接跳转（还有其他一些应用）。

现在我们需要选择如何采用一种便于硬件执行的方式来表示这一体系结构。

指令集编码

显然，上述选择会影响到如何对这些指令进行编码，表示为供计算机执行的二进制形式。这种表示形式不仅影响到程序经过编译后的大小，还会影响到处理器的实现，处理器必须对这种表示形式进行译码，快速找出操作和操作数。操作通常在一个称为操作码的字段中指定。后面将会看到，一个重要决定是如何通过编码将寻址方式与操作结合在一起。

这一决定取决于寻址方式的范围和操作码与寻址方式之间的独立程序。一些较早的计算机有1~5个操作数，每个操作数有10种寻址方式。对于如此大量的组合情况，通常需要为每个操作数使用独立地址标识符：地址标识符告诉使用哪种寻址方式来访问该操作数。

另一个极端是仅有一个存储器操作数、仅有一或两种寻址方式的载入存储计算机；显然，在这种情况下，可以将寻址方式作为操作码的一部分进行编码。

在对指令进行编码时，由于寄存器字段和寻址方式字段可能在-条指令中出现许多次，所以寄存器数目和寻址方式的数目都对指令大小有显著影响。事实上，对于大多数指令，对寻址方式字段和寄存器字体进行编码时所占用的位数，要远多于指定操作码所占用的位数。在对指令集进行编码时，架构师必须平衡以下几种竞争力量。

1. 希望允许尽可能多的寄存器和寻址方式。
2. 寄存器字段和寻址方式字段的大小对平均指令大小存在影响，从而对平均程序大小产生影响。
3. 希望编码后的指令长度易于以流水线实施方式处理。至少，架构师希望指令长度为字节的总数，而不是任意位长度。

图A-11给出三种常见的指令集编码选择。第一种称为变长编码，这是因为它几乎允许对所有操作使用所有寻址方式。当存在许多寻址方式和操作时，这是最佳选择。第二种选择称为定长编码，因为它将操作和寻址方式合并到操作码中。通常，采用定长编码时，所有指令的大小都相同；当寻址方式与操作数较少时，其效果最好。变长编码与定长编码之间进行的权衡是程序大小与处理器译码的难易程度。变长编码在表示程序时尽力减少所用位数，各条指令的大小和要执行的工作量可能会有很大变化。

图A~11指令编码的三种基本变体：变长编码、定长编码、混合编码。变长格式可以支持任何数目的操作数，每个地址标识符确定操作数的寻址方式和标识符的长度。这种方式的代码表示长度通常是最短的，因为不会包含没有使用的字段。定长格式中的操作数个数总是相同的，寻址方式作为操作码的一部分进行指定。它生成的代码规模通常是最大的。尽管字段的位置不会变化，但不同指令会将其用于不同目的。混合编码方法拥有多种由操作码指定的格式，添加了一到两个字段来指定寻址方式，还有一到两个字段来指定操作数地址

让我们看一条80x86指令，作为变长编码的一个例子。

1

add EAX, 1000(EBX)

80x86指令的长度介于1~17个字节之间。80x86程序通常短于RISC体系结构，后者使用定长格式。

有了变长编码和定长编码这两种指令集设计的极端情况之后，立即就可以想到第三种选择：降低变长体系结构中指令大小与任务的变化程度，但提供多种指令长度，以缩小代码尺寸。这种混合式方法是第三种编码选择，稍后将会看到其示例。

RISC中 的精简代码

嵌入式应用程序中的成本和缩短代码非常重要，随着RISC计算机开始进入这一领域，32位定长格式已经成为一种负担。为应对这一情况，几家制造商提供了其RISC指令集的一种新混合版本，同时拥有16位和32位指令。这些较窄的指令支持较少的运算、较小的地址：与立即数字段、较少的寄存器和两地址格式，而不是RISC计算机的典型三地址格式。

小结：指令集编码

前几节讨论了指令集设计时所作的决策，这些决策决定了架构师是否能够在变长指令编码和定长指令编码之间进行选择。给定选择之后，那些看重代码规模多于性能的架构师会选择变长编码，而看重性能多于看重代码规模的架构师则会选择定长编码。附录E给出了架构师的13个选择结果示例。在第3章和附录C中进一步讨论这种变化对处理器性能的影响。我们几乎已经为将在A.9节介绍的MIPS指令集体系结构奠定了基础。但在开始介绍之前，先来简要地了解一下编译器技术及其对程序特性的影响，这也会有所帮助。

交叉问题：编译器的角色

今天，几乎所有的台式机和服务器应用程序都是用高级语言编写的。这种开发意味着：由于所执行的大多数指令都是编译器的输出，所以指令集体系结构基本上就是编译器目标。在这些应用程序的早期，在体系结构方面作出的决策经常是为了简化汇编语言编程，或者是针对特定内核。由于编译器会显著影响到计算机的性能，所以理解今天的编译器技术对于设计、高效实现指令集是至关重要的。

体系结构方面的选择会影响到为一台计算机生成的代码质量和为其构造优良编译器的复杂性，这种影响可能是正面的，也可能是负面的。在这一节，我们主要从编译器的视角来讨论指令集的关键目标。首先回顾对当前编译器的剖析。接下来讨论编译器技术如何影响架构师的决策，还有架构师如何增大或降低编译器生成良好代码的难度。最后回顾编译器和多媒体处理。

目前编译器的结构

首先让我们看看今天的最佳编译器是什么样的。图A-12显示了目前编译器的结构。

图A-12 编译器通常包括2~4遍扫描（pass），一些优化程度更高的编译器会有更多遍扫描。当输入相同时，以不同优化级别编译的程序应当给出相同结果，图上的结构将这种可能性增至最大。优化扫描的设计是希望获得最优代码，如果希望加快编译速度，并且可以接受较低质量的代码，那就可以跳过优化扫描。扫描就是编译器读取和转换整个程序的一个阶段（phase）。由于优化扫描是独立的，所以有多种语言使用了相同的优化和代码生成扫描。一种新的语言只需要一个新的前端即可

编译器编写人员的首要目标是正确性——所有有效程序的编译结果都必须正确。第二个目标通常是编译后的代码速度。通常，还有一整套目标排在这两个目标之后，包括快速编译、支持调试、语言之间的互操作性。正常情况下，编译器中的各次扫描将更抽象的高级表示转换为逐渐降低层级的表示方式。最后到达指令集级别。这种结构可以帮助控制转换的复杂度，更容易编写出没有错误的编译器。

正确编写编译器是一件很复杂的事情，而所能完成的优化程度主要受这一复杂度的限制。尽管采用多遍扫描结构可以帮助降低编译器的复杂性，但它也意味普编译器必须进行排序，某些转换必须在其他转换之前完成。在图A-12所示的优化编译器框图中可以看出，某些高级优化要在执行很久之后，才可能知道最终代码会是什么样子。一旦执行这种转换，编译器就不太可能再返回并重新审视所有步骤，甚至撤消这些转换，这样的成本太过高昂。无论是编译时间还是复杂性，都不允许进行这种迭代。因此，编译器假定最后的几个步骤有能力处理特殊的问题。

例如，在知道被调用过程的确切大小之前，编译器通常就必须选择对哪些进程调用进行内联展开。编译器编写人员将这一问题称为阶段排序问题。这种转换排序如何与指令集体系结构互动呢?一种名为全局公共子表达式消去法的优化提供了一个很好的例子。这种优化找出一个表达式计算相同取值的两个实例，并将第一次计算的结果值保存在临时存储位置。然后利用这个临时值，清除这一公共表达式的第二次计算。为使这一优化发挥显著效用，必须将临时值分配到寄存器中。否则，先将临时值存储在存储器中，之后再重新载入它，其成本将会抵消因为不用重复计算该表达式所节省的成本。

的确存在一些情况：如果没有将临时值保存到寄存器中，这一优化会减缓代码的运行速度。寄存器分配通常是全局优化扫描即将结束、马上要生成代码时进行的，所以阶段排序使上述问题变得复杂。因此，执行这一优化的优化程序必须假定寄存器分配器会将这一临时值分配到寄存器中。根据转移类型，可以将现代编译器执行的优化进行如下分类：

• 高级优化一般对源代码执行，并将输出结果传送给之后的优化扫描；
• 本地优化仅对直行代码段（编译器设计者称为基本块）内的代码进行优化；
• 全局优化将本地优化扩展到分支范围之外，并引入了一组专为优化循环的转换；
• 寄存器分配将寄存器与操作数关联在一起；
• 与处理器相关的优化尝试充分利用特定的体系结构知识；

寄存器分配

鉴于寄存器分配在加快代码速度和使其他优化发挥效用方面扮演的角色，可以说它是最重要的优化之一。今天的寄存器分配算法以一种称为图形着色的技术为基础。这种图形着色技术背后的基本思想是构造一幅图，用来表示可能执行的寄存器分配方案，然后利用这个图来分配寄存器。大致来说，问题在于如何使用有限种颜色，使相关图中两个相邻节点的颜色都不相同。这种方法的重点是将活跃变量全部分配到寄存器中。图形着色问题的求解时间通常是图形大小的指数函数。不过，有一些启发式算法在实际中的应用效果很好，生成分配结果的时间近似与图形大小成线性关系。

当至少有16个通用寄存器（多多益善）可用于为整数变量进行全局分配，而且有其他寄存器分配为浮点变量时，图形着色方法的效果最好。遗憾的是，如果寄存器的数目很少，图形着色的启发式算法很可能会失败，所以图形着色的效果不是太好。

优化对性能的影响

有时很难将一些较简单的优化（本地优化和与处理器相关的优化）与代码生成器中完成的转换隔离开来。典型优化的示例在表A-8中给出。表A-8的最后一列指明对源程序执行所列优化转换的频率。

• 第三列给出一些常见优化在一组12个小型Fortran和Pascal程序中的静态应用频率。在测量过程中，编译器共完成了9个本地与全局优化。图中给出了这些优化中的6种，剩下3种的总静态频率占18%。“未测量”是指没有测上该优化方法的使用次数。与处理器相关的优化通常是在代码生成器中完成，所有这些优化都未在此次试验中测量。所示百分比是特定类型的静态优化所占的比例。

图A-13显示了对两个程序的指令进行各种优化的效果。在这个例子中，与未经优化的程序相比，已优化程序执行的指令数会减少大约25%~90%。该图表明在提议新指令集功能之前首先浏览已优化代码的重要性，因为编译器可能会将架构师正在尝试改进的指令完全清除。

图A-13 当编译器优化级别变化时，SPEC2000 中lucas和mcf程序中指令数目的变化。第0级表示未优化代码。第1级包含本地优化、代码调度和本地寄存器分配。第2级包括全局优化、循环转换（软件流水线）和全局寄存器分配。第3级增加了过程整合。

编译器与高级语言之间的互动显著影响着程序利用指令集体系结构的方式。这里有两个重要问题：如何对变量进行分配和寻址?需要多少个寄存器才能对变量进行适当分配?为了回答这些问题，必须看看当前高级语言用来保存数据的三个独立区域。

• 栈用于分配本地变量。栈会在进程调用与返回时相应增大或缩小。栈内的对象是相对于栈指针进行行寻址的，这些对象主要是标量（单变量），而不是数组。栈用于活动记录，而不是用于表达式求值。因此，几乎从来不会在栈中压入或弹出数值。
• 全局数据区用于静态分配所声明的对象，比如全局变量和常量。这些对象中有很大一部分都是数组或者其他聚合数据结构。
• 堆用于分配那些不符合栈规则的动态对象。堆中的对象用指针访问，通常不是标量。

对于分配到栈中的对象，寄存器分配的处理效率要远高于对全局变量的处理效率，而寄存器分配对于分配到堆中的对象基本上不可能实现，因为它们是用指针访问的。全局变量和一些栈变量也不可能分配，因为它们具有别名，也就是说有多种方法可以引用变量的地址，从而不能合法地将其放到寄存器中。

例如，考虑以下代码序列，其中&返回变量的地址，*取得指针所指向的对象：

1
2
3
4

p = &a;  // 将a的地址放入p中
a = ..   // 直接为a赋值
*p =  .. // 使用ρ为a赋值
...a...  // 访问a

不可能跨过对*p的赋值而对变量a进行寄存器分配，同时还不生成错误代码。在使用别名时，通常很难甚至不可能判断指针可能指向哪些对象，所以会导致一个实质性问题。编译器必然为保守的，如果有指针可能指向过程中的多个本地变量之一，某些编译器就不会在寄存器中分配该过程的任意本地变量。

架构师如何帮助编译器编写人员

今天，编译器的复杂性并非来自对诸如A=B+C等简单语句的转换。大多数程序都具有局部简单性，简单转换的效果很好。之所以会有这种复杂性，是因为程序规模庞大而且其全局互动非常复杂，还因为编译器的结构决定了在判定哪种代码序列最佳时，一次只能判断一步。编译器编写人员在工作时，通常会遵循他们自己对一条体系结构基础原理的推论：加快常见情况的速度、保证少见情况的正确性。

一些指令集特性可以为编译器编写人员提供帮助。这些特性不应被看作需要严格执行的规则，而应当看到一种指南，便于编写出生成高效、正确代码的编译器。

• 提供正则性——只要可能，指令集的三个要素操作、数据类型和寻址方式，就应当是正交的。如果体系结构的两个方面互不影响，就说它们是正交的。以操作和寻址方式为例，如果对于任何一个可以应用寻址方式的操作，都可以向其应用所有寻址方式，那就说操作和寻址是正交的。这种正则性有助于简化代码生成过程，如果在决定生成何种代码时，需要分散在编译器的两遍扫描中做出决策，那这一特性尤为重要。这一特性的一个典型反例是：限制可供特定指令类型使用的寄存器。针对专用寄存器体系结构的编译器通常会陷入这种两难境地。因为这一限制，编译器可能会发现有许多空闲寄存器，但却都不适用!
• 提供原型而非解决方案——与一种语言构造或内核功能“相匹配”的特殊功能通常是无法使用的。为支持高级语言所做的尝试可能仅对一种语言有效，也可能与该种语言的正确、高效实现相偏离，可能有点过头，也可能有所不及。
• 简化候选项之间的权衡——对于编译器编写人员来说，最艰巨的任务之一就是对于所出现的任何一段代码，都能指出哪种指令序列最为适合。设计者所
  做的任何事情，只要能够帮助编译器编写人员了解替代代码序列的成本，就能帮助改进代码。在进行这种复杂权衡时，最困难的情景之一发生在寄存器存储器体系结构中，就是判断一个变量的引用次数达到多大数值以后，将其载入寄存器的成本才会更低一些。
• 提供一些指令，将编译时的已知量绑定为常量——编译器编写人员特别讨厌处理器在运行时费力解读一个在编译时就已经知晓的取值。有些指令需要解读在编译时就已经固定的取值，这就是以上原则的绝佳反例之一。例如， VAX进程调用指令（calls）会动态解释一个掩码，这个掩码说明在进行调用时要保存哪些寄存器，但它在编译时就已经固定下来了。

编译器对多媒体指令的支持

SIMD指令实际是一种出色体系结构的简化版本，它拥有自己的编译器技术。多媒体内核最初是为科学代码发明的，通常也是可以向量化的，当然通常是处理较短的向量。我们可以将Intel 的MMX和SSE或者PowerPC的AltiVec 看作简单的短向量计算机：MMX的向量可以有8个8位元素、4个16位元素或2个32位元素，AItiVec 的向量长度是以上长度的两倍。它们被实现为宽寄存器中的相邻窄元素。

这些微处理器体系结构将向量寄存器大小设定到体系结构内部：对于MMX，元素大小的总和限制为64位，AltiVec 限制为128位。当Intel决定扩展到128位向量时，它添加了一整套新指令，名为流式SIMD扩展（SSE）。

向量计算机的一个主要优势是：一次载入许多元素，然后将执行与数据传输重叠起来，从而隐藏存储器访问的延迟。向量寻址方式的目标是收集散布在存储器中的数据，以紧凑方式放置它们，便于对其进行高效处理，然后再将处理结果放回所属位置。向量计算机包括步幅寻址和集中/分散寻址，以提高可向量化程序的数目。步幅寻址在每次访问之间跳过数量固定的一些字，所以顺序寻址经常被称为单位步幅寻址。集中与分散寻址在另一个向量寄存器中查找其地址：将其看作向量计算机的寄存器间接寻址。与之相对，从向量的角度来看，这些短向量SIMD计算机仅支持单位步幅访问：存储器访向一次从单个宽存储器位置载入或存储所有元素。由于多媒体应用程序的数据经常是一些流，起始点和终止点都在存储器中，步幅寻址方式和集中/分散寻址方式是成功实现向量化的必备条件。

下面的例子将一个向量计算机与MMX进行对比，将像素的色彩表示方式由RGB（红、绿、蓝）转换为YUV （发光度色度），每个像素用3个字节表示。这种转换只需要三行C代码，放在循环中即可：

1
2
3

Y = (9798*R  + 19235*G + 3736*B) / 32768;
U = (-4784*R - 9437*G + 4221*B) / 32768 + 128;
V = (20218*R - 16941*G - 3277*B) / 32768 + 128;

• 3次向量载入（以获得RGB）;
• 3次向量相乘（转换R）;
• 6次向量乘加（转换G和B）;
• 3次向量移位（除以32768）;
• 2次向量加（加上128）;
• 3次向量存储（存储YUV）。

总共有20条指令用于执行前面C代码中转换8个像素的20个操作。（由于向量可能有32 个64 位元素，这一代码实际上可以转换最多32x 8 = 256个像素。）

与之相对，Intel网站显示一个对8个像素执行相同计算的库例程使用了116条MMX指令和6个80x86指令。指令数之所以会增加到6倍是因为没有步幅存储器访问，需要大量的指令来载入RGB像素并解包，然后再打包并存储YUV像素。

采用受体系结构限制的短向量，而且没有多少寄存器和简单的存储器寻址方式，就很难利用向量化编译器技术。因此，这些SIMD指令更可能出现于硬编码库中，而不是编译后的代码中。

小结：编译器的角色

这一节给出了几点建议。第一，我们希望一种新的指令集体系结构中至少拥有16个通用寄存器（另外用于浮点数的寄存器不计在内），以简化使用图形着色的寄存器分配。关于正交性的建议意味着所支持的全部寻址方式都适用于所有传送数据的指令。最后的三点建议（提供原型而非解决方案、简化候选项之间的权衡、不要在运行时绑定常量）都意味着注重简单性是最稳妥的。换句话说，要想清楚，在指令集设计中，少就是多。SIMD扩展是一个出色营销的例子，而不是软硬件协调设计的杰出成果。

融会贯通：MIPS体系结构

在这一节，我们介绍一种名为MIPS的简单64位载入-存储体系结构。MIPS和RISC系列的指令集体系结构的基础与前几节讨论的内容相似。下面回顾一 下我们在每一节对桌面应用程序的期望。

• A.2节——以载入-存储体系结构使用通用寄存器。
• A.3节——支持以下寻址方式：位移量（地址偏移大小为12~16位）立即数（大小为8~16位）和寄存器间接寻址。
• A.4节——支持以下数据大小和类型： 8位、16位、32位和64位整数以及64位IEEE 754浮点数。
• A.5节——支持以下简单指令（它们占所执行指令的绝大多数）：载入、存储、加、减、移动寄存器和移位。
• A.6节——相等、 不相等、小于、分支（长度至少为8位的PC相对地址）、跳转、调用和返回。
• A.7节——如果关注性能则使用定长指令编码， 如果关注代码规模则使用变长指令编码。
• A.8节——至少提供 16个通用寄存器，确保所有寻址模式可应用于所有数据传送指令，希望获得最小规模的指令集。这一节并没有包含浮点程序，但它们经常使用独立的浮点寄存器。其理由是增大寄存器的总数，但不会在指令格式或通用寄存器堆的速度方面产生问题。不过，这两个方面并非相互独立。

我们在介绍MIPS时，将展示它是如何遵循这些建议的。与最近的大多数计算机类似， MIPS强调：

• 简单的载入-存储指令集；
• 针对流水线效率的设计，包括定长指令集编码；
• 编译器目标的效率。

从1985年诞生第一个MIPS处理器以来，已经发布了MIPS的许多版本。我们将使用其中一个现在被称为MIPS64的子集，它经常被简写为MIPS。

MIPS的寄存器

MIPS64有32个64位通用寄存器（GPR），郎R0、R…..R31。GPR有时也称为整数寄存器。此外，还有一组32位浮点寄存器（FPR），即F0、F…..F31，它可以保存32个单精度（32位）值或32位双精度（64位）值。（在保存一个单精度数时，另一半FPR没有使用。）它提供了单精度和双精度浮点运算（32位和64位）。MIPS还包括在单个64位浮点寄存器中对两个单精度操作数进行运算的指令。

R0的值总是0。一些特殊寄存器可以与通用寄存器进行相互转换。其中一个例子就是浮点状态寄存器，用于保存有关浮点运算结果的信息。还有一些指令用于在FPR和GPR之间移动数据。

MIPS的数据类型

MIPS的数据类型包括8位字节、16 位半字、32 位字和64位双字整型数据和32位单精度与64位双精度浮点数据。添加半字是因为它们在诸如C之类的语言中存在这一类型，而且在一些关注数据结构大小的程序（比如操作系统）中非常普遍。出于类似原因添加了单精度浮点操作数。

MIPS64操作对64位整数和32位或64位浮点数进行操作。字节、半字和字被载入通用寄存器中，并通过重复0或符号位来填充GPR的64个位。一旦载入之后，就可以用64位整数运算对其进行操作。

MIPS的数据传输的寻址方式

仅有的数据寻址方式就是立即数寻址和位移寻址，均采用16位字段。寄存器间接寻址通过在16位位移字段中放置0来实现，而采用16位字段的寻址则是以寄存器0为基址寄存器来完成的。尽管这种体系结构中仅支持两种寻址方式，但通过包含0提供了四种有效方式。MIPS存储器可以用64位地址进行字节寻址。它有一个方式位，允许软件选择大端或小端。由于它是一个载入-存储体系结构，介于存储器与GPS或FRP之间的所有引用都是通过载入或存储完成的。通过支持上述数据类型，涉及GPR的存储器访问可以是字节、半字、字或双字。FPR可以载入和存储单精度或双精度数。所有存储器访问都必须对齐。

MIPS指令格式

由于MIPS只有两种寻址方式，所以能把它们编码到操作码中。为便于处理器实现流水线和译码，所有指令的长度都是32位，其中有一个6位的主操作码。图A-14显示了指令布局。这些格式非常简单，提供16位字段用于位移量寻址、立即数常量寻址或PC相对分支寻址。

图A-14 MIPS的指令布局。所有指令均采用三种类型之一进行编码 ，在每种格式的相同位置有公共字段

MIPS 操作

MIPS支持前面推荐的简单操作及其他一些操作。共有四大类指令：载入与存储、ALU运算、分支与跳转、浮点运算。

任意通用或浮点寄存器都可以载入或存储，只是载入R0没有任何效果。表A-9给出载入与存储指令的一些例子。单精度浮点数占据浮点寄存器的一半。单、双精度之间的转换必须显式完成。浮点格式为IEEE754。表A-12中列出了这部分给出的全部MIPS指令。

• 均使用单一寻址方式，需要存储器值对齐。当然，载入和存储都可用于全部所示数据类型。

为理解这些图形，需要对最初在A.3.2节使用的C描述语言再进行些扩展。

• 只要所传送数据的长度不够明确，则向符号←附加一个下标。因此，←n表示传送一个n位量。我们使用x, y←z表示应当将z传送给x和y
• 使用一个下标来表示选择字段中的某一位。在标记字段中的各个位时，最高有效位从0开始。下标可能是单个数位，也可能是一个子范围。
• 变量Mem用作一个表示主存储器的数组，它是按字节地址索引，可以传送任意数目的字节。
• 使用一个上标来表示复制字段（例如，048 给出长度为48位的全零字段）。
• 使用符号#将两个字段串联在一起， 可能出现在数据传输的任一端。

例如，假定R8和R10为64位寄存器：

1

Regs[R10]32, 63 ←32 (Mem[Regs [R8]]10) 24 ## Mem[Regs{R8]]

所有ALU指令都是寄存器-寄存器指令。表A-10给出了算术/逻辑指令的一些例子。这些操作包括简单的算术和逻辑运算：加、减、AND、 OR、XOR 和移位。所有这些指令的立即数形式都是用16位符号扩展立即数提供的。操作LUI （加载高位立即数）加载一个寄存器的第32~47位，并将该寄存器的其他位设置为0。LUI 允许在两条指令中内置一个32位常数，也可以在一个额外指令中使用任意常数32位地址进行数据传送。

前面曾经提到，R0用于合并常见操作。载入常数的操作，其实就是执行一个源操作数为R的加立即数指令，寄存器-寄存器移动就是源操作数之一为 R0的加法。我们有时会使用助记符LI（表示载入立即数， load immediate）来表示前者，用助记符MOV表示后者。

MIPS控制流指令

MIPS提供比较指令，它比较两个寄存器，查看第一个寄存器是否小于第二个寄存器。如果该条件为真，则这些指令在目标寄存器中放入1 （表示真）;否则，放入数值0。因为这些操作会对寄存器进行“置位”，所以它们被称为“相等置位”、“不相等置位”、“小于置位”，等等。这些比较指令还有立即数形式。

控制是通过一组跳转指令和一组分支指令处理的。表A-11给出了一些典型的分支与跳转指定。通过两种指定目标地址的方法以及是否设定链接来区分四种跳转指令。两种跳转指令使用一个进行两位移位的26位偏移量，然后替代程序计数器的低28位，以确定目标地址（程序计数器是指该跳转指令后面指令的程序计数器）。另两种跳转指令指定了包含目标地址的寄存器。共有两类跳转：单纯跳转和跳转并链接（用于过程调用）。后者将返回地址（下-条顺序指令的地址）放在R31中。

所有分支都是有条件的。分支条件由指令指定，它可以测试寄存器源操作数是否为0；寄存器可以包含一个数据值或比较的结果。还有一些条件分支指令用于判断一个寄存器是否为负数，以及两个寄存器是否相等。分支目标地址由一个16位有符号偏移量指定，该偏移量被左移两位，然后加到指向下一顺序指令的程序计数器。还有一个分支用来关注浮点条件分支的浮点状态寄存器，如下文所述。

条件分支是流水线执行的主要挑战；因此，许多体系结构增加了用于将简单分支转换为条件算术指令的指令。MIPS 包含在等于零或不等于零时执行的条件移动。目标寄存器的值或者保持不变，或者由源寄存器之一的副本 替代，具体取决于其他源寄存器的值是否为零。

MIPS浮点运算

浮点运算操控浮点寄存器，并指出运算是以单精度还是双精度执行。操作MOV.S和MOV.D将一个单精度（Mov.S）或双精度（MOV.D）浮点寄存器复制到另一个同种类型的寄存器中。操作MFC1、MTC1、 DMFC1 和DMTC1在单精度或双精度寄存器与整数寄存器之间移动数据，而且还提供了整数向浮点的转换，反之亦然。

浮点运算为加、臧、乘、除；后缀D表示双精度，后缀S表示单精度（例如， ADD.D、 ADD.S、SUB.D、SUB.S、MUL.D、MUL.S、DIV.D、DIV.S）。 浮点比较指令会对特殊浮点状态寄存器中的一个位进行置位，有一对分支指令可以检测这个位，即： BC1T 和BC1F，也就是浮点真分支和浮点假
分支。

为进一步提高图形例程的性能， MIPS64中提供了一些可以针对64位高低位执行2个32位浮点操作的指令。这些成对单精度操作包括：ADD.PS、 SUB.PS、MUL.PS和DIV.PS。（它们使用双精度载入和存储指令进行载入和存储。）MIPS64认识到多媒体应用程序的重要性，还引入了整数与浮点乘加指令： MADD、 MADD.S、MADD.D和MADD.PS。在这些合并操作中，寄存器的宽度都相同。表A-12给出了一部分 MIPS64操作的清单及其含义。

MIPS指令集的使用

为使读者了解哪些指令使用得更为频繁，表A-13中给出了5个SPECint2000程序中各指令及指令类别的使用频率，表A-14给出了对于5个SPECfp2000程序的相同数据。

存储器层次结构回顾

引言

本附录对存储器层次结构进行了快速回顾，包括缓存与虚拟存储器的基础知识、性能公式、简单优化。第一节介绍下面36个术语。

• 缓存（cache）
• 全相联（fully associative）
• 写入分派（write allocate）
• 虚拟存储器（virtual memory）
• 重写（脏）位（dirtybit）
• 统一缓存（unifed cache）
• 存储器停顿周期（memorystallcycles）
• 块偏移（block offset）
• 每条指令缺失数（misses per instruction）
• 直接映射（direct mnapped）
• 写回（write back）
• 块（block）
• 有效位（valid bit）
• 数据缓存（data cache）
• 局域性（locality）
• 块地址（block address）
• 命中时间（hittime）
• 地址跟踪（address trace）
• 直写（write through）
• 缓存缺失（cache miss）
• 组（set）
• 指令缓存（instruction cache）
• 页面错误（page fault）
• 随机替换（random replacement）
• 存储器平均访问时间（average memory access time）
• 缺失率（missrate）
• 索引字段（index feld）
• 缓存命中（cache hit）
• n路组相联（n-way set associative）
• 无写入分派（no-write allocate）
• 页（page）
• 最近最少使用（least-recently used）
• 写入缓冲区（write buffer）
• 缺失代价（miss penalty）
• 标志字段（tagfield）
• 写停顿（write stall）

缓存是指地址离开处理器后遇到的最高级或第一级存储器层次结构。由于��域性原理适用于许多级别，而且充分利用局域性来提高性能的做法非常普遍，所以现在只要利用缓冲方法来重复使用常见项目，就可以使用缓存，文件缓存、名称缓存等都是一些实例。

如果处理器在缓存中找到了所需要的数据项，就说发生了缓存命中。如果处理器没有在缓存中找到所需要的数据项，就是发生了缓存缺失。从主存储器中提取固定大小且包含所需字的数据集，并将其放在缓存中，这个数据集称为块。时域局域性告诉我们：我们很可能会在不远的将来再用到这个字，所以把它放在缓存中是有用的，在这里可以快速访问它。由于空域局域性，马上用到这个块中其他数据的可能性也很高。

缓存缺失需要的时间取决于存储器的延迟和带宽。延迟决定了提取块中第一个字的时间，带宽决定了提取这个块中其他内容的时间。缓存缺失由硬件处理，会导致采用循序执行方式的处理器暂停或停顿，直到数据可用为止。在采用乱序执行方式时，需要使用该结果的指令仍然必须等待，但其他指令可以在缺失期间继续进行。

与此类似，程序引用的所有对象不一定都要驻存在主存储器中。虚拟存储器意味着一些对象可以驻存在磁盘上。地址空间通常被分为固定大小的块，称为页。在任何时候，每个页要么在主存储器中，要么在磁盘上。当处理器引用一个页中既不在缓存中也不在主存储器中的数据项时，就会发生页错误，并把整个页从磁盘移到主存储器中。由于页错误消耗的时间太长，所以它们由软件处理，处理器不会停顿。在进行磁盘访问时，处理器通常会切换到其他某一任务。从更高级别来看，缓存和主存储器在对引用局域性的依赖性方面、在大小和单个位成本等方面的关系，类似于主存储器与磁盘的相应关系。

表B-1给出了各种计算机（从高端台式机到低端服务器）每一级存储器层次结构的大小与访问时间范围。

• 嵌入式计算机可能没有磁盘存储，存储器和缓存也要小得多。在移向层次结构的更低级别时，访问时间延长，从而有可能以较低的反应速度来管理数据传输。实现技术显示了这些功能所用的典型技术。

缓存性能回顾

由于局域性的原因，再加上存储器越小其速度越快，所以存储器层次结构可以显著提高性能。评价缓存性能的一种方法是扩展第1章给出的处理器执行时间公式。我们现在考虑处理器在等待存储器访问而停顿时的周期数目，称为存储器停顿周期。性能结果为处理器周期与存储器停顿周期之和与时钟周期时间的乘积：

CPU执行时间 = （CPU时钟周期+存储器停顿周期） x时钟周期时间

此公式假定CPU时钟周期包括处理缓存命中的时间，并假定处理器在发生缓存缺失时停顿。

存储器停顿周期数取决于缺失数目和每次缺失的成本，后者称为缺失代价：

存储器停顿周期 = 缺失数 x 缺失代价 = IC x 缺失/指令 x 缺失代价 = IC x 存储器访问/指令 x 缺失率 x 缺失代价

最后一种形式的优点在于其各个分量容易测量。我们已经知道如何测量指令数（IC）。（对于推测处理器，只计算提交的指令数。）可以采用同一方式来测量每条指令的存储器引用数；每条指令需要一次指令访问，很容易判断它是否还需要数据访问。

注意，我们计算出缺失代价，作为平均值，但下面将其作为常数使用。在发生缺失时，缓存后面的存储器可能因为先前的存储器请求或存储器刷新而处于繁忙状态。在处理器、总线和存储器的不同时钟之间进行交互时，时钟周期数也可能发生变化。所以请记住，为缺失代价使用单一数值是一种简化。

缺失率分量就是缓存访问中导致缺失的访问比例（即，导致缺失的访问数除以总访问数）。缺失率可以用缓存模拟器测量，它会取得指令与数据引用的地址跟踪，模拟该缓存行为，以判断哪些引用命中，哪些缺失，然后汇报命中与缺失总数。今天的许多微处理器提供了用于计算缺失与存储器引用数的硬件，这一缺失率测量方式要容易得多、快得多。

由于读取和写入操作的缺失率和缺失代码通常是不同的，所以上面的公式得出的是一个近似值。存储器停顿时钟周期可以用每条指令的存储器访问次数、读写操作的缺失代价（以时钟周期为单位入读写操作的缺失率来定义：

存储器停顿时钟周期 = IC x 每条指令的读取操作 x 读取缺失率 x 读取缺失代价 + IC x 每条指令的写入操作 x 写入缺失率 x 写入缺失代价

我们通常会合并读写操作，求出读取与写入操作的平均缺失度与缺失代价，以简化上面的完整公式：

存储器停顿时钟周期 = IC x 存储器访问/指令 x 缺失率 x 缺失代价

缺失率是缓存设计中最重要的度量之一，但在后面各节将会看到，它不是唯一的度量标准。

假定有一个计算机，当所有存储器访向都在缓存中命中时，其每条指令的周期数（CPI）为1.0。仅有的数据访问就是载入和存储，占总指令数的50%。如果缺失代价为25个时钟周期，缺失率为2%，当所有指令都在缓存中命中时，计算机可以加快多少?

首先计算计算机总是命中时的性能：

CPU执行时间 = (CPU时钟周期+存储器停顿周期) x 时钟周期 = (IC x CPI+0) x 时间周期 = IC x 1.0 x 时间周期

现在，对于采用实际缓存的计算机，首先计算存储器停顿周期：

存储器停顿周期 = IC x 存储器访问数/指令 x 缺失率 x 缺失代价 = IC x (1+0.5) x 0.02 x 25 = IC x 0.75

式中，中间项（1+0.5）表示每条指令有1次指令访问和0.5次数据访问。总性能为：

CPU执行时间（缓存） = (IC x 1.0 + IC x 0.75) x 时间周期 = 1.75 x IC x 时钟周期

性能比是执行时间的倒数：

CPU执行时间（缓存）/CPU执行时间 = (1.75 x IC x 时钟周期) / (1.0 x IC x 时钟周期) = 1.75

没有缓存缺失时，计算机的速度为有缺失时的1.75倍。

一些设计师在测量缺失率时更愿意表示为每条指令的缺失数，而不是每次存储器引用的缺失数。这两者的关系为：
缺失数/指令数 = 缺失数 x 存储器访问数 / 指令数 = 缺失数 x 存储器访问数 / 指令数

如果知道每条指令的平均存储器访问数，后面一个公式是有用的，因为这样可以将缺失率转换为每条指令的缺失数，反之亦然。例如，我们可以将上面示例中每次存储器引用的缺失率转换为每条指令的缺失：

缺失数/指令数 = 缺失数 x 存储器访问数/指令数 = 0.02 x 1.5 = 0.030

顺便说一下， 每条指令的缺失数经常以每千条指令的缺失数给出，以显示整数而非小数。因此，上面的答案也可以表示为每1000条指令发生30次缺失。

表示为“每条指令的缺失数”的好处在于它与硬件实现无关。例如，推测处理器提取的指令数大约是实际提交指令数的两倍，如果测量每次存储器引用而非每条指令的缺失数，那么就可以人为地降低缺失率。其缺点在于每条指令的缺失数与体系结构相关;例如，对于80x86与MIPS，每条指令的存储器访问平均数可能会有很大不同。因此，对于仅使用单一计算机系列的架构师，最常使用的是每条指令的缺失数，不过与RISC体系结构的相似性也可以让人们深入理解其他体系结构。

为了展示这两个缺失率公式的等价性，让我们重做上面的例题，这一次假定每千条指令的缺失率为30。根据指令个数，存储器停顿时间为多少?

重新计算存储器停顿周期：存储器停顿周期 = 缺失数 x 缺失代价 = IC x 缺失数/指令数 x 缺失代价 = IC/1000 x 缺失数/(指令数x1000) x 缺失代价 = IC/1000 x 30 x 25 = IC x 0.75

得到的答案与前面的例题相同，表明这两个公式的等价性。

4个存储器层次结构问题

我们通过回答有关存储器层次结构第一级的4个常见问题来继续对缓存的介绍。

• 问题1：一个块可以放在上-级的什么位置? （块的放置）
• 问题2：如果一个块在上一级中，如何找到它? （块的识别）
• 问题3：在缺失时应当替换哪个块? （块的替换）
• 问题4：在写入时会发生什么? （写入策略）

这些问题的答案可以帮助我们理解存储器在层次结构不同级别所做的不同折中；因此，我们对每个示例都会问这四个问题。

问题1：一个块可以放在缓存中的什么位置?

图B-1显示，根据对块放置位置的限制，可以将缓存组织方式分为以下三类。

• 如果每个块只能出现在缓存中的一个位置，就说这一缓存是直接映射的。这种映射通常是：(块地址)MOD(缓存中的块数)
• 如果一个块可以放在缓存中的任意位置，就说该缓存是全相联的。
• 如果一个块可以放在缓存中由有限个位置组成的组（set）内，则该缓存是组相联的。组就是缓存中的一组块。块首先映射到组，然后这个块可以放在这个组中的任意位置。通常以位选择方式来选定组：(块地址)MOD(缓存中的组数)，如果组中有n个块，则称该缓存放置为n路组相联。

从直接映射到全相联的缓存范围实际上就是组相联的一个统一体。直接映射就是一路组相联，拥有m个块的全相联缓存可以称为“m路组相联”。同样，直接映射可以看作是拥有m个组，全相联可以看作拥有一个组。

图B-1 这一缓存示例有8个块帧，存储器有32个块。三种缓存选项由左向右给出。在全相联中，来自较低层级的块12可以进入该缓存8个块帧的任意一个。采用直接映射时，块12只能放在块帧4（12 mod 8）中。组相联拥有这两者的一些共同特性，允许这个块放在第0组的任意位置（12 mod 4）。由于每个组中有两个块，所以这意味着块12可以放在缓存的块0或块1中。实际缓存包含数千个块帧，实际存储器包含数百万个块。拥有四个组、每组两个块的组相联组织形式称为两路组相联。假定缓存中没有内容，而且所关心的块地址确认了较低级别的块12

今天的绝大多数处理器缓存为直接映射、两路组相联或四路组相联，其原因将在稍后介绍。

问题2：如果一个块就在缓存中，如何找到它?

缓存中拥有每个块帧的地址标志，给出块地址。每个缓存块的标志中可能包含所需要的信息，会对这些标志进行查看，以了解它是否与来自处理器的块地址匹配。由于速度非常重要，所以会对所有可能标志进行并行扫描，这是一条规则。

必须存在一种方法来获知缓存块中不包含有效信息。最常见的过程是向标志中添加一个有效位，表明这一项是否包含有效地址。如果没有对这个位进行置位，那就不可能存在对这一地址的匹配。

在继续讨论下一问题之前，先来研究一个处理器地址与缓存的关系。图B-2显示了址是如何划分的。第一次划分是在块地址和块偏移之间，然后再将块帧地址进一步分为标志字段和索引字段。块偏移字段从块中选择期望数据，索引字段选择组，通过对比标志字段来判断是否命中。尽管可以对标志之外的更多地址位进行对比，但并不需要如此，原因如下所述。

• 在对比中不应使用偏移量，因为整个块或者存在或者不存在，因此，根据定义，所有块偏移都会导致匹配。
• 核对索引是多余的，因为它是用来选择待核对组的。例如，存储在第0组的地址，其索引字段必须为0，否则就不能存储在第0组中；第1组的索引值必须为1，以此类推。这一优化通过缩小缓存标志的宽度来节省硬件和功率。

图B-2 组相联或直接映射缓存中地址的三个组成部分。标志用于检查组中的所有块，索引用于选择该组。块偏移是块中所需数据的地址。全相联缓存没有索引字段

如果总缓存大小保持不变，增大相联度将提高每个组中的块数，从而降低索引的大小、增大标志的大小。即，图B-2中的标志索引边界因为相联度增大而向右移动，到端点处就是全相关缓存，没有索引字段。

问题3：在缓存缺失时应当替换哪个块?

当发生缺失时，缓存控制器必须选择一个用期望数据替换的块。直接映射布置方式的好处就是简化了硬件判决——事实上，简单到没有选择了：只会查看一个块帧，以确定是否命中，而且只有这个块可被替换。对于全相联或组相联布置方式，在发生缺失时会有许多块可供选择。主要有以下三种策略用来选择替换哪个块。

• 随机——为进行均匀分配，候选块是随机选择的。一些系统生成伪随机块编号，以实现可重复的行为，这在调试硬件时有一定的用处。
• 最近最少使用（LRU）——为尽量避免抛弃不久就会用到的信息，会记录下对数据块的访问。依靠过去行为来预测未来，将替换掉未使用时间最久的块。LRU依赖于局域性的一条推论：如果最近用过的块很可能被再次用到，那么放弃最近最少使用的块是一种不错的选择。
• 先入先出（FIFO）——因为LRU的计算可能非常复杂，所以这一策略是通过确定最早的块来近似LRU，而不是直接确定LRU。

随机替换的一个好处是易于用硬件实现。随着要跟踪块数的增加，LRU的成本也变得越得来高，通常只能采用近似法。一种常见的近似方法（经常称为“伪LRU”）是为缓存中的每个组设定一组比特，每个比特应于缓存中的一路，一路就是组相联缓存中的条（bank）；四路组相联缓存中有四路。在访向一组时开启一个特定比特，这一比特与包含所需块的路相对应；如果与一个组相关联的所有比特都被开启，除最近刚被开启的比特之外，将所有其他比特关闭。在必须替换一个块时，处理器从相应被关闭的路中选择一个块，如果有多种选择，则随机选定。这种方法会给出近似LRU，这是因为自上次访问组中的所有块之后，被替换块再没有被访问过。

表B-2给出了LUR、随机和FIFO替换方式中的缺失率之差。

• 对于最大的缓存，LRU和随机方式之间没有什么差别，当缓存较小时，LUR胜过其他几种方式。当缓存较小时，FIFO通常优于随机方式。

问题4：在写入时发生什么?

大多数处理器缓存访问都是读取操作。所有指令访问都是读取，大多数指令不会向存储器写入数据。要加快常见情景的执行速度，就意味着要针对读取操作对缓存进行优化，尤其是处理器通常会等待读取的完成，而不会等待写入操作。但Amdahl定律提醒我们，高性能设计不能忽视写入操作的速度。

幸运的是，常见情景也是容易提升速度的情景。可以在读取和比对标志的同时从缓存中读取块，所以只要有了块地址就开始读取块。如果读取命中，则立即将块中所需部分传送给处理器。如果读取缺失，那就没有什么好处。

不能对写入操作应用这一优化。要想修改一个块，必须先核对标志，以查看该地址是否命中。由于标志核对不能并行执行，所以写入操作需要的时间通常要长于读取。另一种复杂性在于处理器还指定写入的大小，通常介于1~8个字节之间；只能改变一个块的相应部分。而读取则与之不同，可以毫无顾虑地访问超出所需的更多字节。写入策略通常可以用来区分缓存设计。在写入缓存时，有下面两种基本选项。

• 直写——信息被写入缓存中的块和低一级存储器中的块。
• 写回——信息仅被写到缓存中的块。修改后的缓存块仅在被替换时才被写到主存储器。

为减少在替换时写回块的频率，通常会使用一种称为重写（脏）位的功能。这一状态位表示一个块是脏的（在缓存中经历了修改）还是干净的（未被修改）。如果它是干净的，则在缺失时不会写回该块，因为在低级存储器中可以看到缓存中的相同信息。

写回和直写策略都有自己的优势。采用写回策略时，写入操作的速度与缓存存储器的速度相同，一个块中的多个写入操作只需要对低一级存储器进行一次写入。由于一些写入内容不会进入存储器，所以写回方式使用的存储器带宽较少，使写回策略对多处理器更具吸引力。由于写回策略对存储器层次结构其余部分及存储器互连的使用少于直写，所以它还可以节省功耗，对于嵌入式应用极具吸引力。

相对于写回策略，直写策略更容易实现。缓存总是清洁的，所以它与写回策略不同，读取缺失永远不会导致对低一级存储器的写入操作。直写策略还有一个好处：下一级存储器中拥有数据的最新副本，从而简化了数据一致性。数据一致性对于多处理器和IO来说非常重要。多级缓存使直写策略更适于高一级缓存，这是因为写入操作只需要传播到下一个较低级别，而不需要传播到所有主存储器。

稍后将会看到，IO和多处理器有些反复无常：它们希望为处理器缓存使用写回策略，以减少存储器通信流量，又希望使用直写策略，以与低级存储器层次结构保持缓存一致。如果处理器在直写期间必须等待写入操作的完成，则说该处理器处于写入停顿状态。减少写入停顿的常见优化方法是写入缓冲区，利用这一优化，数据被写入缓冲区之后，处理器就可以立即继续执行，从而将处理器执行与存储器更新重叠起来。稍后将会看到，即使有了写入缓冲区也会发生写入停顿。

由于在写入时并不需要数据，所以在发生写入缺失时共有以下两种选项。

• 写入分派——在发生写入缺失时将该块读到缓存中，随后对其执行写入命中操作。在这一很自然的选项中，写入缺失与读取缺失类似。
• 无写入分派——这显然是一种不太寻常的选项，写入缺失不会影响到缓存。而是仅修改低一级存储器中的块。

因此，在采用无写入分派策略时，在程序尝试读取块之前，这些块一直都在缓存之外，但在采用写入分派策略时，即使那些仅被写入的块也会保存在缓存中。让我们看一个例子。

假定一个拥有许多缓存项的全相联写回缓存，在开始时为空。下面是由5个存储器操作组成的序列（地址放在中括号内）：

1
2
3
4
5

Write Mem[100];
Write Mem[100];
Read  Mem[200];
Write Mem[200];
Write Mem[100] .

对于无写入分派策略，地址100不在缓存中，在写入时不进行分派，所以前两个写入操作将导致缺失。地址200 也不在缓存中，所以该读取操作也会导致缺失。接下来对地址200进行的写入将会命中。最后一个对地址100的写入操作仍然是缺失。所以对无写入分派策略，其结果是4次缺失和1次命中。

对于写入分派策略，前面对地址100 和地址200的访问导致缺失，由于地址100和地址200都可以在缓存中找到，所以其他写入操作将会命中。因此，采用写入分派时，其结果为2次缺失和3次命中。

任何一种写入缺失策略都可以与直写或写回策略起使用。通常，写回缓存采用写入分派策略，希望对该块的后续写入能够被缓存捕获。直写缓存通常使用无写入分派策略。其原因在于：即使存在对该块的后续写入操作，这些写入操作仍然必须进入低一级存储器，那还有什么好处呢?

举例：Opteron数据缓存

为了展示这些思想的本质，图B-3给出了AMD Opteron微处理器中数据缓存的组织方式。该缓存包含65536 （64KB）字节的数据，块大小为64字节，采用两路组相联布置方式、最近使用最少替代策略、写缺失时采用写入分派。

图B-3 Opteron 微处理器中数据缓存的组织方式。这个64 KB的缓存为两路组相联，块大小为64字节。长为9位的索引从512个组中进行选择。一次读取命中的四个步骤 （按发生顺序表示为带圆圈的数字）标记了这一组织方式。块偏移量的三位加上索引，提供了RAM地址，恰好选择8个字节。因此，该缓存保存了由4096个64位字组成的群组，每个群组包含512个组的一半。从低级存储器至缓存的线路用于在发生缺失时载入缓存，不过未在这一示例中 展示。离开处理器的地址大小为40位，这是因为它是物理地址而不是虚拟地址。图B-14解释了Opteron 如何从虚拟地址映射到物理地址，以进行缓存访问

我们通过图B-3中标注的命中步骤来跟踪一次缓存命中的过程。（这4个步骤用带圆圈的数字表示。）如B.5节所述，Opteron 向缓存提供48位虚拟地址进行标志比对，它将同时被翻译为40位物理地址。

Opteron之所以没有利用虚拟地址的所有64位，是因为它的设计者认为还没有人会需要那么大的虚拟地址空间，而较小的空间可以简化Opteron虚拟地址的映射。设计者计划在未来的微处理器中增大此虚拟地址。

进入缓存的物理地址被分为两个字段：34 位块地址和6位块偏移量（64=2^6，34+6=40）。块地址进一步分为地址标志和缓存索引。第1步显示了这一划分。

缓存索引选择要测试的标志，以查看所需块是否在此缓存中。索引大小取决于缓存大小、块大小和级相联度。Opteron 缓存的组相联度被设置为2，索引计算如下：

2^索引 = 缓存大小/(块大小x组相联度) = 65536/(64x2) = 512 = 2^9

因此，索引宽9位，标志宽34-9=25位。尽管这是选择正确块所需要的索引，但64个字节远多于处理器希望一次使用的数目。因此，将缓存存储器的数据部分安排为宽8个字节更有意义一些，这是64位Opteron处理器的自然数据字。因此，除了用于索引正确缓存块的9个位之外，还使用来自块偏移量的另外3个位来索引恰好8个字节。索引选择是图B-3中的第2步。

在从缓存中读取这两个标志之后，将它们与处理器所提供块地址的标志部分进行对比。这一对比是图中第3步。为了确保标志中包含有效信息，必须设置有效位，否则，对比结果将被忽略。假定有一个标志匹配，最后一步是通知处理器，使用2选1多工器的获胜输入从缓存中载入正确数据。Opteron可以在2个时钟周期内完成这四个步骤，因此，如果后面2个时钟周期中的指令需要使用载入结果，那就得等待。

在Opteron中，写入操作的处理要比读取操作更复杂，这一点与在任何缓存中都是一致的。如果要写入的字在缓存中，前三步相同。由于Opteron是乱序执行的，所以只有在它发出指令已提交而且缓存标志比对结果显示命中的信号之后，才会将数据写到缓存中。

到目前为止，我们假定的是缓存命中的常见情景。那在缺失时会发生什么情况呢?在读取缺失时，缓存会向处理器发出信号，告诉它数据还不可用，并从下一级层级结构中读取64个字节。对于该块的前8个字节，延迟为7个时钟周期，对于块的其余部分，为每8个字节需要2个时钟周期。由于数据缓存是组相联的，所以需要选择替换哪个块。Opteron 使用LRU （选择在最早之前被引用的块），所以每次访问都必须更新LRU位。替换一个块意味着更新数据、地址标志、有效位和LRU位。

由于Opteron使用写回策略，旧的数据块可能已经被修改，所以不能简单地放弃它。Opteron为每个块保存1个脏位，以记录该块是否被写入。如果“牺牲块”被修改，它的数据和地址就被发送给牺牲块缓冲区。（这种结构类似于其他计算机中的写入缓冲区。）Opteron有8个牺牲块的空间。它会将牺牲块写到低一级层次结构，这一操作与其他缓存操作并行执行。如果牺牲块缓冲区已满，缓存就必须等待。

由于Opteron在读取缺失和写入缺失时都会分派一个块，所以写入缺失与读取缺失非常类似。

我们已经看到数据缓存是如何工作的，但它不可能提供处理器所需要的所有存储器：处理器还需要指令。尽管可以尝试用一个缓存来提供数据、指令两种缓存，但这样可能会成为瓶颈。例如，在执行载入或存储指令时，流水化处理器将会同时请求数据字和指令字。因此，单个缓存会表现为载入与存储的结构性冒险，从而导致停顿。解决这一问题的一种简单方法是分开它：一个缓存专门用于指令，另一个缓存专门用于数据。最近的处理器中都使用了独立缓存，包括Opteron在内。因此，它有一个64 KB的指令缓存和64 KB的数据缓存。

处理器知道它是在发射一个指令 地址，还是一个数据地址，所以可能存在用于这两者的独立端口，从而使存储器层次结构和处理器之间的带宽加倍。采用分离缓存还提供了分别优化每个缓存的机会：采用不同的容量、块大小和相联度可能会得到更佳性能。

表B-3显示指令缓存的缺失率低于数据缓存。指令与数据缓存分离，消除了因为指令块和数据块冲突所导致的缺失，但这种分离固定了每种类型所能使用的缓存空间。与缺失率相比，哪个更重要呢?要公平地对比指令数据分离缓存和统一缓存， 需要总缓存大小相同。例如，分离的16 KB指令缓存和16 KB数据缓存应当与32KB统一缓存相对比。要计算分离指令与数据缓存的平均缺失率，需要知道对每种缓存的存储器引用百分比。从附录A中的数据可以找到：

指令引用为100%（100%+26%+10%），大约为74%；数据引用为（26%+ 10%）（100%+26%+10%），大约为26%。稍后将会看到，分割对性能的影响并非仅限于缺失率的变化。

缓存性能

由于指令的数目与硬件无关，所以用这个数值来评价处理器性能是很有诱惑力的。由于缺失率也与硬件的速度无关，所以评价存储器层次结构性能的相应焦点就主要集中在缺失率上。后面将会看到，缺失率可能与指令数目一样产生误导。存储器层次结构性能的一个更好度量标准是存储器平均访问时间：

存储器平均访问时间=命中时间+缺失时间x缺失代价

式中，命中时间是指在缓存中命中的时间；其他两项已经在前面看到过。平均访问时间的各个分量可以用绝对时间衡量，比如，一次命中的时间为0.25~1.0 ns，也可以用处理器等待该存储器的时间周期数来衡量，比如一次缺失代价为150~200 个时钟周期。注意，存储器平均访问时间仍然是性能的间接度量；尽管它优于缺失率，但并不能替代执行时间。

这个公式可以帮助我们决定是选择分离缓存还是统一缓存。

16KB指令缓存加上16KB数据缓存相对于一个32KB统一缓存，哪一种的缺失率较低?利用表B-3中的缺失率数据来帮助计算正确答案，假定36%的指令为数据传输指令。假定一次命中需要1个时钟周期，缺失代价为100个时钟周期。对于统一缓存，如果仅有一个缓存端口来满足两个同时请求，一次载入或存储命中另需要一个时钟周期。利用第3章的流水线技术，统一缓存会导致结构性冒险。每种情况下的存储器平均访问时间为多少?假定采用具有写入缓冲区的直写缓存，忽略由于写入缓冲区导致的停顿。

首先让我们将每千条指令的缺失数转换为缺失率。求解上面的一般公式，缺失率为：

缺失率 = ( (缺失率/1000条指令) / 1000) / (存储器访问数/指令数)

由于每次指令访问都正好有一次存储器访问来提取指令，所以指令缺失率为：

缺失率(16 KB指令) = 3.82 / 1000 = 0.004

由于36%的指令为数据传输，所以数据缺失率为：

缺失率(16 KB数据) = 40.9 / 1000 / 0.36 = 0.114

统一缺失率需要考虑指令和数据访问：

缺失率(32 KB统一) = 43.3 / 1000 / (1.00 +0.36) = 0.0318

如上所述，大约74%的存储器访问为指令引用。因此，分离缓存的总缺失率为：

(74% x 0.004)+(26% x 0.114) = 0.0326

因此，32KB 统一缓存的实际缺失率略低于两个16 KB缓存。

存储器平均访问时间公式可分为指令访问和数据访问：

存储器平均访问时间 = 指令百分比 x (命中时间+指令缺失率x缺失代价) + 数据百分比 x (命中时间+数据缺失率x缺失代价)

因此，每种组织方式的时间为：

存储器平均访问时间(分离) = 74% x (1 + 0.004 x 200) + 26% x (1 + 0.114 x 200) = (74% x 1.80)+(26% x 23.80) = 7.52

存储器平均访问时间(统一) = 74% x (1 + 0.0318 x 200) + 26% x (1 + 1 + 0.0318 x 200) = 7.62

因此，在这个示例中，尽管分离缓存（每时钟周期提供两个存储器端口，从而避免了结构性冒险)的实际缺失率较差，但其存储器平均访问时间要优于单端口统一缓存。

存储器平均访问时间与处理器性能

一个显而易见的问题是：因缓存缺失导致的存储器平均访问时间能否预测处理器性能。

首先，还有其他原因会导致停顿，比如使用存储器的I/O 设备产生争用。由于存储器层次结构导致的停顿远多于其他原因导致的停顿，所以设计人员经常假定所有存储器停顿都是由于缓存缺失导致的。我们这里也采用这一简化假定，但在计算最终性能时，一定要考虑所有存储器停顿。

第二，上述问题的回答也受处理器的影响。采用循序执行处理器，那回答基本上就是肯定的。处理器会在缺失期间停顿，存储器停顿时间与存储器平均访问时间存在很强的相关性。现在假定采用循序执行，但下一小节会返回来讨论乱序处理器。

如上一节所述，可以为CPU时间建立如下模型：

CPU时间 = (CPU执行时钟周期+存储器停顿时钟周期) x 时钟周期时间

这个公式会产生一个问题：一次缓存命中的时钟周期应看作CPU执行时钟周期的一部分，还是存储器停顿时钟周期的一部分?尽管每一种约定都有自己的正当理由，但最为人们广泛接受的是将命中时钟周期包含在CPU执行时钟周期中。

我们现在可以研究缓存对性能的影响了。

让我们对第一个示例使用循序执行计算机。假定缓存缺失代价为200个时钟周期，所有指令通常都占用1.0个时钟周期（忽略存储器停顿）。假定平均缺失率为2%，每条指令平均有1.5 次存储器引用，每千条指令的平均缓存缺失数为30。如果考虑缓存的行为特性，对性能的影响如何?使用每条指令的缺失数及缺失率来计算此影响。

CPU时间=ICx( CPI执行 + 存储器停顿时钟周期/指令数)x时钟周期时间

其性能（包括缓存缺失）为：

CPU时间包括缓存= IC x [1.0+(30/1000 X 200)] x周期时钟时间 = ICx7.00x时钟周期时间

现在使用缺失率计算性能：

CPU时间 = IC x (CPU执行+缺失率x存储器访问/指令x缺失代价)x时钟周期时间

CPU时间(包括缓存) = IC x [1.0x (1.5 x 2% X 200)] x 时钟周期时间 = ICx7.00x时钟周期时间

在有、无缓存情况下，时钟周期时间和指令数均相同。因此，CPU时间提高至7倍，CPI 从“完美缓存”的1.00增加到可能产生缺失的缓存的7.00。在根本没有任何存储器层次结构时，CPU 将再次升高到1.0+200x1.5=301，比带有缓存的系统长出40多倍。

如上例所示，缓存特性可能会对性能产生巨大影响。此外，对于低CPI、高时钟频率的处理器，缓存缺失会产生双重影响。

1. CPI(执行)越低，固定数目的缓存缺失时钟周期产生的相对影响越高。
2. 在计算CPI时，一次缺失的缓存缺失代价是以处理器时钟周期进行计算的。因此，即使两个计算机的存储器层次结构相同，时钟频率较高的处理器在每次缺失时会占用较多的时钟周期，CPI的存储器部分也相应较高。

对于低CPI、高时钟频率的处理器，缓存的重要性更高，因此，如果在评估此类计算机的性能时忽略缓存行为，其危险性更大。Amdahl 定律再次发挥威力!

尽管将存储器平均访问时间降至最低是一个合理的目标(在本附录中大多使用这一目标），但请记住，最终目标是缩短处理器执行时间。下面的例子说明如何区分这两者。

两种不同缓存组织方式对处理器性能的影响如何?假定完美缓存的CPI为1.6，时钟周期时间为0.35 ns，每条指令有1.4 次存储器引用，两个缓存的大小都是128 KB，两者的块大小都是64字节。一个缓存为直接映射，另一个为两路组相联。图B-3显示，对于组相联缓存，必须添加一个多工器，以根据标志匹配在组中的块之间作出选择。由于处理器的速度直接与缓存命中的速度联系在一起，所以假定必须将处理器时钟周期时间扩展1.35 倍，才能与组相联缓存的选择多工器相适应。对于一级近似，每一种缓存组织方式的缓存缺失代价都是65纳秒。

首先，计算存储器平均访问时间，然后再计算处理器性能。假定命中时间为1 个时钟周期，128 KB直接映射缓存的缺失率为2.1%，同等大小的两路组相联缓存的缺失率为1.9%。

存储器平均访问时间为：

存储器平均访问时间=命中时间+缺失率x缺失代价

因此，每种组织方式的时间为：

存储器平均访问时间(一路) = 0.35+(0021 x 65)=1.72ns

存储器平均访问时间(两路) = 0.35 x 1.35+(0019 X 65)=1.71ns

这一存储器平均访问时间优于两路组相联缓存。

处理器性能为：

CPU时间= IC x ( CPI(执行) + 缺失数/指令数 x 缺失代价) x 时钟周期时间 = IC x [(CPI(执行) x 时钟周期时间) + (缺失率x(存储器访问次数/指令数)x缺失代价x时钟周期时间)]

将(缺失代价x时钟周期时间)代以65ns，可得每种缓存组织方式的性能为：

CPU时间(一路)= ICx [1.6 x 0.35 + (0.021x1.4x65)] = 2.47 x IC
CPU时间(两路)= ICx [1.6 x 0.35 x 1.35 + (0.019x1.4x65)] = 2.49 x IC

相对性能为：

CPU时间(两路)/CPU时间(一路) = (2.49x指令数)/(2.47x指令数) = 1.01

与存储器平均访问时间的对比结果相反，直接映射缓存的平均性能略好一些，这是因为尽管两组组相联的缺失数较少，但针对所有指令扩展了时钟周期。由于CPU时间是我们的基本评估，而且由于直接映射的构建更简单一些，所以本示例中的优选缓存为直接映射。

缺失代价与乱序执行处理器

对于乱序执行处理器，如何定义“缺失代价”呢?是存储器缺失的全部延迟，还是仅考虑处理器必须停顿时的“暴露”延迟或无重叠延迟?对于那些在完成数据缺失之前必须停顿的处理器，不存在这一问题。

让我们重新定义存储器停顿，得到缺失代价的一种新定义，将其表示为非重叠延迟：

存储器停顿周期/缺失数 = 缺失数/指令数 x (总缺失代价-直叠缺失延迟)

与此类似，由于一些乱序处理器会拉长命中时间，所以性能公式的这一部分可以除以总命中延迟减去重叠命中延迟之差。可以对这一公式进一 步扩 展，将总缺失延迟分解为没有争用时的延迟和因为争用导致的延迟，以考虑乱序处理器中的存储器资源。我们仅关注缺失延迟。我们现在必须决定以下各项。

• 存储器延迟长度——在乱序处理器中如何确定存储器操作的起止时刻。
• 延迟重叠的长度——如何确定与处理器相重叠的起始时刻（或者说，在什么时刻我们说存储器操作使处理器停顿）。

由于乱序执行处理器的复杂性，所以不存在单一的准确定义。

由于在流水线退出阶段只能看到已提交的操作，所以我们说：如果处理器在一个时钟周期内没有退出（retire）最大可能数目的指令，它就在该时钟周期内停顿。我们将这一停顿记在第一条未退出指令的账上。这一定义绝不像看上去那么简单。例如，为缩短特定停顿时间而应用某一种优化，并不一定总能缩短执行时间，这是因为此时可能会暴露出另一种类型的停顿（原本隐藏在所关注的停顿背后）。

关于延迟，我们可以从存储器指令在指令窗口中排队的时刻开始测量，也可以从生成地址的时刻开始，还可以从指令被实际发送给存储器系统的时刻开始。只要保持一致，任何一种选项都是可以的。

让我们重做上面的例题，但这一次假定具有较长时钟周期时间的处理器支持乱序技术，但仍采用直接映射缓存。假定65 ns的缺失代价中有30%可以重叠，也就是说，CPU存储器平均停顿时间现在为45.5 ns。

乱序计算机的存储器访问时间为：

存储器平均访问时间(一路、乱序) = 0.35 x 1.35 + (0.021 x45.5)= 1.43 ns .

乱序缓存的性能为：

CPU时间(一路、乱序) = IC x [1.6 x 0.35 x 1.35 + (0.021 x 1.4 x 45.5)] = 2.09 x IC

因此，尽管乱序计算机的时钟周期时间要慢得多，直接映射缓存的缺失率也更高一些，但如果它能隐藏30%的缺失代价，那仍然可以稍快一些。

总而言之，尽管乱序处理器存储器停顿的定义和测量比较复杂，但由于它们会严重影响性能，所以应当了解这些问题。这一复杂性的出现是因为乱序处理器容忍由缓存缺失导致一定的延迟，不会对性能造成伤害。因此，设计师在评估存储器层次结构的权衡时，通常使用乱序处理器与存储器的模拟器，以确保一项帮 助缩短平均存储器延迟的改进能够真的有助于提高程序性能。为了帮助总结本节内容，同时也作为一个方便使用的参考，图B-4列出了本附录中的缓存公式。

图B-4 本附录中的性能公式汇总。第一个公式计算缓存索引大小，其余公式帮助评估性能。后两个公式处理多级缓存

6种基本的缓存优化

存储器平均访问时间公式为我们提供了一个框架，用于展示提高缓存性能的缓存优化方法：

存储器平均访问时间=命中时间+缺失率x缺失代价

因此，我们将6种缓存优化分为以下3类。

• 降低缺失率——较大的块、较大的缓存、较高的关联度。
• 降低缺失代价——多级缓存，为读取操作设定高于写入操作的优先级。
• 缩短在缓存中命中的时间——在索引缓存时避免地址转换。

改进缓存特性的经典方法是降低缺失率，我们给出3种实现技术。为了更好地理解导致缺失的原因，首先介绍一个模型，将所有缺失分为3个简单类别。

• 强制缺失（Compulsory）——在第一次访问某个块时，它不可能会在缓存中，所以必须将其读到缓存中。这种缺失也被称为冷启动缺失或首次引用缺失。
• 容量缺失（Capacity）——如果缓存无法容纳程序执行期间所需要的全部块，由于一些块会被放弃，过后再另行提取，所以会（在强制缺失之外）发生容量缺失。
• 冲突缺失（Conflict）——如果块布置策略为组相联或直接映射，则会（在强制缺失和容量缺失之外）发生冲突缺失，这是因为如果有太多块被映射到一个组中，这个组中的某个块可能会被放弃，过后再另行提取。这种缺失也被称为碰撞缺失。其要点就是：由于对某些常用组的请求数超过n，所以本来在全相联缓存中命中的情景会在n路组相联缓存中变为缺失。

表B-4显示了根据3C分类后的缓存缺失相对频率。强制缺失在无限缓存中发生，容量缺失在全相联缓存中发生。冲突缺失在从全相联变为八路相联、四路相联…时发生。图B-5以图形方式展示相同数据。上图显示绝对缺失率，下图绘制了当缓存大小变化时，各类缺失占总缺失数的百分比曲线。

• 强制缺失与缓存大小无关，而容量缺失随容量的增加而降低，冲突缺失随相联度的增大而降低。

图B-5以围形方式显示了相同数据。注意，在不超过128KB时，大小为N的直接映射缓存的缺失率大约与大小为N/2的两路组相联缓存的缺失率相同。大于128KB的缓存不符合这一规则。注意，“容量” 列给出的也是全相联缺失率。

图B-5 根据表B-4中的3C数据，每种不同缓存大小的总缺失率（上）和缺失率分布（下）。上图显示实际数据缓存缺失率，下图显示每个类别的百分比

为了展示相联度的好处，将冲突缺失划分为每次相联度下降时所导致的缺失。共有4类冲突缺失，其计算方式如下所示。

• 八路——从全相联（无冲突）到八路相联时产生的冲突缺失。
• 四路——从八路相联到四路相联时产生 的冲突缺失。
• 两路——从四路相联到两路相联时产生的冲突缺失。
• 一路——从两路相联到一路相联（直接映射）时产生的冲突缺失。

从图中可以看出，SPEC2000程序的强制缺失率非常低，对许多长时间运行的程序都是如此。

从概念上来讲，冲突缺失是最容易避免的：全相联布置策略就可以避免所有冲突缺失。但是，全相联的硬件实现成本非常高昂，可能会降低处理器时间频率，从而降低整体性能。除了增大缓存之外，针对容量缺失没有什么办法了。如果上一级存储器远小于程序所需要的容量，那就会有相当一部分时间用于在层次结构的两级之间移动数据，我们说这种存储器层次结构将会摆动。由于需要太多的替换操作，所以摆动意味着计算机的运行速度接近于低级存储器的速度，甚至会因为缺失开销变得更慢。

另外一种降低3C缺失的方法是增大块的大小，以降低强制缺失数，但稍后将会看到，大型块可能会增加其他类型的缺失。

3C分类使我们可以更深入地了解导致缺失的原因，但这个简单的模型也有它的局限性；它让我们深入地了解了平均性能，但不能解释个体缺失。例如，由于较大的缓存可以将引用扩展到更多个块中，所以改变缓存大小会改变冲突缺失和容量缺失。因此，当缓存大小变化时，一个缺失可能会由容量缺失变为冲突缺失。注意，3C分类还忽略了替换策略，一方面是因为其难以建模，另一方面是因为它总体来说不太重要。但在具体环境中，替换策略可能会实际导致异常行为，比如，在大相联度下得到较低的缺失率，这与3C模型的结果矛盾。

遗憾的是，许多降低缺失率的技术也会增加命中时间或缺失代价。在使用3种优化方法降低缺失率时，必须综合考虑提高整体系统速度的目标，使两者达到平衡。第一个例子显示了平衡观点的重要性。

第一种优化方法：增大块大小以降低缺失率

降低缺失率的最简单方法是增大块大小。图B-6针对一组程序及缓存大小，给出了块大小；与缺失率的折中。较大的块大小也会降低强制缺失。这一降低是因为局域性原理分为两个部分：时间局域性和空间局域性。较大的块充分利用了空间局域性的优势。

图B-6 对于5种不同大小的缓存，缺失率与块大小的相互关系。注意，如果与缓存大小相比，块大小过大，则缺失率实际上会上升。每条曲线表示一个不同大小的缓存。

同时，较大的块也会增加缺失代价。由于它们降低了缓存中的块数，所以较大块可能会增大冲突缺失，如果缓存很小，甚至还会增加容量缺失。显然，没有理由要将块大小增大到会升高缺失率的程度。如果它会增加存储器平均访问时间，那降低缺失率也没有什么好处。缺失代价的增加会超过缺失率的下降。

• 注意，对于4KB缓存，块大小为256字节时的缺失率高于32字节。在本例中，缓存大小必须为256KB，以使块大小为256字节时能够降低缺失。

表B-5显示了图B-6中绘制的实际缺失率。假定存储器系统的开销为80个时钟周期，然后每2个时钟周期提交16 个字节。因此，它可以在82个时钟周期内提供16个字节，在84个时钟周期内提供32个字节，以此类推。对于表B-5中的每种缓存大小，哪种缓存大小的存储器平均时间最短?

如果我们假定命中时间为1个时钟周期，与块大小无关，那么在4KB缓存中，对16字节块的访问时间为：

存储器平均访问时间 = 1+(8.57% x 82) = 8.027时钟周期

在256 KB缓存中，对256字节块的存储器平均访问时间为：

存储器平均访问时间 = 1+(0.49% x 112) = 1.549时钟周期

表B-6显示了这两个极端值之间所有块与缓存大小的存储器平均访问时间。粗体项目表示对于给定缓存大小能够实现最快访问的块大小：若缓存大小为4KB，则块大小为32字节时的访问速度最快;若缓存大小大于4 KB，则块大小应为64字节。事实上，这些数值也正是当前处理器缓存的常见块大小。

• 注意，绝大多数的块大小为32字节和64字节。每种缓存大小的最短平均访问时间用黑体标出。

在所有这些技术中，缓存设计者都在尝试尽可能同时降低缺失率和缺失代价。块大小的选择有赖于低级存储器的延迟和带宽。高延迟和高带宽鼓励采用大块，因为缓存在每次缺失射能够获取的字节可以多出许多，而缺失代价却很少增加。相反，低延迟和低带宽则鼓励采用小块，因为这种情况下采用较大块不会节省多少时间。例如，一个小块的两倍缺失代价可能接近一个两倍大小块的缺失代价。更多的小块还可能减少冲突缺失。注意，图B-6和表B-6给出了基于缺失率最低、存储器平均时间最短选择块大小时的差别。

在了解了较大块对强制缺失和容量缺失的正面与负面影响之后，下面两小节将研究较高容量和较高相联度的可能性。

第二种优化方法：增大缓存以降低缺失率

降低表B-4和图B-5中容量缺失的最明显方法是增加缓存的容量，其明显的缺点是可能延长命中时间、增加成本和功耗。这一技术在片外缓存中尤其常用。

第三种优化方法：提高相联度以降低缺失率

表B-4和图B-5显示了缺失率是如何随着相联度的增大而得以改善的。从中可以看出两个一般性的经验规律。第一条规律是：对于这些特定大小的缓存，从实际降低缺失数的功效来说，八路组相联与全相联是一样有效的。通过对比表B-4中的八路项目与容量缺失列可以看出这差别，其中的容量缺失是使用全相联缓存计算得出的。

从图中观察得到的第二条规则称为2：1缓存经验规律：大小为N的直接映射缓存与大小为N/2的两路组相联缓存具有大体相同的缺失率。这一规律对3C图形中小于128KB的缓存也是成立的。

与许多此类示例类似，要改善存储器平均访问时间的一个方面，可能会导致另一方面的恶化。增大块大小可以降低缺失率，但会提高缺失代价；增大相联度可能会延长命中时间。因此，加快处理器时钟速度的压力鼓励使用简单的缓存设计，但提高相联度的回报是提高缺失代价，如下例所示。

假定提高相联度将会延长时钟周期时间，如下所示：

• 时钟周期时间(两路) = 1.36 x 时钟周期时间(一路)
• 时钟周期时间(四路) = 1.44 x 时钟周期时间(一路)
• 时钟周期时间(八路) = 1.52 x 时钟周期时间(一路)

假定命中时间为1个时钟周期，直接映射情景的缺失代价为到达第2级缓存的25个时钟周期，在第2级缓存中绝对不会缺失，还假定不需要将缺失代价舍入为整数个时钟周期。

每种相联度的存储器平均访问时间为：

存储器平均访问时间(八路) = 命中时间(八路) + 缺失率路x缺失代价(八路) = 1.52+缺失率(八路)x25

• 存储器平均访问时间(四路) = 1.44+缺失率(四路) x 25
• 存储器平均访问时间(两路) = 1.36+缺失率(两路) x 25
• 存储器平均访问时间(一路) = 1.00+缺失率(一路) x 25

每种情况下的缺失代价相同，所以我们使其保持25个时钟周期。例如，对于一个4 KB的直接映射缓存，存储器平均访问时间为：

存储器平均访问时间(一路) = 1.00+ (0.098 x 25) = 3.44

对于512 KB八路组相联缓存，该时间为：

存储器平均访问时间(八路) = 1.52+(0.006x25) = 1.66

利用这些公式及表B-4中的缺失率，表B-7给出了每种缓存和相联度时的存储器平均访问时间。该表显示，对于不大于8KB、不超过四路相联度的缓存，本例中的公式成立。从16 KB开始，较大相联度的较长命中时间超过了因为缺失降低所节省的时间。

注意，在本例中，我们没有考虑较慢时钟频率对程序其余部分的影响，因此低估了直接映射缓存的收益。

第四种优化方法：采用多级缓存降低缺失代价

降低缓存缺失已经成为缓存研究的传统焦点，但缓存性能公式告诉我们：通过降低缺失代价同样可以获得降低缺失率所带来的好处。此外，图2-2显示的技术趋势表明：处理器的速度增长快于DRAM，从而使缺失代价的相对成本随时间的推移而升高。处理器与存储器之间的性能差距让架构师开始思考这样一个问题：是应当加快缓存速度以与处理器速度相匹配呢?还是让缓存更大一些，以避免加宽处理器与主存储器之间的鸿沟?

一个回答是：两者都要。在原缓存与存储器之间再添加一级缓存可以简化这一决定。第一级缓存可以小到足以与快速处理器的时钟周期时间相匹配。而第二级缓存则大到足以捕获本来可能进入主存储器的访问，从而降低实际缺失代价。尽管再添加一级层次结构的思路非常简单，但它增加了性能分析的复杂程度。第二级缓存的定义也并非总是那么简单。首先让我们为一个二级缓存定义存储器平均访问时间。用下标L1和L2分别指代第一级、 第二级缓存，原公式为：

存储器平均访问时间=命中时间L1 + 缺失率L1 x 缺失代价L1

及

缺失代价L1=命中时间L2 + 缺失率L2 x 缺失代价L2

得

存储器平均访问时间=命中时间L1 + 缺失率L1 x (命中时间L2 + 缺失率L2 x 缺失代价12)

在这个公式中，第二级缺失率是针对第-级缓存未能找到的内容进行测量的。为了避免模糊，对二级缓存系统采用以下术语。

• 局部缺失率——此比值即是缓存中的缺失数除以对该缓存进行存储器访问的总数。可以想到，对于第一级缓存， 它等于缺失率L1，对于第二级缓存，它等于缺失率L2
• 全局缺失率——缓存中的缺失数除以处理器生成的存储器访问总数。利用以上术语，第一级缓存的全局缺失率仍然为缺失率L1，但对于第二级缓存则为缺失率L1x缺失率L2

第二级缓存的这一局部缺失率很大，这是因为第一级缓存已经提前解决了存储器访问中便于实现的部分。这就是为什么说全局缺失率是一个更有用的度量标准：它指出在处理器发出的存储器访问中，有多大比例指向了存储器。

这是一个让每条指令缺失数度量闪光的地方。利用这一度量标准，不用再担心局部缺失率或全局缺失率的混淆问题，只需要扩展每条指令的存储器停顿，以增加第二级缓存的影响。

每条指令的平均存储器停顿时间=每条指令的缺失数L1x命中时间L2 + 每条指令的缺失数L2x缺失代价L2

假定在1000次存储器引用中，第一级缓存中有40次缺失，第二级缓存中有20次缺失。各缺失率等于多少?假定L2缓存到存储器的缺失代价为200个时钟周期，L2缓存的命中时间为10个时钟周期，L1 的命中时间为1个时钟周期，每条指令共有1.5次存储器引用。每条指令的存储器平均访问时间和平均停顿周期为多少?

第一级缓存的缺失率（局部缺失率或全局缺失率）为40/1000=4%。第二级缓存的局部缺失率为20/40=50%。第二级缓存的全局缺失率为20/1000=2%。则：

存储器平均访问时间=命中时间L1+缺失率L1 x (命中时间L2+缺失率L2x缺失代价L2) = 1+4% x (10+50% x 200) = 5.4个时钟周期

为了知道每条指令会有多少次缺失，我们将1000次存储器引用除以每条指令的1.5次存储器引用，得到667条指令。因此，我们需要将缺失数乘以1.5，得到每千条指令的缺失数。于是得到每千条指令的L1缺失数为40x 1.5=60次，L2缺失数为20x1.5= 30次。关于每条指令的平均存储器停顿，假定缺失数在指令与数据之间是均匀分布的：

每条指令的平均存储器停顿=每条缺失的缺失数L1 x 命中时间L2 + 每条指令的缺失数L2 x 缺失代价L2 = (60/1000) x 10 + (30/1000) x 200 = 0.060 x 10 + 0.030 x 200 = 6.6个时钟周期

如果从存储器平均访问时间（AMAT）中减去L1命中时间，然后再乘以每条指令的平均存储器引用数，则可以得到每条指令平均存储器停顿值：(5.4- 1.0) x 1.5 = 4.4 x 1.5 - 6.6个时钟周期

注意，这些公式是针对混合式读取与写入操作的，假定采用写回第一级缓存。显然，直写第一级缓存会将所有写入操作都发往第二二级，而不是仅限于缺失，而且还可能使用写入缓冲区。

图B-7和图B-8显示了一个设计中的缺失率和相对执行时间是如何随着第一二级缓存的大小而变化的。从两个图中可以有两点体悟。第一，如果第二级缓存远大于第一级缓存，则全局缓存缺失率与第二级缓存的单一缓存缺失率非常类似。第二，局部缓存缺失率不是第二级缓存的良好度量标准；它是第一级缓存缺失率的函数，因此可以通过改变第一级缓存而变化。所以，在评估第一级缓存时，应当使用全局缓存缺失率。

图B-7 多级缓存的缺失率随缓存大小的变化。小于两个64 KB一级缓存总和的第二级缓存没有什么意义，从其高缺失率中可以反映出这一点。大于256 KB之后，单个缓存在全局缺失率在10%以内。单级缓存的缺失率随大小的变化是根据第二级缓存的局部缺失率和全局缺失率绘制的，采用的是32 KB一级缓存。L2缓存（统一缓存）为两路组相联，采用替换策略。分别有独立的L2指令与数据缓存，它们都是64 KB两路组相联，采用LRU替换策略。L1与L2缓存的块大小均为64字节。

图B-8 相对执行时间与第二级缓存大小的关系。图中的每两个长条表示一次L2缓存命中的不同时钟周期。引用执行时间1.00 是指一个8192 KB第二级缓存在第二级命中的延迟为1个时钟周期。

有了这些定义，我们可以考虑第二级缓存的参数。两级缓存之间的首要区别就是第一级缓存的速度影响着处理器的时钟频率，而第二级缓存的速度仅影响第一级缓存的缺失代价。因此，我们可以在第二级缓存中考虑许多不能用于第一级缓存的替代选项。在设计第二级缓存时，主要有两个问题：是否要降低CPI的存储器平均访问时间部分?其成本有多高?

首先要决定的是第二级缓存的大小。由于第一级缓存中的所有内容都可能在第二级缓存中，所以第二级缓存应当远大于第一级缓存。如果第二级缓存只是稍大一点，那局部缺失率将会很高。这一观察结果激励了巨型第二级缓存的设计。

给定以下数据，第二级缓存相联度对其缺失代价的影响如何?

• 直接映射的命中时间L2为10个时钟周期。
• 两路组相联将命中时间增加0.1个时钟周期，达到10.1个时钟周期。
• 直接映射的局部缺失率L2为25%。
• 缺失代价I2为200个时钟周期。
• 两路组相联直接映射的局部缺失率L2为20%。

对于直接映射第二级缓存，第一级缓存缺失代价为：
缺失代价(一路L2) = 10 + 25% x 200 = 60.0个时钟周期

加上相联度的成本仅使命中成本增加0.1个时钟周期，由此得到新的第一级缓存缺失代价为：

缺失代价(两路L2) = 10.1 + 20% x 200 = 50.1个时钟周期

事实上，第二级缓存几乎总是与第一级缓存、处理器同步。相应地，第二级命中时间必须为整数个时钟周期。如果幸运的话，我们可以将第二级命中时间缩短到10个时钟周期；如果不够幸运，则会舍入到11个周期。相对于直接映射第二级缓存，任一选项都是一种改进：

• 缺失代价两路L2 = 10+20% x 200 = 50.0个时钟周期
• 缺失代价两路12 = 11+20% x 200 = 51.0个时钟周期

现在我们可以通过降低第二级缓存的缺失率来降低缺失代价了。

另一条关注事项涉及第一级缓存中的数据是否在第二级缓存中。多级包含是存储器层次结构的一种自然策略：L1 数据总是出现在L2中。这种包含性是我们所希望的，因为仅通过检查第二级缓存就能确定IO与缓存之间（或多处理器中的缓存之间）的一致性。

包含性的一个缺点就是：测量结果可能提议对较小的第一级缓存使用较小的块，对较大的第二级缓存使用较大的块。例如，Pentium 4的L1缓存中的块为64个字节，L2缓存中的块为128个字节。包含性仍然能够得到保持，但在第二级缺失时要做更多工作。如果一级块所映射的二级块将被替换，则第二级缓存必须使所有此类一级块失效，从而会略微提高第一级缺失率。为了避免此类问题，许多缓存设计师使所有各级缓存的块大小保持一致。

但是，如果设计师只能承受略大于L1缓存的L2缓存呢?它是不是有很大一部分空间要被用作L1缓存的冗余副本?在此种情况下，可以使用一种明显相反的策略：多级互斥，L1中的数据绝对不会出现在L2缓存中。典型情况下，在采用互斥策略时，L1中的缓存缺失将会导致L1与L2的块交换，而不是用L2块来替代L1块。这一策略防止了L2缓存中的空间浪费。例如，AMD Opteron芯片使用两个64 KB L1缓存和1 MB L1缓存来执行互斥策略。

这些问题表明，尽管一些新手可能会独立地设计第一级和第二级缓存，但在给定一个兼容第二级缓存时，第一级缓存设计师的任务要简单一些。比如，如果下一级有写回缓存来为重复写入操作提供支持，而且使用了多级包含，那使用直写的风险就会小一些。所有缓存设计的基础都是在加速命中和减少缺失之间实现平衡。对于第二级缓存，命中数要比第一级缓存中少得多，所以重心更多地偏向减少缺失。因为这一认知，人们开始采用大得多的缓存和降低缺失率的技术，比如更高的相联度和更大的块。

第五种优化方法：使读取缺失的优先级高于写入缺失，以降低缺失代价

这一优化方法在完成写入操作之前就可以为读取操作提供服务。我们首先看一下写入缓冲区的复杂性。

采用直写缓存时，最重要的改进就是一个大小合适的写入缓冲区。但是，由于写入缓冲区可能包含读取缺失时所需要的更新值，所以它们的确会使存储器访问变得复杂。

看以下序列：

1
2
3

SW R3, 512(R0)   ;M[512] ← R     (cache index 0)
LW R1, 1024(R0)  ;R1 ← M[1024]   (cache index 0)
LW R2, 512(R0)   ;R2 ← M[512]    (cache index 0)

使用第2章的术语，这是存储器中的一个“写后读”数据冒险。我们通过跟踪一次缓存访问来了解这种危险性。R3的数据在存储之后被放在写入缓冲区中。随后的载入操作使用相同的缓存索引，因此产生一次缺失。第二条载入指令尝试将位置512处的值放到寄存器R2 中，这样也会导致一次缺失。如果写入缓冲区还没有完成向存储器中位置512的写入，对位置512的读取就会将错误的旧值放到缓存块中，然后再放入R2中。如果没有事先防范，R3是不等于R2的!

摆脱这一两难境地的最简单方法是让读取缺失一直等待到写入缓冲区为空为止。一种替代方法是在发生读取缺失时检查写入缓冲区的内容，如果没有冲突而且存储器系统可用，则让读取缺失继续。几乎所有桌面与服务器处理器都使用后一方法，使读取操作的优先级高于写入操作。

处理器在写回缓存中的写入成本也可以降低。假定一次读取缺失将替换一个脏服务器块。我们不是将这个脏块写到存储器中，然后再读取存储器，而是将这个脏块复制到缓冲区中，然后读存储器，然后再写存储器。这样，处理器的读取操作将会很快结束（处理器可能正在等待这一操作的完成）。和前一种情况类似，如果发生了读取缺失，处理器或者停顿到缓冲区为空，或者检查缓冲区中各个字的地址，以了解是否存在冲突。

命中时间会影响到处理器的时钟频率，所以它是至关重要的；在今天的许多处理器中，缓存访问时间限制都限制了时钟频率，即使那些使用多个时钟周期来访问缓存的处理器也是如此。因此，缩短命中时间可以对各个方面提供帮助，从而具有多重重要性，超出了存储器平均访问时间公式的限制。

第六种优化方法：避免在索引缓存期间进行地址转换，以缩短命中时间

即使一个小而简单的缓存也必须能够将来自处理器的虚拟地址转换为用以访问存储器的物理地址。如B.4节所述，处理器就是将主存储器看作另一级存储器层次结构，因此，必须将存在于磁盘上的虚拟存储器地址映射到主存储器。

根据“加快常见情景速度”这一指导原则，我们为缓存使用虚拟地址，因为命中的出现频率当然远高于缺失。这种缓存被称为虚拟缓存，而物理缓存用于表示使用物理地址的传统缓存。问题是：在索引缓存中应当使用虚拟地址还是使用物理地址，在标志对比中应当使用虚拟地址还是使用物理地址。如果对索引和标志都完全采用虚拟寻址，那在缓存命中时就可以省掉地址转换的时间。

那为什么不是所有体系结构都构建虚拟寻址的缓存呢?一个原因是要提供保护。在将虚拟地址转换为物理地址时，无论如何都必须检查页级保护。一种解决方案是在缺失时从TLB复制保护信息，添加一个字段来保存这一信息，然后在每次访问虚拟寻址缓存时进行核对。另一个原因是：在每次切换进程时，虚拟地址会指向不同的物理地址，需要对缓存进行刷新。图B-9显示了这一刷新对缺失率的影响。一种解决方案是增大缓存地址标志的宽度，增加一个进程识别符标志（PID）。如果操作系统将这些标志指定给进程，那么只需要在PID被回收时才刷新缓存；也就是说，PID 可以区分缓存中的数据是不是为此这个程序准备的。图B-9显示了通过PID避免缓存刷新而对缺失率的改善。

图B-9 一个程序的缺失率随虚拟寻址缓存大小的变化，分三种情况测量：没有进程切换（单进程）、使用进程识别符标志（PID）进行进程切换，有进程切换但没有PID，即清除（purge） 模式。PID使单进程绝对缺失率增加0.3%~0.6%，比清除模式节省0.6%~4.3%。

虚拟缓存没有更加普及的第三个原因是操作系统和用户程序可能为同一物理地址使用两种不同的虚拟地址。这些重复地址称为同义地址或别名地址，可能会在虚拟缓存中生成同一数据的两个副本；如果其中一个被修改了，另一个就会包含错误值。而采用物理缓存是不可能发生的，因为这些访问将会首先被转换为相同的物理缓存块。

同义地址问题的硬件解决方案称为别名消去，保证每个缓存块都拥有一个独一无二的物理地址。软件可以强制这些别名共享某些地址位，从而大大简化了这一问题。 比如Sun要求所有别名地址的后面18位都必须相同；这一限制称为页面着色。注意，页面着色就是向虚拟存储器应用的组相联映射：使用64（2%）个组来映射4 KB（212）个页面，确保物理地址和虚拟地址的后18位匹配。这一限制意味着不大于 218 （256 K）字节直接映射缓存绝对不会为块使用重复的物理地址。从缓存的角度来看，页着色有效地增大了页偏移，因为软件保证了虚拟、物理页地址的最后几位是相同的。

最后一部分与虚拟地址相关的领域是I/O。I/O 通常使用物理地址，从而需要映射到虚拟地址，以与虚拟地址进行交换。一种使虚拟缓存与物理缓存均能实现最佳性能的备选方法是使用一部分页偏移量（也就是虚拟地址与物理地址保持一致的那一部分）来索引缓存。在使用索引读取缓存的同时，地址的虚拟部分被转换，标志匹配使用了物理地址。

这一备选方法允许缓存读取操作立即开始，而标志对比仍然使用物理地址。这种虚拟索引、物理标志备选方法的局限性是直接映射缓存不能大于页大小。为了利用这一技巧，虚拟页大小至少为2（9+6）个字节，即32 KB。如果不是这样，则必须将该索引的一部分由虚拟地址转换为物理地址。图B-10显示了在使用这一技术时的缓存、转换旁视缓冲区（TLB）和虚拟存储器的组织方式。

图B-10 一种从虛拟地址到L2缓存访问的虚设存储器层次结构的整体图像。页大小为16 KB。TLB是拥有256项的两路组相联。L1 缓存是一个直接映射16 KB，L2缓存是一个总容量为4 MB的四路组相联。这两者的块大小都是64个字节。虚拟地址为64位，物理地址为40位

相联度可以将此索引保存在地址的物理部分，但仍支持大型缓存。回想一下，索引的大小受以下公式的控制：

2^索引 = 缓存大小/(块大小x组相联)

例如，使相联度和缓存大小同时加倍并不会改变索引的大小。作为一个极端示例，IBM 3033缓存是一个十六路组相联，尽管研究表明：在八路以上的组相联中，对缺失率没有什么好处。尽管IBM体系结构中存在页大小为4KB这一障碍，这一高相联度允许使用物理索引对64 KB缓存进行寻址。

基本缓存优化方法小结

本节介绍了用于降低缺失率与缺失代价、缩短命中时间的技术，这些技术通常会影响到存储器平均访向公式的其他部分，还会影响到存储器层次结构的复杂性。表B-8总结了这些技术，并估计了对复杂性的影响，“+”表示该技术对该因素有改进，“-” 表示该技术对该因素有伤害，空白表示没有影响。本图中任何一项优化方法都不能对一个以上的类别提供帮助。

虛拟存储器

必须有一种方法，用于在许多进程之间共享较少量的物理空间。

其中一种做法——虚拟存储器，将物理存储器划分为块，并分配给不同的进程。这种方法必然要求采用一种保护机制来限制各个进程，使其仅能访问属于自己的块。虚拟存储器的许多形式还缩短了程序的启动时间，因为程序启动之前不再需要物理存储器中的所有代码和数据。尽管由虚拟存储器提供的保护对于目前的计算机来说是必需的，但共享并不是发明虚拟内存的原因。如果一个程序对物理内存来说变得过于庞大，就需要由程序员负责将其装进去。程序员将程序划分为片段，然后确认这些互斥的片断，在执行时间根据用户程序控制来加载或卸载这些覆盖段（overlay）。程序员确保程序绝对不会尝试访问超出计算机现有的物理主存储器，并确保会在正确的时间加载正确的覆盖段。容易想到，这种责任降低了程序员的生产效率。

虚拟存储器的发明是为了减轻程序员的这一负担；它自动管理表示为主存储器和辅助存储的两级存储器层次结构。图B-11显示了程序从虚拟存储器到物理存储器的映射，共有4个页面。

除了共享受保护的存储器空间和自动管理存储器层次结构之外，虚拟存储器还简化了为执行程序而进行的加载过程。这种被称为再定位（relocation）的机制允许同一程序在物理存储器中的任意位置运行。图B-11中的程序可以定位在物理存储器中的任何位置，也可以放在磁盘上，只需要改变它们之间的映射即可。（在虚拟存储器普通之前，处理器中包含一个用于此目的的再定位寄存器。）硬件解决方案的一种替代方法是使用软件，在每次运行一个程序时，改变其所有地址。

图B-11 左侧给出位于相邻虚拟地址空间中的逻辑程序。它包括A、B、C和D4个页。这些块中有3个的实际位置在物理主存储器中，另一个位于磁盘上

第1章中几个有关缓存的一般性存储器层次结构思想与虚拟存储器类似，当然，其中有许多术语不同。页或段表示块，页错误或地址错误用于缺失。有了虚拟存储器，处理器会给出虚拟地址，由软硬件组合方式转换为物理地址，再来访问主存储器。这一过程称为存储器映射或地址转换。今天，由虚拟地址控制的两级存储器层次结构为DRAM和磁盘。表B-9显示了虚拟存储器存储器层次结构参数的典型范围。

除了表B-9中提到的量化区别之外，缓存与虚拟存储器之间还有其他一些区别，如下所述。

• 发生缓存缺失时的替换主要由硬件控制，而虚拟存储器替换主要由操作系统控制。缺失代价越长，正确作出决定就显得越重要，所以操作系统可以参与其中，花费一些时间来决定要替换哪些块。
• 处理器地址的大小决定了虚拟存储器的大小，但缓存大小与处理器地址大小无关。
• 除了在层次结构中充当主存储器的低一级后援存储之外，辅助存储还用于文件系统。事实上，文件系统占用了大多数辅助存储。它通常不在地址空间中。

虚拟存储器还包含几种相关技术。虚拟存储器系统可分为两类：页，采用大小固定的块；段，采用大小可变的块。页大小通常固定为4096至8 192字节，而段大小是变化的。任意处理器所支持的最大段范围为216个字节至232个字节，最小段为1个字节。图B-11显示了这两种方法可以如何划分代码和数据。

图B-11 分页和分段方式对程序的划分示例

是使用页虚拟存储器还是段虚拟存储器，这一决定会影响处理器。页寻址方式的地址是单一固定大小，分为页编号和页内偏移量，与缓存寻址类似。单一地址对分段地址无效，可变大小的段需要1个字来表示段号，1个字表示段内的偏移量，总共2个字。对编译器来说，不分段地址空间更简单一些。

这两种方法的优缺点已经在操作系统教科书中进行了很好的阐述，表B-10总结了这些观点。由于替换问题（表中第三行），今天很少再有计算机使用纯粹的分段方法。一些计算机使用一种名为页式分段的混合方式，在这种方式中，一个段由整数个页组成。由于存储器不需要是连续的，也不需要所有段都在主存储器中，从而简化了替换过程。最近的一种混合方式是由计算机提供多种页面大小，较大页面的大小为最小页面大小的整数倍，且为2的幂。

• 这两者都可能浪费存储器，取决于块大小及各分段能否很好地容纳于主存储器中。采用不受限指针的编程语言需要传递段和地址。一种称为页式分段的混合方法可以发挥这两者的最佳状态：分段由页组成，所以替换一个块是很轻松的，而一个段仍被看作一个逻辑单位。

再谈存储器层次结构的4个问题

我们现在已经为回答虚拟存储器的四个存储器层次结构问题做好了准备。

问题1：一个块可以放在主存储器的什么位置?

虚拟存储器的缺失代价涉及旋转磁存储设备的访问，因此非常高。如果在较低缺失率与较简单放置算法之间进行选择，操作系统设计人员通常选择较低缺失率，因为其缺失代价可能会高得离谱。因此，操作系统允许将块放在主存储器中的任意位置。根据图B-1中的术语，这一策略可以标记为全相联的。

问题2：如果一个块在主存储器中，如何找到它?

分页和分段都依靠一种按页号或段号索引的数据结构。这种数据结构包含块的物理地址。对于分段方式，会将偏移量加到段的物理地址中，以获得最终物理地址。对于分页方式，该偏移量只是被串接到这一物理分布地址。

图B-13 通过页表将虚拟地址映射到物理地址

这一包含物理页地址的数据结构通常采用一种分页表的形式。这种表通常根据虚拟页号进行索引，其大小就是虚拟地址空间中的页数。如果虚拟地址为32位、4 KB页、每个页表项（PTE）大小为4字节，则页表的大小为(2^32/2^12) x 2^2 = 2^22即4 MB。

为了缩小这一数据结构，一些计算机向虚拟地址应用了一种散列功能。这种散列允许数据结构的长度等于主存储器中物理页的数目。这一数目可以远小于虚拟页的数目。这种结构被称为反转分页表。利用前面的例子，一个512 MB的物理存储器可能只需要1 MB (8 x 512 MB/4KB)的反转分页表；每个页表项另外需要4字节，用于表示虚拟地址。

为了缩短地址转换时间，计算机使用一个专门进行这些地址变换的缓存，称为变换旁视缓冲区，或者简称为变换缓冲区。

问题3：在虛拟存储器缺失时应当替换哪个块?

前面曾经提到，操作系统的最高指导原则是将页错误降至最低。几乎所有操作系统都与这一指导原则保持一致，尝试替换最近使用最少（LRU）的块，这是因为如果用过去的信息来预测未来，将来用到这种块的可能性最低。

为了帮助操作系统评估LRU，许多处理器提供了一个使用位或参考位，从逻辑上来说，只要访问一个页，就应对其进行置位。（为了减少工作，通过仅在发生转换缓冲区缺失时对其进行置位，稍后将对此进行介绍。）操作系统定期对这些使用位清零，之后再记录它们，以判断在一个特定时间段时使用了哪些页。通过这种方式进行跟踪，操作系统可以选择最近引用最少的一个页。

问题4：在写入时发生什么?

主存储器的下一级包含旋转磁盘，其访问会耗时数百万个时钟周期。由于访问时间的巨大差异，还没有人构建一种虚拟存储器操作系统，在处理器每次执行存储操作时将主存储器直写到磁盘上。因此，这里总是采用写回策略。

由于对低一级的非必需访问会带来如此之高的成本，所以虚拟存储器系统通常会包含一个重写位。利用这一重写位，可以仅将上次读取磁盘之后经过修改的块写至磁盘。

快速地址变换技术

分页表通常很大，从而存储在主存储器中，有时它们本身就是分页的。分页意味着每次存储器访问在逻辑上至少要分两次进行，第一次存储器访问是为了获得物理地址，第二次访问是为了获得数据。第2章曾经提到，我们使用局域性来避免增加存储器访问次数。将地址变换局限在一个特殊缓存中，存储器访问就很少再需要第二次访问来转换数据。 这一特殊地址变换缓存被称为变换旁视缓冲区（TLB），有时也称为变换缓冲区（TB）。

TLB项就像是一个缓存项目，其中的标志保存了虚拟地址部分，数据部分保存了特殊页帧编号、保护字段、有效位，通常还有一个使用位和重写位。要改变页表中某一项的特殊页帧编号或保护字段，操作系统必须确保旧项不在TLB中；否则，系统就不能正常运行。注意，这个重写位意味着对应页曾被改写过，而不是指TLB中的地址变换或数据缓存中的特殊块经过改写。操作系统通过改变页表中的值，然后再使相应TLB项失效来重置这些位。在从分页表中重新加载该项时，TLB会获得这些位的准确副本。

图B-14给出了Opteron 数据TLB组织方式，并标出了每一个变换步骤。这个TLB使用全相联布置；因此，变换首先向所有标志发送虚拟地址（步骤1和步骤2）。当然，这些标志必须标记为有效，以允许进行匹配。同时，根据TLB中的保护信息核对存储器访问的类型，以确认其是否有效（也在步骤2中完成）。

图B-14 在地址变换期间Opteron数据TLB的操作。一次 TLB命中的4个步骤用带圆圈的数字显示。这个TLB有40项。

和缓存中的理由相似，TLB中也不需要包含页偏移量的12个位。匹配标志通过一个40选1多工器，高效地发送相应的物理地址（步骤3）。然后将页偏移量与物理页帧合并，生成一个完整的物理地址（步骤4）。地址大小为40位。

选择页大小

最显而易见的体系结构参数是页大小。页大小的选择实际就是在偏向较大页与偏向较小页的力量之间进行平衡的问题。以下因素偏向较大尺寸。

• 页表的大小与页大小成反比，因此，增大页的大小可以节省存储器（或其他用于存储器映射的资源）。
• B.3节曾经提到，分页较大时，可以允许缓存命中时间较短的较大缓存。
• 与传递较小页相比，从（向）辅助存储传递较大页（有可能通过网络）的效率更高一些。
• TLB项目的数量受限，所以分页较大意味着可以高效地映射更多存储器，从而可以降低TLB缺失数量。

由于最后这个原因，近来的微处理器决定支持多种页大小；对于一些程序，TLB缺失对CPI的重要性可能与缓存缺失相同。

采用较小分页的主要动机是节省存储。当虚拟内存的相邻区域不等于页大小的整数倍时，采用较小页可以减少存储的浪费空间。页面中这种未使用存储器的术语名称为内部碎片。假定每个进程有三个主要段（文本、堆和栈），每个进程的平均浪费存储量为页大小的1.5倍。当然，当页大小非常大（超过32KB）时，那就可能浪费存储（主存储器和辅助存储器）和I/O带宽了。

最后一项关注是进程启动时间；许多进程都很小，较大的页面可能会延长调用一个进程的时间。

虚拟存储器和缓存小结

由于虚拟存储器、TLB、第一级缓存、第二级缓存都映射到虚拟与物理地址空间的一部分，所以人们可能会混淆哪些位去了哪里。图B-15给出了一个从64位虚拟地址到41位物理地址的假设示例，它采用两级缓存。这一L1缓存的缓存大小和页大小都是8 KB，所以它是虚拟寻址、物理标记的。L2缓存为4 MB。这两者的块大小都是64个字节。

第一，64位虚拟地址在逻辑上被划分为虚拟页号和页偏移量。前者被发送到TLB，以备变换为物理地址，后者的高位被发送到L1缓存，充当索引。如果TLB匹配命中，则将物理页号发送到L1缓存标志，检查是否匹配。如果匹配，则是L1缓存命中。块偏移随后为处理器选择该字。

如果L1缓存核对显示为缺失，则使用物理地址尝试L2缓存物理地址的中间部分用作4MB L2缓存的索引。将所得到的L2缓存标志与物理地址的上半部分对比，以检查是否匹配。如果匹配，我们得到一次L2缓存命中，数据被送往处理器，它使用块偏移量来选择所需字。在L2缺失时，会使用物理地址从存储器获取该块。

尽管这是一个简单示例，但该图与真实缓存之间的主要区别只是重复问题。因为，只有一个L1缓存。如果有两个L1缓存，会重复该图的上半部分。注意，这会导致拥有两个TLB，而这正是典型情况。因此，一个缓存和TLB用于指令，由PC驱动，一个缓存和TLB用于数据，由实际地址驱动。

第二种简化是所有缓存与TLB都是直接映射的。如果有任何一个是n路组相联的，则会将每一组标志存储器、比较器和数据存储器重复n次，并用一个 n选1多工器将数据存储器连接在一起，以选择命中内容。当然，如果总缓存大小保持不变，则缓存索引也会收缩log2n 位，如图B-4中的公式所示。

图B-15 一个从虚拟地址到L2缓存访问的虚设存储器层次结构的整体图像。页大小为8 KB。TLB为直接映射，有256项。L1缓存为直接映射8 KB，L2缓存为直接映射，大小为4 MB。两者的块都是64字节。虚拟地址为64位，物理地址为41位。这一简单图像与实际缓存的主要差别在于这一图像多个组成部分的重复

虚拟存储器的保护与示例

在多重编程中，计算机由几个并行执行的程序共享，它的发明为程序之间的保护和共享提供了新的要求。这些要求与今天计算机中的虚拟存储器紧密捆绑在一起，所以我们在这里用两个虚拟存储器的示例来介绍这一主题。

多重编程导致了进程概念的出现。打个比方，进程就是程序呼吸的空气和生活的空间——即一个正在运行的程序加上持续运行它所需要的所有状态。时分共享是多重编程的一种变体，由几个同时进行交互的用户来共享处理器和存储器，给人的感觉是所有用户都拥有自己的计算机。因此，它在任何时刻都必须能够从一个进程切换到另一进程。 这种交换被称为进程切换或上下文切换。

一个进程无论是从头到尾持续执行，还是被反复中断，与其他进程进行切换，其运行都必须正常进行。维护正确进程行为的责任由程序和操作系统的设计者共同分担。计算机设计师必须确保进程状态的处理器部分能够保存和恢复。操作系统设计师必须确保这些进程不会相互干扰对方的计算。

保护一个进程的状态免受其他进程损害的最安全方法就是将当前信息复制到磁盘上。但是，一次进程切换可能需要几秒的时间一这对时分共享环境来说过长了。这一问题的解决方法是由操作系统对主存储器进行划分，使几个不同进程能够在存储器同时拥有自己的状态。这种划分意味着操作系统设计师需要计算机设计师的帮助，以提供保护，使一个进程无法修改其他进程。除了保护之外，计算机还为进程之间共享代码和数据提供了支持，允许进程之间进行通信，或者通过减少相同信息的副本数目来节省存储器。

保护进程

使进程拥有自己的分页表，分别指向存储器的不同页面，这样可以为进程提供保护，避免相互损害。显然，必须防止用户修改它们的分页表，或者以欺骗方式绕过保护措施。

分段虛拟存储器举例：Intel Pentium中的保护方式

最早的8086使用分段寻址，但它没有提供任何虚拟存储器或保护。分段拥有基础寄存器，但没是界限寄存器，也没有访问核查，在能够载入分段寄存器之前，必须将相应段载入物理存储器中。Intel对虚拟存储器和保护的专注在8086的后续产品中得到体现，扩展了一些字段来支持更大地址。这种保护机制非常精巧，精心设计了许多细节，以尝试避免安全漏洞。我们将其称为IA-32。接下来的几页内容将重点介绍Intel的一些安全措施。

第一种增强是将传统的两级保护模型加倍： IA-32 有四级保护，最内层（0）对应于传统的内核模式，最外层（3）是权限最少的模型。IA-32 为每一级提供独立栈，以避免突破不同级别之间的安全措施。还有一些与传统分页表类似的数据结构，其中包含了段的物理地址，还有一个对变换地址进行的核对清单。

Intel设计师并没有就此驻足不前。IA-32 划分了地址空间，让操作系统和用户都能访问整个空间。IA-32用户能够在保持全面保护的情况下调用这一空间 中的操作系统例程，甚至还可以向其传送参数。由于操作系统栈不同于用户栈，所以这一安全调用可不是一 个简单操作。另外，LA-32允许操作系统为那些传递给被调用例程的参数保持这些被调用例程的保护级别禁止用户进程要求操作系统间接访问一些该进程自己不能访问的东西，就可以防止这一潜在保护漏洞。

Intel设计师有一条指导原则：尽可能对操作系统持怀疑态度，并支持共享和保护。作为这种受保护共享的一个应用示例，假定有一个薪金支付系统，它要填写支票，并更新有关本年度截至当前为止的总薪金和津贴支付信息。因此，我们希望赋予该程序读取薪金、当前信息和修改当前信息的功能，但不能修改薪金。稍后将会看到支持这些功能的机制。

增加界限检查和存储器映射

增强Intel 处理器的第一个步骤是利用分段寻址来检查界限和提供基址。IA-32中的分段寄存器中包含的不是基址，而是指向虚拟存储器数据结构的索引，这种结构称为描述符表。描述符表扮演着传统分页表的角色。IA-32 上与页表项等价的是段描述符。它包含可以在PTE中找到的字段，如下所述。

• 存在位——等价于 PTE有效位，用于表明这是一个有效变换。
• 基址字段——等价于一个页帧地址，包含该段第一个字节的物理地址。
• 访问位——类似于某些体系结构中的引用位或使用位，可以为替换算法提供帮助。
• 属性字段——为使用这一段的操作指定有效操作和保护级别。

还有一个在分页系统中没有出现的界限段，它确定这一分段有效偏移量的上限。图B-16给出了IA-32段描述符的示例。

图B-16 IA-32 段描述符由其属性字段中的位进行区分。基址位、界限位、存在位、可读位和可写位的用途都是不言自明的。D是指令的默认寻址大小：16位或32位。G是段界限的粒度：0表示采用字段，1表示采用4 KB的页。在开启分页以设置页表大小时，将G设置为1。 DPL表示描述符权限级别一根据代码权限级别核对 DPL，以查看是否允许访问。一致性是指代码采用被调用代码的权限级别，而不是调用者的权限级别；用于库例程。向下扩展段颠倒检查过程，以基址字段为高位标记，界限字段为低位标记。可以猜到，这种方式用于向下发展的栈段。字数控制从当前栈向调用门上新栈复制的字数。调用门描述符的其他两个字段——目标选择位和目标偏移量，分别选择该调用目标的描述符及其内部的偏移量。IA-32 保护模型中的段描述符远不止这三种

除了这种段式寻址之外，IA-32 提供了一种可选的分页系统。32位地址的上面部分选择段描述符，中间部分是描述符所选页表中的索引。下 面介绍不依赖分页的保护系统。

增加共享和保护

为提供受保持的共享，地址空间的一伴由所有进程共享，另一半由各进程独享，分别称为全局地址空间和局部地址空间。为每一半都提供一个拥有适当名字的描述符表。指向共享段的描述符被放在全局描述符表中，而指向专用段的描述符则被放在局部描述符表中。程序向IA-32 段寄存器中载入一个索引和一个位，索引指向描述符表，这一个位表明程序希望获得哪个表。根据描述符中的属性对操作进行检查，将来自处理器的偏移量加到描述符中的基址来构成物理地址，前提是这一偏移量要小于界限字段。每个段描述符都有一个独立的2位字段，提供这个段的合法访问级别。仅当程序尝试以段描述符中的较低保护级别使用段时，才会发生违反错误。

我们现在可以介绍如何调用上述薪金支付程序来更新当前信息，但不允许它更新薪金数据。可以向程序提供该信息的一个描述符，描述符的可写字段被清零，表明程序能够读取数据但不能写数据。然后可以提供一个受信任的程序，它只会写入当前最新信息。在向这一程序提供的描述符中，其可写字段已被置位（见图B-16）。薪金支付程序使用一个代码段描述符来调用受信任的代码，描述符的一致性字段已被置位。这种设置意味着被调用程序取得了被调用代码的权限级别，而不是调用者的权限级别。因此，薪金支付程序可以读取薪金信息，并调用受信任的程序来更新当前总值，但薪金支付程序不能修改这些薪金信息。

增加从用户到操作系统门的安全调用，为参数继承保护级别

允许用户介入操作系统是非常大胆的一步。但是，硬件设计师如何能在不信任操作系统或其他代码的情况下增加安全系统的可能性呢? IA-32 方法是限制用户能够进入代码段的位置，将参数安全地放到正确的栈中，并确保用户参数不会取得被调用代码的保护级别。为限制进入其他代码，IA-32 提供了一种被称为调用门（call gate）的特殊段描述符，用属性字段中的一位来识别。与其他描述符不同，调用门是一个对象在存储器中的完整物理地址；处理器提供的偏移量被忽略。如上所述，它们的目的是防止用户随机进入一段受保护或拥有更高权限的代码段中。在我们这个编程示例中，这意昧着薪金支付程序唯一能够调用受信任代码的位置就是在准确的边界位置。一致性段的正常工作需要这一限制。

如果调用者和被调用者“相互怀疑”，都不相信对方，那会怎么样呢?在图B-16询问描述符的字数字段中可以找到解决方案。当一条调用指令调用一个调用门描述符时，描述符将局部栈中的一些字复制到这个段级别相对应的栈中，字的数量由描述符指定。这一复制过程允许用户首先将参数压入局部栈中，从而实现参数传递。随后由硬件将参数安全地传送给正确的栈。在从调用门返回时，会将参数从栈中弹出，并将返回值复制到正确的栈中。注意，这一模型与目前在寄存器中传递参数的实际做法不兼容。

这一机制仍然未能关闭潜在的安全漏洞：操作系统以操作系统的安全级别来使用作为参数传递的用户地址，而不是使用用户级别。IA-32在每个处理器段寄存器中专门拿出2个位来指定所请求的保护级别，从而解决了上述问题。当这些地址参数载入段寄存器时，它们将所请求的保护级别设置为正确值。IA-32硬件随后使用所请求的保护级别来防止出现欺骗：对于使用这些参数的系统例程，如果其权限保护级别高于被请求级别，则不允许该例程访问任何段。

分页虚拟存储器举例： 64位Opteron存储器管理

常用的模型是在80386中引入的一种平面32位地址空间，它将段寄存器的所有基址值都设置为0。因此，AMD在64位模式中摒弃了多个段。它假定段基址为0，忽略了界限字段。页大小为4KB、2 MB和4MB。

AMD64体系结构的64位虚拟地址被映射到52位物理地址，当然，具体实现可以采用较少的位数，以简化硬件。例如，Opteron 使用48位虚拟地址和40位物理地址。AMD64需要虚拟地址的高16 位就是低48位的符号扩展，这称为规范格式。

64位地址空间页表的大小是惊人的。因此，AMD64使用了一种多级层次结构分页表来映射地址空间，使其保持合理大小。级别数取决于虚拟地址空间的大小。图B-17显示了Opteron的48位虚拟地址的四级变换。

这些页表中各个表的偏移量来自4个9位字段。地址变换时，首先将第一个偏移量加到页映射第4级基址寄存器，然后从这个位置读取存储器，获取下一级页表的基址。然后再将下一级地址偏移量添加到这个新获取的地址，再次访问存储器，以确定第三个页表的基址。再次重复以上过程。最后一个地址字段被加到这一最终基址，使用两者之和读取存储器，获得所引用页面的物理地址。这个地址与12位页面偏移量串接在一起，获得完整的物理地址。注意，Opteron体系结构中的页表可以放在单个4KB页中。

Opteron在每个页表中使用64位的项目。前12位为保留位，供以后使用，接下来的52位包含物理页帧编号，最后12位提供保护、使用信息。尽管不同页表级别之间的字段会有所变化，但基本上都有以下位。

• 存在位——表明该页存在于存储器中。
• 读取/写入位——表明一个页是只读的，还是读写的。
• 用户/管理员位——表明用户是可以访问该页，还是仅限于上面三个权限级别。
• 脏位——表明该页是否已经被修改。
• 访问位——表明自该位上次清零以来，是否曾读取或写入过该页。
• 页面大小位——表明最后一级是4 KB页面，还是4 MB页面;如果是后者，则Opteron只使用3个页面级别，而不是4个。
• 不执行位——未出现在 80386保护机制中，添加这个位是为了防止代码在某些页内执行。
• 页级缓存禁用——表明是否可以缓存该页。
• 页级直写——表明该页对数据缓存应用写回还是直写。

图B-17 Opteron 虚拟地址的映射。拥有4个页表级别的Opteron虚拟存储器实现方式支持40位的有效物理地址大小。每个页表有512项，所以每一级字段的宽度为9位。AMD64体系结构文档允许虚拟地址大小从当前的48位增长到64位，允许物理地址从当前的40位增长到52位

由于Opteron在TLB缺失时通常会经历四级页表，所以有3个可能位置来核对保护限制。Opteron仅服从底级PTE，检查其他各项只是为了确保设置了有效位。由于该项目的长度为8个字节，每个页表有512项，而且Opteron拥有大小为4 KB的页，所以这些页表的长度恰好为一页。 这些四级字段的每一个字段长9位，页偏移量为12位。这一推导留出64-(4 x 9 + 12)=16位进行符号扩展，以确保地址的规范化。

尽管我们已经解释了合法地址的转换，那什么会防止用户创建非法地址转换并阻止故障发生呢?这些页表本身是受保护的，用户程序不能对其进行写入。因此，用户可以尝试任意虚拟地址，但操作系统通过控制页表项来控制访问哪个物理存储器。为了实现进程之间的存储器共享，在每个地址空间中都设置一个页表项，指向同一个物理存储器页。

Opteron采用4个TLB来缩短地址转换时间，两个TLB用于指令访问，两个用于数据访问。与多级缓存类似，Opteron 通过两个较大的L2 TLB来减少TlB缺失：一个用于指令，一个用于数据。表B-11介绍了数据TLB。

小结：32 位Intel Pentium与64位AMD Opteron的保护对比

Opteron中的存储器管理是当今大多数桌面或服务器计算机的典型代表，依靠页级地址变换和操作系统的正确操作，为共享计算机的多个进程提供安全性。尽管Intel也提出了一些替代方案，但它还是沿袭了AMD的领先作法，接纳了AMD64体系结构。因此，AMD和Intel都支持80x86的64位扩展；但出于兼容性原因，这两者都支持复杂的分段保护机制。

结语

要想制造出能够跟上处理器步伐的存储器系统，其难度极大，无论多么先进的计算机，其主存储器的制造原材料都与最廉价的计算机一致，这一事实为上述难度添加了新的注脚。这里能为我们提供帮助的是局域性原理一当前计算机中存 储器层次结构的各个级别（从磁盘到TLB）都证明了它的正确性。

但是，到存储器的相对延迟不断增加，2011 年达到数百个时钟周期，这就意味着，如果程序员和编译器编写入员希望自己的程序能够正常执行，就必须了解缓存和TLB的参数。

流水线：基础与中级概念

引言

我们在本附录中首先介绍流水线的基础知识，包括数据路径含义的讨论、冒险的介绍、流水线性能的研究。这一节介绍基本的五级RISC，它是本附录其余部分的基础。C.2 节介绍冒险问题、它们为什么会导致性能问题、应当如何应对。C.3节讨论如何实际实现这个简单的五级流水线，重点是控制和如何应对冒险。C.4节讨论流水线和指令集设计各个方面之间的相互关系，讨论了有关异常的重要主题以及它们与流水线的相互交互。C.5节讨论如何扩展五级流水线，以处理运行时间更长的浮点指令。C.6节在一个案例研究中将这些概念结合在一起，这个案例研究的对象是一个深度流水线处理器——MIPS R4000/4400，它既包括八级整数流水线，又包括浮点流水线。C.7节介绍了动态调度的概念，以及记分板在动态调度实现中的用法。它是作为交叉问题介绍的。C.7节还简单探讨了第3章中介绍的更复杂Tomasulo 算法。

什么是流水线

流水线是一种将多条指令重叠执行的实现技术。一条指令的执行需要多个操作，流水线技术充分利用了这些操作之间的并行性。就像装配线一样，不同步骤并行完成不同指令的不同部分。这些步骤中的每一步都称为流水级或流水段。流水级前后相连形成流水线一指令在一端进入，通过这些流水级，在另一段退出。

指令流水线的吞吐量由指令退出流水线的频率决定。由于流水线级是连在一起的，所以所有流水级都必须做好同时工作的准备。将一条指令在流水线中下移一步所需的时间为处理器周期。由于所有各级同时进行，所以处理器周期的长度由最缓慢流水线级所需时间决定。在计算机中，这一处理器周期通常为1个时钟周期（有时为2个，但要少见得多）。流水线设计者的目标是平衡每条流水线的长度。如果各级达到完美平衡，那么每条指定在流水线处理器中的时间（假定为理想条件）等于：

非流水线机器上每条指令的时间/流水级的数目

在这些条件下，因为实现流水线而得到的加速比等于流水级的数目，但一般情况下，这些流水线之间不会达到完美平衡；此外，流水线还会产生一些开销。因此，在流水线处理器上，处理每条指令的时间不会等于其最低可能值，但可以非常接近。

流水线可以缩短每条指令的平均执行时间。根据我们认证的基准，这一缩短量可以计作每条指令时钟周期数（CPI）的下降、时钟周期时间的缩短，或者这两者的组合。如果在开始时，处理器需要多个时钟周期来处理一条指令，那我们通常将流水线的作用看作是降低了CPI。

如果在开始时，处理器需要一个（长）时钟周期来处理一条指令，那就认为流水线缩短了时钟周期时间。流水线技术开发了串行指令流中各指令之间的并行度。它与某些加速技术不同，其真正的好处在于它对程序员是透明的。在这一附录中，我们将首先使用一个经典的五级流水线来介绍流水线的概念；其他章节研究了更复杂流水线技术在现代处理器的应用。在更深入地讨论流水线及其在处理器的应用之前，我们需要一个简单的指令集，下面将对此进行介绍。

RISC指令集基础知识

在本书中，我们一直使用RISC（精简指令集计算机）体系结构或载入-存储体系结构来说明基本概念，当然，本书介绍的几乎所有思想都适用于其他处理器。本节介绍典型RISC 体系结构的核心。RISC体系结构有几个关键属性，这些属性大大简化了其实现方式。

• 所有数据操作都是对寄存器中数据的操作，通常会改变整个寄存器（每个寄存器为32位或64位）。
• 只有载入和存储操作会影响到存储器，它们分别将数据从存储器移到寄存器或从寄存器移到存储器。通常存在一些可以载入或存储低于一个完整寄存器的内容。
• 指令格式的数量很少，所有指令通常都是同一种大小。

这些简单属性极大地简化了流水线的实现，这也是如此设计这些指令集的原因。为与本书其他部分保持一致， 我们使用MIPS64，它是MIPS指令集的64位版本。这些扩展64位指令通常在助记符的开头或末尾加上字母D加以标识。例如，DADD是加法指令的64位版本，而LD则是载入指令的64位版本。

与其他RISC体系结构类似，MIPS 指令集提供了32个寄存器，不过寄存器0的值总是0。大多数RISC体系结构，比如MIPS，通常有以下三类指令（更多详细信息请参见附录A）。

（1） ALU指令——这些指令取得两个寄存器或者一个寄存器与一个符号扩展立即数（称为ALU立即数指令，它们在MIPS中有一个16位偏移量），对它们进行操作，然后将结果存储到第三个寄存器中。典型操作包括加（DADD）、减（DSUB）和逻辑运算（例如AND或OR），后者不区分32位和64位版本。这些指令的立即数版本使用相同助记符，但添加了后缀I。在MIPS中，包括算术运算的有符号形式和无符号形式；无符号形式的末尾有一个字母U（例如，DADDU、DSUBU、DADDIU），不会生成溢出异常（因此在32位和64位模式中是一样的）。

（2）载入和存储指令——这些指令获取一个寄存器源（称为基址寄存器）和一个立即数字段（在MIPS中为16位，称为偏移量）作为操作数。基址寄存器的内容与符号扩展偏移量之和（称为有效地址）用作存储器地址。对于载入指令，使用第二个寄存器操作数，用于存放从存储器载入的数据。对于存储指令，第二个寄存器操作数是要存入存储器的数据源。载入字（LD）和存储字（SD）等指令载入或存储整个64位寄存器内容。

（3）分支与跳转——分支是指控制的条件转移。在RISC体系结构中，通常有两种方式来指定分支条件：采用一组条件位（有时称为条件码），或者通过寄存器对之间、寄存器与零之间的有限对比来设定。MIPS采用后者。对于本附录，我们仅考虑两个寄存器是否相等。在所有RISC体系结构中，分支目的地都是通过将符号扩展偏移量（MIPS中为16位）加到当前程序计数器中获得的。在许多RISC体系结构中都提供了无条件跳转，但本附录中不会介绍跳转。

RISC指令集的简单实现

为了理解如何以流水线形式来实现RISC指令集，需要理解在没有流水线时它是如何实现的。这一节给出了一种简单实现，每一条指令 最多需要5个时钟周期。我们将这一基本实现扩展到流水线版本，从而大幅降低CPI。在所有不采用流水线的实现方式中，我们给出的方式并非最经济或性能最高的。它的设计只是可以很自然地引向流水线实现。实现此指令集需要引入几个不属于该体系结构的临时寄存器，引入它们是为了简化流水线。我们的实现将仅关注RISC体系结构中整数操作部分的流水线，这部分操作包括载入-存储字、分支和整数ALU操作。

这个RISC子集中的每条指令都可以在最多5个时钟周期内实现。这5个时钟周期如下所述。

• 指令提取周期（IF）
  • 将程序计数器（PC）发送到存储器，从存储器提取当前指令。向程序计数器加4 （因为每条指令的长度为4个字节），将程序计数器更新到下一个连续程序计数器。
• 指令译码/寄存器提取周期（ID）
  • 对指令进行译码，并从寄存器堆中读取与寄存器源说明符相对应的寄存器。在读取寄存器时对其进行相等测试，以确定是否为分支。必要时，对指令的偏移量字段进行符号扩展。符号扩展后的偏移量添加到所实现的程序计数器上，计算出可能的分支目标地址。在较为积极的实现方式中，如果这一条件判断的结果为真，则可以将分支目标地址存储到程序计数器中，以在这一级的末尾完成分支。
  • 指令译码与寄存器的读取是并行执行的，这可能是因为在RISC体系结构中，寄存器说明符位于固定位置。这一技术称为固定字段译码。注意，我们可能会读取一个不会使用的寄存器。由于一个指令的立即数部分也位于同一位置，所以在需要符号扩展立即数时，也是在这一周期计算的。
• 执行/有效地址周期（EX）
  • ALU对上一周期准备的操作数进行操作，根据指令类型执行三条指令之一。
    • 存储器引用——ALU 将基址寄存器和偏移量加到一起，形成有效地址。
    • 寄存器-寄存器ALU指令——ALU 对读自寄存器堆的值执行由ALU操作码指定的操作。
    • 寄存器-立即数ALU指令——ALU对读自寄存器堆的第一个值和符号扩展立即数执行由ALU操作码指定的操作。
  • 在载入-存储体系结构中，有效地址与执行周期可以合并到一个时钟周期中，这是因为没有指令需要计算数据地址并对数据执行操作。
• 存储器访问（MEM）
  • 如果该指令是一条载入指令，则使用上一周期计算的有效地址从存储器中读取数据。如果是一条存储指令，则使用有效地址将从寄存器堆的第二个寄存器读取的数据写入存储器。
• 写回周期（WB）
  • 寄存器寄存器ALU指令或载入指令。
  • 将结果写入寄存器堆，无论是来自寄存器系统（对于载入指令），还是来自ALU（对于ALU指令）。

在这一实现中，分支指令需要2个周期，存储指令需要4个周期，所有其他指令需要5个周期。假定分支频率为12%，存储频率为10%，对于这一典型指令分布， 总CPI 为4.54。但是，无论是在获取最佳性能方面，还是在给定性能级别的情况尽量减少使用硬件方面。

RISC处理 器的经典五级流水线

我们几乎不需要进行什么改变就能实现上述执行过程的流水化，只要在每个时钟周期开始一条新的指令就行。上一节的每个时钟周期都变成一个流水
线级——流水线中的一个周期。这样会得到表C-1所示的执行模式，这是绘制流水线结构的典型方式。尽管每条指令需要5个周期才能完成，但在每个时钟周期内，硬件都会启动一条新的命令，执行5个不同指令的某一部分。

• 在每个时钟周期，提取另一条指令，并开始它的五周期执行过程。如果在每个时钟周期都启动一条指令，其性能最多可达到非流水化处理器的5倍。流水线中各个阶段的名称与非流水线实现方式中各个周期的名称相同： IF=指令提取、ID=指令译码、EX=执行、MEM=存储器访问、WB=写回。

首先，我们必须确定在处理器的每个时钟周期都会发生什么，确保不会在同一时钟周期内对相同数据路径源执行两个不同操作。例如，不能要求同一个ALU同时计算有效地址和执行减法操作。因此，我们必须确保流水线中的指令重叠不会导致这种冲突。幸运的是，RISC指令集比较简单，使资源评估变得相对容易。图C-1以流水线形式绘制了一个RISC数据路径的简化版本。可以看到，主要功能单元是在不同周期使用的，因此多条指令的执行重叠不会入多少冲突。从以下三点可以看出这一事实。

图C-1 流水线可以看作一系列随时间移动的数据路径。本图给出了数据路径不同部分之间的重叠，时钟周期5 （CC5）表示稳定状态。由于寄存器用作ID级中的一个源和WB级中的目的地，所以它出现两次。我们表示它在该级的一个部分进行读取，在另一部分进行写入，分别用左右两侧的实线或虚线来表示。缩写IM表示指令存储器、DM表示数据存储器、CC表示时钟周期

第一，我们使用分离的指令存储器和数据存储器，我们通常用分离的指令和数据缓存来实现它们。在使用存储器时，在指令提取和数据存储器访向之间可能会发生冲突，而使用分离缓存则可以消除这种冲突。注意，如果我们的流水线处理器的时钟周期等于非流水线版本的时钟周期，则存储器系统必须提供5倍的带宽。这一需求的增加是提高性能的一种成本。

第二，在两个阶段都使用了寄存器堆：一个是在ID中进行读取，一个是在WB中进行写入。这些用法是不同的，所以我们干脆在两个地方画出了寄存器堆。因此，每个时钟周期需要执行两次读取和一次写入。为了处理对相同寄存器的多次读取和一次写入，我们在时钟周期的前半部分写寄存器，在后半部分读寄存器。

第三，图C-1没有涉及程序计数器。为了在每个时钟周期都启动一条新指令，我们必须在每个时钟周期使程序计数器递增并存储它，这必须在IF阶段完成，以便为下一条指令做好准备。此外，还必须拥有一个加法器，在ID期间计算潜在的分支目标。另外一个问题是分支在ID级改变程序计数器。

尽管确保流水线中的指令不会试图在相同时间使用硬件资源是至关重要的，我们还必须确保不同流水级中的指令不会相互干扰。这种分离是通过在连续流水级之间引入流水线寄存器来完成的，这样会在时钟周期的末尾，将一个给定流水级得出的所有结果都存储到寄存器中，在下一个时钟周期用作下一级的输入。图C-2给出了画有这些流水线寄存器的流水线。

图C-2 此流水线显示了连续流水级之间的流水线寄存器。注意，寄存器防止流水线相邻级中两条不同指令之间的干扰。在将一条给定指令的数据从一级带至另一级的过程中，寄存器也扮演着重要角色。寄存器的边沿触发特性（也就是说，取值在时钟沿即时改变）是非常关键的。否则，来自一条指
令的数据可能会干扰另一指令的执行!

尽管许多图形都为了简便而省略了这些寄存器，但它们是流水线正常操作所必需的。当然，即使在一些没有 采用流水化的多周期数据路径中也需要类似寄存器（因为 只有寄存器中的值能够在跨过时钟边界之后仍然得以保存）。在流水化处理器中，如果要将中间结果从一级传送到另一级，而源位置与目标位置可能并非直接相邻，流水线寄存器也会在这种传送过程种扮演关键角色。例如，要在存储指令中存储的寄存器值是在ID期间读取的，但要等到MEM才会真正用到；它在MEM级中通过两个流水线寄存器传送给数据存储器。与此类似，ALU指令的结果是在EX期间计算的，但要等到WB才会实际存储；它通过两个流水线寄存器才到达那里。有时对流水线寄存器进行命名是有用的，根据这些寄存器所连接的流水级对其进行命名，所以这些
寄存器称为IF/ID、ID/EX、EXMEM和MEM/WB。

流水化的基本性能问题

流水化提高了CPU指令吞吐量（单位时间内完成的指令数），但不会缩短单条指令的执行时间。事实上，由于流水线控制会产生开销，它通常还会稍微延长每条指令的执行时间。尽管单条指令的运行速度并没有加快，指令吞吐量的增长意味着程序可以更快速地运行，总执行时间缩短。除了因为流水线延迟产生的局限之外，流水级之间的失衡和流化化开销也会造成限制。流水级之间的不平衡会降低性能，这是因为时钟的运行速度不可能快于最缓慢的流水级。

流水线开销包含流水线寄存器延迟和时钟偏差。流水线寄存器增加了建立时间，也就是在发出触发写操作的时钟信号之前，寄存器输入必须保持稳定的时间，而且时钟周期的传播也会产生延迟。时钟偏差是时钟到达任意两个寄存器时刻之间的最大延迟，时钟周期的下限也受此因素的影响。如果时钟周期小于时钟偏差与延迟开销之和，那时钟周期中就没有留给有用工作的时间了，所以再增加流水线也就没用了。

考虑上一节的非流水化处理器。假定其时钟周期为1 ns，ALU运算和分支需要4个周期，存储器操作需要5个周期。假定这些操作的相对频率分别为40%、20%和40%。假设由于时钟偏差和建立时间的原因，对处理器实现流水化使时钟增加了0.2 ns的开销。忽略所有延迟影响，通过流水线获得的指令执行速率加速比为多少?

在非流水化处理器上，指令平均执行时间为：

指令平均执行时间=时钟周期x平均CPI = Ins x [(40% + 20%)x4 + 40%x5] = Ins x 4.4 = 4.4ns

在流水线实现方式中，时钟的运行速度必须等于最慢流水级的速度加上开销时间，也就是1+0.2=1.2 ns；这就是指令平均执行时间。因此，通过流水化获得的加速比为：

流水化加速比 = 非流水化指令平均执行时间/流水化指令平均执行时间 = 4.4ns/1.2ns = 3.7倍

0.2 ns的开销基本上确定了流水化的效能限度。如果此开销不受时钟周期变化的影响，那么从Amdahl定律可知，这一开销限制了加速比。

如果流水线中每条指令独立于所有其他指令，那这种简单的RISC 流水线对于整数指令可以正常运行。实际上，流水线中的指令可能是相互依赖的；这是下一节的主题。

流水化的主要阻碍——流水线冒险

有一些被称为冒险的情景，会阻止指令流中的下一条指令在其自己的指定时钟周期内执行。冒险降低了流水化所能获得的理想加速比。共有以下三类冒险。

1. 结构冒险，在重叠执行模式下，如果硬件无法同时支持指令的所有可能组合方式，就会出现资源冲突，从而导致结构冒险。
2. 数据冒险，根据流水线中的指令重叠，指令之间存在先后顺序，如果一条指令取决于先前指令的结果，就可能导致数据冒险。
3. 控制冒险，分支指令及其他改变程序计数器的指令实现流水化时可能导致控制冒险。

流水线中的冒险会使流水线停顿。为了避免冒险，经常要求在流水线中的一些指令延迟时，其他一些指令能够继续执行。对于本附录中讨论的流水线，当一条指令被停顿时，在停顿指令之后发射的所有指令也被停顿（这些指令在流水线中的位置不会远于停顿指令）。而在停顿指令之前发射的指令必须继续执行（它们在流水线中的位置要更远一些），否则就永远不会清除冒险情况。结果，在停顿期间不会提取新的指令。

带有停顿的流水线性能

停顿会导致流水线性能下降，低于理想性能。现在让我们看一个简单的公式，求解流水化的实际加速比，首先从上一节的公式开始：

流水化加速比=非流水化指令平均执行时间/流水化指令平均执行时间 = (非流水化CPI x 非流水化时钟周期)/(流水化CPI x流水化时钟周期) = (非流水化CPI/流水化CPI)x(非流水化时钟周期/流水化时钟周期)

流水化可以看作CPI或时钟周期时间的降低。由于传统上使用CPI来比较流水线，所以让我们从这里开始。流水化处理器的理想CPI几乎总等于1。因此，可以计算流水化CPI为：

流水化CPI = 理想CPI+每条指令的流水线停顿时钟周期 = 1+每条指令的流水线停顿时钟周期

如果忽略流水化的周期时间开销，并假定流水级之间达到完美平衡，则两个处理器的周期时间相等，得到：

加速比=非流水化CPI/(1+每条指令的流水线停顿周期)

一种简单而重要的情景是所有指令的周期数都相同，必然等于流水级数目（也称为流水线深度）。在这种情况下，非流水化CPI等于流水线的深度，得到：

加速比=流水深度/(1+每条指令的流水线停顿周期)

如果没有流水线停顿，由此公式可以得到一个很直观的结果：流水化可以使性能提高的倍数等于流水线深度。

或者，如果将流水化看作时钟周期时间的改善，那可以假定非流水化处理器的CPI以及流水化处理器的CPI为1。于是得到：

流水化加速比=(非流水化CPI/流水化CPI)x(非流水化时钟周期/流水化时钟周期) = (1/(1+每条指令的流水线停顿周期))x(非流水化时钟周期/流水化时钟周期)

当流水级达到完美平衡，而且没有开销时，流水化处理器的时钟周期小于非流水化处理器的时钟周期，缩小因子等于流水线深度：

流水化时钟周期=非流水化时钟周期/流水线深度

流水线深度=非流水化时钟周期/流水化时钟周期

从而得到以下公式：

流水化加速比=(1/(1+每条指令的流水线停顿周期))x(非流水化时钟周期/流水化时钟周期) = (1/(1+每条指令的流水线停顿周期))x流水线深度

因此，如果没有停顿，则加速比等于流水级数，与我们对理想情况的直观感受一致。

结构冒险

当处理器以流水线方式工作时，指令的重叠执行需要实现功能单元的流水化和资源的复制，以允许在流水线中出现所有可能的指令组合。如果由于资源冲突而不能容许某些指令组合，就说该处理器存在结构冒险

结构冒险最常见于某功能单元未能完全流水化的情况。这时，一系列使用该非流水化单元的指令不能以每时钟周期执行一条指令的速度前进。结构冒险另一常见出现方式是某一资源的复制不足以执行流水线中的所有指令组合。例如，处理器可能仅有一个寄存器堆写端口，但在特定情况下，流水线可能希望在一个时钟周期内执行两个写操作。这就会生成结构冒险。

当指令序列遇到这种冒险时，流水线将会使这些指令中的一个停顿，直到所需单元可用为止。这种停顿会增大CPI值，不再是其通常的理想值1。一些流水化处理器为数据和指令共享单存储器流水线。结果，当指令中包含数据存储器引用时，它会与后面指令的指令引用冲突，如图C-3所示。为避免这一冒险，在发生数据存储器访问时，我们使流水线停顿一个时钟周期。停顿通常被称为流水线气泡，或就称为气泡，因为它会飘浮穿过流水线，占据空间却不执行有用工作。在讨论数据冒险时，将会看到另一种停顿类型。

图C-3 只要发生存储器引用，仅有一个存储器端口的处理器就会生成一次冲突. 在这个示例中，载入指令因为数据访问而使用存储器的同时，指令3希望从存储器中提取一条指令

设计者经常使用仅含有流水级名称的简图来表示停顿行为，如表C-2所示。在表C-2中展示停顿时，指出那些没有执行操作的周期，只是将指令3向右移动（使其执行过程的开始与结束都推后1个周期）。当流水线气泡穿过流水线时，其效果就是占据了该指令时隙的资源。

• 载入指令实际强占了指令提取周期，导致流水线停顿——在4号时钟周期没有启动指令(它通常会启动指令i+3）。因为被提取的指令停顿，所以流水线中位于停顿指令之前的所有其他指令都可以正常进行。停顿周期将继续穿过流水线，所以在8号时钟周期中没有完成指令。有时在绘制这些流水线表时，让流水线占据整个水平行，指令3被移到下一行；无论采用哪种画法，效果都是一样的，因为指令i+3直到5号周期才开始执行。因为以上形式占据的空间较少，所以我们采用了这一形式。注意，本图假定指令i+1和i+2不是存储器引用。

让我们看看载入结构冒险的成本有多高。假定数据引用占总体的40%，流水化处理器的理想CPI为1(忽略结构冒险）。假定与没有冒险的处理器相比，有结构冒险处理器的时钟频率为其1.05 倍。不考虑所有其他性能损失，有结构冒险和无结构冒险相比，哪种流水线更快?快多少?

有几种方法可以求解这一问题。 最简单的一种可能就是计算两种处理器的平均指令时间：

平均指令时间 = CPI x 时钟周期时间

由于没有停顿，所以理想处理器的平均指令时间就是时钟周期时间理想。有结构冒险处理器的平均指令时间为：

平均指令时间=CPIx时钟周期时间 = (1+0.4x1)x(时钟周期时间(理想)/1.05) = 1.3x时钟周期时间(理想)

显然，没有结构冒险的处理器更快一些; 根据平均指令时间的比值，我们可以得出结论，无冒险处理器的速度快1.3倍。

为避免出现这种结构冒险，设计师可以为指令提供独立的存储器访问，既可以将缓存分为独立的指令缓存和数据缓存，也可以使用一组缓冲区来保存指令，这种缓冲区通常称为指令缓冲区。

如果其他因素相同，无结构冒险处理器的CPI总是更低一些。那设计师为什么还会允许结构冒险呢?其主要目的是为了降低单元成本，因为要实现所有功能单元的流水化，或者复制它们，成本都太高昂了。例如，那些在每个周期内支持指令与数据缓存访问的处理器需要有2倍的总存储器带宽，通常要求管脚处也可以承受较高的带宽。

与此类似，要完全实现浮点（FP）乘法器需要耗用大量门电路。如果结构冒险很罕见，那就不值得花费这么大的代价来避免它。

数据冒险

流水化的主要效果是通过重叠指令的执行过程来改变它们的相对执行时间。这种重叠引入了数据与控制冒险。当流水线改变对操作数的读写访问顺序，使该顺序不同于在非流水化处理器上依次执行指令时的顺序，这时可能发生数据冒险。考虑以下指令的流水化执行：

1
2
3
4
5

DADD     R1, R2, R3
DSUB     R4, R1, R5
AND      R6, R1, R7
OR       R8, R1, R9
XOR      R10, R1, R11

AND指令也会受到这种冒险的影响。从图C-4 中可以看出，在5号时钟周期之前，R1的写入操作是不会完成的。因此，在4号时钟周期读取寄存器的AND指令会得到错误结果。

图C-4在后面三条指令中使用DADD指令的结果时，由于要等到这些指令读取寄存器之后才会向其中写入，所以会导致冒险。

XOR指令可以正确执行，因为它的寄存器读取是在6号时钟周期进行的，这时寄存器写入已经完成。OR指令的执行也不会招致冒险，因为我们在该时钟周期的后半部分执行寄存器堆读取，而写入是在前半部分执行的。

下一小节将讨论一种技术，用于消除涉及DSUB和AND指令的冒险停顿。

利用转发技术将收据冒险停顿减至最少

图C-4中提出的问题可以使用一种称为转发（forwarding）的简单硬件技术来解决（这一技术也称为旁路，有时也称为短路）。转发技术的关键是认识到DSUB要等到DADD实际生成结果之后才会真正用到它。DADD 将此结果放在流水线寄存器中，如果可以把它从这里转移到DSUB需要的地方，那就可以避免出现停顿。根据这一观察结果，转发的工作方式如下所述。

1. 来自EX/MEM和MEMWB流水线寄存器的ALU结果总是被反馈回ALU的输入端。
2. 如果转发硬件检测到前一个ALU操作已经对当前AlU操作的源寄存器进行了写入操作，则控制逻辑选择转发结果作为ALU输入，而不是选择从寄存器堆中读取的值。

注意，采用转发技术后，如果DSUB停顿，则DADD将会完成，不会触发旁路。当两条指令之间发生中断时，这一关系同样成立。

如图C4中的示例所示，我们需要转发的结果可能不只来自前一条指令，还可能来自提前两个周期启动的指令。图C-5显示了带有旁通路径的示例，它重点突出了寄存器读取与写入的时机。这一代码序列可以无停顿执行。

图C-5 一组依赖DADD结果的指令使用转发路径来避免数据冒险。DSUB 和AND指令的输入是从流水线寄存器转发到第一个ALU输入。0R接收的结果是通过寄存器堆转发而来的，这一点很容易实现，只需要在周期的后半部分读取寄存器、在前半部分写入寄存器就能轻松完成，如寄存器上的虚线所示。注意，转发结果可以到达任一ALU输入；事实上，ALU输入既可以使用来自相同流水线寄存器的转发输入，也可以使用来自不同流水线寄存器的转发输入。例如，当AND指令为AND R6，R1，R4时就会发生这种情况

可以将转发技术加以推广，将结果直接传送给需要它的功能单元：可以将一个功能单元输出到寄存器中的结果直接转发到另一个功能单元的输入，而不仅限于同一单元的输出与输入之间。例如以下序列：

1
2
3

DADD      R1, R2, R3
LD        R4,0(R1)
SD        R4,12(R1)

图C-6 在MEM期间执行的存储操作需要转发操作数。载入结果由存储器输出转发到要存储的存储器输入端。此外，ALU指令被转发到ALU输入，供载入和存储指令进行地址计算（这与转发到另一个ALU操作没有区别）。如果存储操作依赖与其直接相邻的前一个ALU操作（图中未示出），则需要转发其结果，以防止出现停顿

需要停顿的数据冒险

遗憾的是，并非所有潜在数据冒险都可以通过旁路方式处理。考虑以下指令序列：

1
2
3
4

LD      R1, 0(R2)
DSUB    R4,R1,R5
AND     R6,R1,R7
OR      R8,R1,R9

载入指令有一种不能单由转发来消除的延迟。而是需要增加一种称为流水线互锁，以保持正确的执行模式。一般情况下， 流水线互锁会检测冒险，并在该冒险被清除之前使流水线停顿。在这种情况下，互锁使流水线停顿，让希望使用某一数据的指令等待，直到源指令生成该数据为止。这种流水线互锁引入一次停顿或气泡，就像应对结构冒险时所做的一样。停顿指令的CPI会增加，延长数目等于停顿的长度（在本例中为1个时钟周期）。

图C-7 载入指令可以将其结果旁路至AND和OR指令，但不能旁路至DSUB，因为这将意味着在“负向时间”上转发结果

表C-3使用流水级名称显示了停顿前后的流水线。因为停顿会导致从DSUB开始的指令在时间上向后移动1个周期，转发给AND指令的数据现在是通过寄存器堆到达的，而对于OR指令根本不需要转发。由于插入了气泡，需要增加一个周期才能完成这一序列。4号时钟周期内没有启动指令（在6号周期没有指令完成）。

分支冒险

对于我们的MIPS流水线，控制冒险造成的性能损失可能比数据冒险还要大。在执行分支时，修改后的程序计数器的值可能等于（也可能不等于）当前值加4。回想一下，如果分支将程序计数器改为其目标地址，它就是选中分支；否则就是未选中分支。如果指令i为选中分支，通常会等到ID末尾，完成地址计算和对比之后才会改变程序计数器。表C-4表明，处理分支的最简单方法是：一旦在ID期间（此时对指令进行译码）检测到分支，就对该分支之后的指令重新取值。第一个IF周期基本上是一次停顿，因为它从来不会执行有用工作。读者可能已经注意到，如果分支未被选中，由于事实上已经正确地提取了指令，所以IF级的重复是不必要的。表C-4分支在五级流水线中导致一个周期的停顿分支指令

• 分支指令之后的指令已被提取，但随后被忽略，在已经知道分支目标之后，重新开始提取操作。如果分支未被选中，则分支后续指令的第二个IF就有些多余了，这一点可能比较明显。

如果每个分支产生一个停顿周期, 将会使性能损失10%~30%，具体取决于分支频率，所以我们将研究一些用于应对这一损失的技术。

降低流水线分支代价

有许多方法可以处理由分支延迟导致的流水线停顿，我们在这一小节讨论4种简单的编译时机制。在这4种机制中，分支的操作是静态的，也就是说，在整个执行过程中，它们对每条分支来说都是固定的。软件可以尝试利用硬件机制和分支行为方面的知识将分支代价降至最低。

处理分支的最简单机制是冻结或冲刷流水线，保留或删除分支之后的所有指令，直到知道分支目标为止。这种解决方案的吸引力主要在于其软硬件都很简单。这也是表C-4所示流水线中较早使用的解决方案。在这种情况下，分支代价是固定的，不能通过软件来缩减。一种性能更高但仅略微复杂一点的机制是将每个分支都看作未选中分支，允许硬件继续执行，就好像该分支未被执行一样。这时必须非常小心，在确切知道分支输入之前，不要改变处理器状态。这一机制的复杂性在于必须要知道处理器状态可能何时被指令改变，以及如何“撤销”这种改变。

在简单的五级流水线中，这种预测未选中机制的实现方式是继续提取指令，就好像分支指令是一条正常指令一样。流水线看起来好像没有什么异常发生。但是，如果分支被选中，就需要将已提取的指令转为空操作，重新开始在目标地址位提取指令。表C-5显示了这两种情况。一种替代机制是将所有分支都看作选中分支。只要对分支指令进行了译码并计算了目标地址，我们就假定该分支将被选中，开始在目标位置提取和执行。因为在我们的五级流水线中，不可能在知道分支输出结果之前知道目标地址，所以这种方法对于这一流水线没有好处。在一些处理器中，特别是那些拥有隐性设定条件代码或者拥有更强大分支条件的处理器中，是可以在分支输出之前知道分支目标的，这时，预测选中机制可能就有意义了。

无论是在预测选中还是预测未选中机制中，编译器总是可以通过代码组织方式，使最频繁的路径与硬件选择相匹配，从而提高性能。我们的第四种机制为编译器提高性能提供了更多的机会。

• 当分支未被选中时（在ID期间确定），我们提取未选中指令，继续进行。当在ID期间确定选中该分支时，则在分支目标处重新开始提取。这将导致该分支后面的所有指令停顿1个时钟周期。在某些处理器中使用的第四种机制称为延迟分支。这一技术在早期RISC处理器中的使用非常广泛，在五级流水线中的工作状态相当好。在延迟分支中，带有一个分支延迟的执行周期为：

• 分支指令
• 依序后续指令
• 选中时的分支目标

依序后续指令位于分支延迟时隙中。无论该分支是否被选中，这一指令都会执行。表C-6中给出具有分支延迟的五级流水线的流水线行为特性。尽管分支延迟可能长于一个1周期，但在实际中，几乎所有具有延迟分支的处理器都只有单个指令延迟；如果流水线的潜在分支代价更长，则使用其他技术。

• 延迟时隙中的指令（对于MIPS，只有一个延迟时隙）被执行。如果分支未被选中，则继续执行分支延迟指令之后的指令；如果分支被选中，则继续在分支目标处执行。当分支延迟时隙中的指令也是分支时，其含义有些模糊：如果该分支未被选中，延迟分支时隙中的分支应当怎么办呢?由于这一混淆，采用延迟分支的体系结构经常禁止在延迟时隙中放入分支。

编译器的任务是让后续指令有效并可用。因此使用了多种优化方式。图C-8给出了三种可以调度分支延迟的方式。

图C-8 分支延迟时隙的调度。每一对中的上框显示调度之前的代码；下框表示调度后的代码。在（a）中，延迟时隙内载入的是分支之前的一条不相关指令。这是最佳选择。策略（b）与（c）在策略（a）不可能实现时使用。在（b）和（c）的序列中，由于分支条件中使用了R1，所有不能将DADD指令移到分支之后（它的目的地是R1 ）。在（b）中，分支延迟时隙中填充了分支的目标指令；这时一般需要复制目标指令，因为其他路径也可能会到达这一目标指令。当分支的选中机率很高时（比如循环分支）优选策略（b）。最后，如（c）中所示，可以用未被选中的指令填充延迟时隙。为使这一优化方法能够对（b）和（c）有效，当分支进入非预测方向时，必须可以执行经过移动的指令。这里所说的“可以”是指浪费了工作量，但程序仍能正确执行。例如，当分支进入非预测方向时，R7成为一个未被用到的临时寄存器，那（c）策略就属于这一情景

延迟分支调度的局限性源于: （1）对于可排在延迟时隙中的指令有限制；（2）我们在编译时预测一个分支是否可能被选中的能力有限。为了提高编译器填充分支延迟时隙的能力，大多数具有条件分支的处理器都引入了一种取消或废除分支。在取消分支中，指令包含了预测分支的方向。当分支的行为与预期一致时，分支延迟时隙中的指令就像普通的延迟分支一样执行。 当分支预测错误时，分支延迟时隙中的指令转为空操作。

分支机制的性能

这些机制的各自实际性能怎么样呢?假定理想CPI为1，考虑分支代价的实际流水线加速比为：

流水线加速比 = 流水线深度 / (1+分支导致的流水线停顿周期)

由于:

分支导致的流水线停顿周期 = 分支频率 x 分支代价

得到:

流水线加速比 = 流水线深度 / (1+分支频率x分支代价)

分支频率和分支代价可能都存在因为无条件分支和有条件分支导致的分量。但是，由于后者出现得更为频繁，所以它们起主导作用。

对于一个更深的流水线，比如在MIPS R4000中，在知道分支目标地址之前至少需要三个流水级，在计算分支条件之前需要增加一个周期，这里假定条件比较时寄存器中没有停顿。三级延迟导致表C-7中所列三种最简单预测机制的分支代价。假定有如下频率，计算因分支使该流水线的CPI增加了多少。

• 无条件分支：4%
• 有条件分支、未选中：6%
• 条件分支、选中：10%

表C-7三种最简单预测机制对于一个较深流水线的分支代价

将无条件、有条件未选中和有条件选中分支的相对频率乘以各自的代价，就可以求出CPI。结果如表C-8所示。

这些机制之间的差别大体随这一较长的延迟而增大。如果基础CPI为1，分支是唯一的停顿源，则理想流水线的速度是使用停顿流水线机制的流水线的1.56倍。 预测未选中机制在相同假定条件下优于停顿流水线机制，为其1.13 倍。

通过预测降低分支成本

当流水线变得越来越深，而且分支的潜在代价增加时，仅使用延迟分支及类似机制就不够了。这时需要寻求一种更积极的方式来预测分支。这些机制分为两类：依赖编译时可用信息的低成本静态机制；根据程序特性对分支进行动态预测的策略。下面将讨论这两种方法。

静态分支预测

改进编译时分支预测的一种重要方式是利用先前运行过程收集的一览数据。之所以值得这样做，是因为人们观测到分支的行为特性经常是双峰分布的；也就是说，各个分支经常是严重偏向于选中或未选中两种情景之一。图C-9显示了使用这一策略成功地进行了分支预测。使用相同输入数据来运行程序，以收集一览数据；其他研究表明，如果改变输入，使不同运行的一览数据发生变化，只会使基于一览数据的预测准确度有微小变化。

任意分支预测机制的有效性都同时取决于机制的精度和条件分支的频率，在SPEC中，其变化范围为3%~24%。 整数程序的错误预测率较高，此类程序的分支频率通常较高，这一事实是静态分支预测的主要限制。在下一节中，我们考虑动态分支预测器，最新的处理器都采用这种机制。

图C-9 对于一种基于一览数据的预测器，SPEC92的错误预测率变化幅度很大，但浮点程序通常优于整型程序，前者的平均错误预测率为9%，标准偏差为4%，后者的平均错误预测率为15%，标准偏差为5%。实际性能取决于预测精度和分支频率，其变化范围为3%~24%

动态分支预测和分支预测缓冲区

最简单的动态分支预测机制是分支预测缓冲区或分支历史表。分支预测缓冲区是一个小型存储器，根据分支指令地址的低位部分进行索引。这个存储器中包含一个位（bit），表明该分支最近是否曾被选中。这一机制是最简单的缓冲区形式；它没有标志，仅当分支延迟过长，超过可能目标PC计算所需要的时间时，用于缩短分支延迟。

采用这样一种缓冲区时，我们事实上并不知道预测是否正确——它也可能是由另外一个具有相同低位地址的分支放入的。这个预测就是一种提示，我们假定它是正确的，并开始在预测方向上开始提取。如果这一提示最终是错误的，那将预测位反转后存回。这个缓冲区实际上就是一个缓存，对其所有访问都会命中，而且在后面可以看到，缓冲区的性能取决于两点：对所关注分支的预测频繁程度，该预测在匹配时的准确度。在分析性能之前，对分支预测机制的精度进行一点微小而重要的提升是很有用的。

这种简单的1位预测机制在性能上有一处短板: 即使某个分支几乎总是被选中，在其未被选中时，我们也可能会得到两次错误预测，而不是一次， 因为错误预测会导致该预测位反转。

为了弥补这一弱点，经常使用2位预测机制。在两位预测机制中，预测必须错过两次之后才会进行修改。图C-10给出了2位预测机制的有限状态处理器。

分支预测缓冲可以实现为一个小的特殊“缓存”，在IF流水线中使用指令地址进行访问，或者实现为一对比特，附加到指令缓存中的每个块，并随指令一起提取。如果指令的译码结果为一个分支，并且该分支被预测为选中，则在知道PC之后立即从目标位置开始提取。否则，继续进行顺序提取和执行。如图C-10所示，如果预测结果错误，将改变预测位。

图C-10 2位预测机制中的状态。许多分支被选中和不被选中的概率并非均等，而是严重偏向其中一种状态，对于此类分支，2位预测器的错误预测率经常低于1位预测器。在这种预测器中，使用2个数位对系统中的4种状态进行编码。这一2位机制实际上是一种更具一般性的机制的具体化，这种通用机制对于预测缓冲区中的每一项都有n位饱和计数器。对于一个n位计数器，其取值介于2至2^n-1之间：当计数器大于或等于其最大值（2^n-1）的一半时，分支被预测为选中；否则，预测其未选中。对n位预测器的研究已经证明，2位预测器的效果几乎与n位预测器相同，所以大多数系统都采用2位分支预测器，而不是更具一般性的n位预测器

在实际应用程序中，如果使用每项两位的分支预测缓冲区，可以预测得到什么样的准确度?图C-11显示，对于SPEC89基准测试，一个拥有4096项的分支预测缓冲区将得到超过99%~82%的预测准确度，或者说错误预测率为1%~18%。根据2005年的标准，一个4K项的缓冲区（比如得出上述结果的缓冲区）算是很小了，较大的缓冲区可以得到更好点的结果。

由于我们尝试开发更多的IP，所以分支预测的准确度变得非常关键。在图C-11中可以看出，整数程序的预测器精度低于循环密集的科学程序（前者的分支频率通常也更高一些）。我们可以采用两种方式来解决这一问题: 增大缓冲区的大小，增加每种预测机制的准确度。但如图C-12所示，一个拥有4000项的缓冲区，其性能大体与无限缓冲区相当，至少对于SPEC这样的基准测试如此。图C-12中的数据清楚地表明缓冲区的命中率并非主要限制因素。前面曾经提到，仅提高每个预测器的位数而不改变预测器结构，其影响也是微乎其微的。因此，我们需要研究一下如何提高每种预测器的精度。

图C-11 对于SPEC89基准测试，4096 项2位预测缓冲区的预测准确度。整数基准测试（gcc、espresso、eqntott和li ）的预测错误率大体高于浮点程序，前者的均值为11%，后者为4%。忽略浮点内核（nasa7、matrix300和tomcatv）仍然会使浮点基准测试的准确度高于整数基准测试。收集这些数据及本节其余数据的分支预测研究采用IBM Power体系结构及针对该系统的优化代码执行。

图C-12 对于SPEC89基准测试，4096项2位预测缓冲区与无限缓冲区的预测准确度对比。尽管这些数据是针对一部分 SPEC基准测试的较早版本收集的，但较新版本的结果也大体相当，只是可能需要8000项来匹配一个无限2位预测器

如何实现流水化

在开始介绍基本流水化之前，需要回顾一下MIPS非流水版本的一种简单实现。

MIPS的简单实现

本节将继续C.1节的风格，首先给出一种简单的非流水化实现，然后是流水化实现。但我们这一次的例子是专门针对MIPS体系结构的。
在这一小节，我们主要关注MIPS中一部分整数运算的流水线，其中包括载入-存储字、等于零时分支和整数ALU运算。在本附录的后半部分将整合这些基础浮点操作。尽管我们仅讨论MIPS的一个子集，但这些基本原则可以扩展到对所有指令的处理。

每种MIPS指令都可以在最多5个时钟周期中实现。这5个时钟周期分述如下。

（1）指令提取周期（IF）

1
2

IR <- Mem[PC];
NPC ← PC+4;

（2）指令译码/寄存器提取周期（ID ）。

1
2
3

A←Regs[rs];
B←Regs[rt];
Imm←IR的符号扩展立即数字段;

指令译码与寄存器读取是并行完成的，这一点之所以成为可能，是因为在MIPS格式中，这些字段放在固定位置。因为在所有MIPS格式中，指令的立即数部分都位于同一位置，所以在这一周期还会计算符号扩展立即数，以备在下一周期使用。

（3）执行/实际地址周期（EX）

ALU对前一周期准备的操作数进行操作，根据MIPS指令类型执行以下4种功能之一。

• 存储器引用:
  • ALUOutput ← A + Imm;
  • 操作——ALU将操作数相加，得到实际地址，并将结果放在寄存器ALUOutput中。
• 寄存器-寄存器ALU指令:
  • ALUOutput ← A func B;
  • 操作——ALU 对寄存器A和寄存器B中的取值执行由功能代码指定的操作。结果放在临时寄存器ALUOutput中。
• 寄存器立即数ALU指令:
  • ALUOutput ← A op Imm;
  • 操作——ALU 对寄存器A和寄存器Imm中的值执行由操作代码指定的操作。结果放在临时寄存器ALUOutput中。
• 分支:
  • ALUOutput ← NPC + (Imm << 2）;
  • Cond ← (A==0)
  • 操作——ALU将NPC加到Imm中的符号扩展立即数，将该立即数左移2位，得到一个字偏移量，以计算分支目标的地址。检查已经在上一周期读取的寄存器A，以确保该分支是否被选中。由于我们仅考虑分支的一种形式（BEQZ）,所以是与0进行对比。注意，BEQZ实际上是一个伪指令，它会转换为一个以R0为操作数的BEQ。为简单起见，我们这里仅考虑这一种分支形式。

MIPS的载入-存储体系结构意味着实际地址与执行周期可以合并到一个时钟周期中，因为此时没有指令需要同时计算数据地址和指令目标地址，并对数据执行操作。各种形式的跳转指令未包含在上述整数指令中，它们与分支相类似。

（4）存储器访问/分支完成计算（MEM ）。

对所有指令更新PC: PC←NPC;

• 存储器引用:
  • LMD ← Mem[ALUOutput] 或 Mem[ALUQutput]←B;
  • 操作——在需要时访问存储器。 如果指令为载入指令，则从存储器返回数据，将其放入LMD（载入存储器数据）寄存器中；如果是存储指令，则将来自B寄存器的数据写入存储器。无论是哪种情况，所使用的地址都是在上一周期计算得出并放在寄存器ALUOutput中的地址。
• 分支:
  • if (cond) PC ← ALU0utput
  • 操作——如果该指令为分支指令，则用寄存器ALUOutput中的分支目标地址代替PC。

（5）写回周期（WB ）。

• 寄存器-寄存器ALU指令:
  • Regs[rd]←ALU0utput;
• 寄存器立即数ALU指令:
  • Regs[rt]←ALUOutput;
• 载入指令:
  • Regs[rt]←LMD;
  • 操作——无论结果来自存储器系统（在LMD中），还是ALU（在ALUOutput中），都将其写到寄存器堆中，寄存器目标字段也在两个位置之一（rd或rt）之一，具体取决于实际操作码。

图C-13显示了一条指令是如何流经数据路径的。在每个时钟周期结束时,在该时钟周期计算并会在后面时钟周期用到的所有值（无论是供本条指令使用，还是供下一条指令使用）都被写入存储设备中，可能是存储器、通用寄存器、PC或临时寄存器（即，LMD、lmm、A、B、IR、NPC、ALUOutput或Cond ）。临时寄存器在一个指令的时钟周期之间保存值，而其他存储元件则是状态的可视部分，在连续指令之间保存值。

尽管今天的所有处理器都是流水化的，但这种多周期实现方式合理地近似呈现了早些时候是如何实现大多数处理器的。可以使用一种简单的有限状态机来实现一种遵循上述5周期结构的控制。对于更复杂的处理器，可以使用微代码控制。在任何一种情况下，类似上述内容的指令序列决定着控制结构。

在这种多周期实现中可以消除一些硬件冗余。 例如，有两个ALU: 一个用于使PC递增，一个用于实际地址和ALU计算。由于不会在同一时钟周期用到它们，所以可以通过添加多工器和共享同一ALU来合并它们。同样，由于数据和指令访问发生在不同时钟周期内，所以指令和数据可以存储在相同存储器中。

我们没有优化这一简单实现方式，而是保持图C-13所示设计方式，为流水化实现提供了更好的基础。

图C-13 MIPS 数据路径的实现允许每条指令在4或5个时钟周期内执行。尽管PC显示在指令提取使用的数据路径部分、寄存器显示在指令译码/寄存器提取使用的数据路径部分，实际上这些功能单元都是由一条指令读取和写入的。尽管这些功能单元显示在对其进行读取的周期内，实际上，PC是在存储器访问时钟周期内写入，寄存器是在写回时钟周期内写入的。在这两种情况下，在后续流水级中的写入是由多工器输出指示（在存储器访问或写回中），它将一个取值带回PC或寄存器。流水线的大多数复杂性是由这些反向流动信号引入的，因为它们表明存在冒险的可能

作为本节所讨论多周期设计的一种替代方式，我们也可以将CPU实现为每条指令占用1个长时钟周期。在这种情况下，由于一条指令之内的时钟周期之间不需要任何通信，所以将会删除临时寄存器。每条指令都在1个长时钟周期内执行，在该时钟周期结束时将结果写入数据存储器、寄存器或PC。此类处理器的CPI为1。不过，这时的时钟周期大约等于多周期处理器时钟周期的5倍，这是因为所有指令都需要遍历全部功能单元。设计人员从来不会使用这种单周期实现方式，其原因有两个。第一，单周期实现对于大多数CPU的效率极低，因为对于不同指令，它们的任务量会有合理的变动，从而时钟周期时间也会变动。第二，单周期实现需要重复功能单元，而在多周期实现中，这些功能单元是可以共享的。不过，这种单周期数据路径可以让我们说明流水化是如何从时钟周期时间的角度（而非CPI的角度）来为处理器提供改进的。

MIPS基本流水线

和以前一样，只需要在每个时钟周期启动一个新指令，几乎不需要什么改变就可以对图C-13的数据路径实现流水线。因为每个流水级在每个时钟周期都是活动状态，所以流水级中的所有操作都必须在1个时钟周期内完成，任何操作组合都必须能够立即发生。此外，数据路径的流水化要求必须将流水级之间传递的数值放在寄存器中。图C-14 显示的MIPS流水线中包含了每个流水级之间的适当寄存器，称为流水线寄存器或流水线锁存器。用这些寄存器相联的流水线名称对其进行标记。图C-14的绘制方式清楚地显示了各级之间通过流水线寄存器的连接。

用于在一条指令的时钟周期之间保存临时值的所有寄存器都包含在这些流水线寄存器中。指令寄存器（IR）是IF/ID寄存器的一部分，当它们用于提供寄存器名称时，对其字段进行标记。这些流水线寄存器用于从一个流水级向下一个流水级传送数据和控制。在后续流水级上需要的所有值都必须放在这样一个寄存器中，并从一个流水线寄存器中复制到下一个寄存器，直到不再需要这些值为止。如果我们尝试仅在早期未流水化数据路径中使用临时寄存器，就有可能在完成所有应用之前覆盖这些值。例如，寄存器操作数的字段，用于在载入或ALU操作中执行写入操作，这一字段是从MEM/WB流水线寄存器而非IF/ID寄存器中提供的。这是因为我们希望一个载入或ALU操作写入该操作指定的寄存器，而不是该指令当前从IF传送到ID的寄存器字段!这一目标寄存器字段就是从一个流水线寄存器复制到下一个寄存器，直到在WB级用到它为止。

图C-14 通过增加一组寄存器实现流水化的数据路径，每对流水线之间一个寄存器。寄存器用于从一个流水级向下一个流水级传送值和控制信息。我们也可以将PC看作一个流水线寄存器，它位于流水线的IF级之前，指向每个流水级的一个流水线寄存器。回想一下，PC是一个边缘触发寄存器，在时钟周期结束时对其进行写入；因此，在写入PC时不存在争用条件。PC的多工器已被移动，恰好在一个流水级（IF）中写入PC。如果我们没有移动它，那在发生分支时可能会出现冲突，因为两条指令都会尝试将不同值写到PC中。大多数数据路径是由左向右流动，即从较早时间移向较晚时间。从右向左流动的数据（携带着分支的写回信息和PC信息）增加了流水线的复杂性

任何一条指令在某一时刻恰好在一个流水级中处于活动状态；任何以指令名义执行的操作都发生在一对流水线寄存器之间。因此，我们还可以通过以下方式来研究流水线的行为：查看在不同指令类型下，各流水级上必须执行什么操作。表C-9展示了这一观点。流水线寄存器的字段命名显示了数据在流水级之间的流动。注意，前两级的操作与当前指令类型无关。由于要等到ID级结束时才会对指令进行译码，所以前两级的操作必须与当前指令无关。IF行为取决于EXMEM中的指令是否为选中分支。如果是，则会在IF结束时将EXMEM中分支指令的分支目标地址写入PC中；如果不是，则写回递增后的PC。寄存器源操作数的固定位置编码对于在ID期间提取寄存器是至关重要的。

• 在IF中，除了提取指令和计算新PC之外，我们还将递增后的PC存储到PC和流水线寄存器（NPC）中，供以后计算分支目标地址时使用。这个结构与图C-14中的组织方式相同，在正使用两个来源之一更新PC。在D中，我们提取寄存器，对IR（立即数字段）的低16位进行符号扩展，并沿R和NPC进行传送。在EX期间执行ALU运算或地址计算，沿IR和B寄存器进行传送（如果该指令为存储指令）。如果该指令为选中分支，我们还将cond的值设置为1。在MEM阶段，我们循环使用存储器，必要时写PC，并传送在最后流水级中使用的值。最后，在WB期间用ALU输出值或载入值来更新寄存器字段。为简单起见，我们总是将整个R从一级传送到下一级，实际上，在一条指令沿流水线流动时，对IR的需要越来越少。

为了控制这一简单流水线，我们只需要决定如何设定图C-14 数据路径中4个多工器的控制方式。ALU级的2个多工器根据指令类型设定，由ID/EX寄存器的IR字段规定。上面的ALU输入多工器根据该指令是否为分支来进行设定，下面的多工器根据该指令是寄存器-寄存器ALU操作还是任意其他类型的操作来设定。If级中的多工器选择是使用递增PC 的值，还是EX/MEM.ALUOutput（分支目标）的值来写入PC。这个多工器由EX/MEM.cond字段控制。第
四个多工器由WB级的指令是载入指令还是ALU指令来控制。除了这4个多工器之外，还需要另外1个多工器，虽然未在图C-14中画出，但只要看一下ALU操作的WB级就可以清楚地看出是存在该选择器的。根据指令类型（是寄存器寄存器ALU,还是ALU立即数或载入），目标寄存器字段为两个不同位置中的一个。因此，我们需要一个多工器来选择MEM/WB寄存器中IR的正确部分，以指定寄存器目标字段，假定该指令写入一个寄存器。

实现MIPS流水线的控制

将一条指令从指令译码级（I）移入此流水线执行级（EX）的过程通常称为指令发射，已经执行这一步骤的指令称为已发射。对于MIPS整数流水线，所有数据冒险都可以在该流水线的ID阶段进行检查。如果存在数据冒险，该指令将在被发射之前停顿。与此类似，我们可以确定在ID期间需要哪种转发，并设定适当的控制。如果在流水线早期检查互锁，除非整个处理器停顿，否则硬件从来不需要挂起一条已经改变处理器状态的指令，从而降低了硬件的复杂性。

或者，我们可以在使用操作数的一个时钟周期之始（对于此流水线来说，为EX和MEM）检查冒险或转发。为了说明这两种方法之间的区别，我们将展示如何通过在ID中进行检查来消除因为载入指令所导致的写后读（RAW）冒险互锁（称为载入互锁），并说明如何实现指向ALU输入的转发路径。表C-10列出了我们必须处理的各种环境。

• 这个表显示，对于跟在写指令后面的两条指令，只需要对其目标和源进行对比。在发生停顿时，一旦继续执行后，流水线相关性与第三种情况类似。当然，涉及R0的冒险是可以忽略的，这是因为寄存器中总是包含零，而且上述测试经扩展后可以完成这一任务。

接下来实现载入互锁。如果存在一个因为载入指令导致的RAW冒险，当需要该载入数据的指令存位于ID级时，该载入数据将位于EX级。因此，我们可以用一个很小的表来描述所有可能存在的情景，可以直接将其转换为实现方式。表C-11显示了当使用载入结果的指令位于ID级时，检测到负载互锁的逻辑。

• 表中第1行和第2行测试载入目标寄存器是否为ID中寄存器——寄存器操作的源寄存器之一。表中第3行判断载入目标寄存器是否为载入或存储有限地址、ALU立即数或分支测试的源。请记住，IF/ID 寄存器保存着ID中指令的状态，它可能会用到载入结果，而ID/EX保存着EX中指令的状态，它是载入指令。

一旦检测到冒险，控制单元必须插入流水线停顿，并防止IF和ID级中的指令继续前进。前面曾经看到，所以控制信息都承载于流水线寄存器中。（仅承载指令就足够了，因为所有控制都是由其派生而来的。）因此，在检测冒险时，只需要将ID/EX流水线寄存器的控制部分改为全0，它正好是一个空操作（一个不做任何事情的指令，比如DADD R0, R0, R0）。此外，我们只篅循环使用IF/ID 寄存器中的内容，以保存被停顿的指令。在具有更复杂冒险的流水线中，这些思想同样适用：对比一组流水线寄存器，并转换为空操作，以防止错误执行。

转发逻辑的实现尽管需要考虑更多种情况，但大体类似。要实现转发逻辑，关键是要注意到流水线寄存器中既包含了要转发的数据，也包含了源、目标寄存器字段。所有转发在逻辑上都是从ALU或数据存储器的输出到ALU输入、数据存储器输入或零检测单元。因此，我们可以对比EXMEM和MEMWB级中所包含IR的目标寄存器与ID/EX和EXMEM寄存器中所包含IR的源寄存器，以此来实现转发。表C-12显示了这些对比，以及当转发结果的目的地是EX中当前指令的ALU输入时，可能执行的转发操作。

• 为了判断是否应当发生转发操作，一共需要10次不同比较。顶部和底部的ALU输入分别指代与第一、第二ALU源操作数相对应的输入，如图C-13及图C15中所示。请记住，EX中目标指令的流水线销存器是ID/EX，而源值来自EX/MEM或MEM/WB的ALUOutput部分，或者MEMWB的LMD部分。有一个复杂问题未能通过这一逻辑解决：处理多条向相同寄存器进行写入的指令。例如，在代码序列DADD R1, R2, R3; DADDI: R1, R1, #2; DSUB R4, R3, R1期间，该逻辑必须确保DSUB指令使用的是DADDI指令的教据，而不是DADD指令的结果。为了处理这一情景，可以扩展上述逻辑：仅在未对相同输入转发来自EXMEM的结果时，才检测来自MEMWB的转发。由于DADDI结果将位于EX/MEM中，所以将转发该结果，而不是MEMWB中的DADD结果。

除了在需要启用转发路径时必须确定的比较器和组合逻辑之外，还必须扩大ALU输入端的多工器，并添加一些连接,这些连接源于转发结果所用的流水线寄存器。图C-15给出了流水化数据路径的相关段，其中添加了所需要的多工器和连接。

图C-15 向ALU转发结果需要在每个ALU多工器上另外增加三个输入，增加三条指向这些新输入的路径。这些路径对应于以下三者的一个旁路: （1）EX结束时的ALU输出；（2）MEM级结束时的ALU输出；（3）MEM级结束时中的存储器输出

对于MIPS，冒险检测和转发硬件是相当简单的；我们将会看到，当为处理浮点数而对这一流水线进行扩展时，事情多少会变得复杂一些。在此之前，需要处理分支。

处理流水线中的分支

在MIPS中，分支（BEQ和BNE）需要检测一个寄存器，看其是否等于另一个寄存器（该寄存器可能为R0）。如果仅考虑BEQZ和BNEZ的情景（它们需要零检测），那有可能通过将零检测移到周期内部，在ID周期结束时完成此判断。为了充分利用尽早判断出该分支是否命中的优势，都必须尽早计算PC（无论命中还是未命中）。在ID期间计算分支目标地址需要增加一个加法器，因为前面一直用于实现此功能的主ALU在EX之前是不可用的。图C-16给出了修订后的流水化数据路径。通过增加独立的加法器，并在ID期间作出分支判断，分支仅需要停顿1个时钟周期。尽管这样将分支延迟缩减为1个周期，但这意味着如果一个 ALU指令后面跟有一个依赖该指令结果的分支，那就会招致数据冒险停顿。表C-13显示了表C-9中修订后的流水线表的分支部分。

在一些处理器中，分支冒险的代价（以时钟周期为单位）比我们这里的例子中更昂贵，因为评估分支条件和计算目的地的时间可能更长一些。例如，拥有独立译码和寄存器提取级的处理器可能存在分支延迟（控制冒险的长度），其长度至少为1个时钟周期。除非经过处理，否则分支延迟会转变为分支代价。许多实现更复杂指令集的较旧CPU，其分支延迟为4个时钟周期，甚至更长一些，而大型深度流水化处理器的分支代价经常为6或7个时钟周期。一般来说，流水线越深，以时钟周期度量的分支代价就越糟。当然，较长分支代价的相对性能性能影响取决于处理器的总CPI。低CPI的处理器可以承受更昂贵的分支，这是因为分支导致处理器性能下降的百分比较低。

图C-16 将零检测和分支目标计算移到流水线的ID级中，可以缩减因为分支冒险导致的停顿。注意，我们已经进行了两处重要改变，每个改变消除了分支指令的三周期停顿之一。第一处变化是将分支目标地址计算和分支条件判断移到ID周期。第二处变化是在IF阶段写入指令的PC，或者使用在ID阶段计算的分支目标地址，或者使用在IF期间计算的递增PC。在对比中，图C-14从EXMEM寄存器中获取分支目标地址，并在MEM时钟周期内写入结果。在图C-14中曾经提到，可以将PC看作流水线寄存器（例如，作为ID/IF的一部分），会在每个IF周期结束时向其中写入下一条指令的地址

• 它使用一个独立的加法器（和图C-16一样），在ID期间计算分支目标地址。新操作或发生变化的操作以黑体标出。由于分支目标地址加法是在ID期间发生的，所以针对所有指令都会经过这一步骤；分支条件（Regs[IF/ID. IR6..10] op 0）也对所有指令有效。是选择顺序PC还是分支目标PC，仍然是在IF期间决定的，但它现在仅使用来自ID级的取值，这些值与上一条指令设定的值相对应。这一改变使分支代价降低两个周期，一个周期是因为提前计算分支目标和条件，一个周期是因为在同一时钟周期内控制PC选择，而没有推至下一周期。由于cond的值被设置为0，所以除非ID中的指令为选中分支，则该处理器必须在ID结束之前对指令进行译码。因为该分支在ID结束时完成，所以分支指令没有用到EX、MEM和WB级。对于偏移量长于分支的跳转，还会进一步增加复杂性。我们可以增加一个加法器，将IR中低26位左移2位后的值与PC相加，以应对上述复杂性。

妨碍流水线实现的难题

处理异常

异常情景在流水化CPU中更难处理：由于指令的重叠，更难以判断一条指令是否能安全比改变CPU的状态。在流水化CPU中，指令是一段一段地执行， 在几个时钟周期内不会完成。不幸的是，流水线中的其他指令可能会引发一些异常，强制CPU在流水线中的指令尚未完成中止执行。

异常的类型与需求

对于一些改变指令正常执行顺序的异常情景，在不同CPU中会采用不同的术语来进行指述。人们会使用中断、错误和异常等词，但具体用法并不一致。我们用异常一词来涵盖包括下列内容的所有此类机制:

• I/O设备需求
• 从用户程序调用操作系统服务
• 跟踪指令执行
• 断点（程序员请求的中断）
• 整数算术溢出
• 浮点算术异常
• 页面错误（不在主存储器中）
• （在需要对齐时）存储器访问未对齐
• 违反存储器保护规则
• 使用未定义或未实现的指令
• 硬件故障
• 电源故障

当我们希望引用这些异常中的某一具体类别时，将使用一个较长的名称，比如I/O中断、浮点异常或页面错误。表C-14显示了上述常见异常事件的各种不同名称。

• IBM 360和80x86上的每个事件都称为中断，而680x0中的每个事件称为异常。VAX将事件划分为中断或异常。在VAX中断中使用了设备、软件和紧急等修饰词语，而VAX异常则细分为故障、陷阱和中止。

尽管我们使用异常一词来涵盖所有这些事件，但各种事件都有自己的重要特性，决定了硬件中需要采取什么操作。关于异常的需求，可以从五个半独立的方面进行描述。

1. 同步与异步——如果每次以相同数据和存储器分配执行程序时，事件都在同一位置发生，那事件就是同步的。由于硬件故障等异常，可能会由CPU和存储器外部的设备导致异步事件。异步事件通常可以在完成当前指令后处理，使其处理变得更容易一些。
2. 用户请求与强制——如果用户任务直接请求某一事件，那它就是用户请求事件。在某种意义上，用户请求的异常不是真正的异常，因为它们是可预测的。但是，由于对这些用户请求事件使用了用于存储和恢复状态的相同机制，所以也将它们看作异常。因为对于触发这一异常的指令来说，其唯一功能就是引发该异常，所以用户请求异常总是可以在完成该指令之后加以处理。强制异常是由某一不受用户程序控制的硬件事件导致的。强制异常不可预测，所以更难以实现。
3. 用户可屏蔽与用户不可屏蔽——如果一个事件可以借由用户任务来屏蔽或禁用，那它就是用户可屏蔽的。这一屏蔽只是控制硬件是否对异常进行回应。
4. 指令内部与指令之间一这种分类取决于妨碍指令完成的事件是发生在执行过程中间（无论多短），还是被看作是发生在指令之间。发生在指令内部的异常通常是同步的，因为就是这条指令触发了异常。在指令内部发生的异常实现起来要难于指令之间的异常，因为该指令必须被停止、重新启动。发生在指令内部的异步异常是因为灾难性情景（例如，硬件故障）出现的，所以总会导致程序终止。
5. 恢复与终止——如果程序的执行总是在中断之后停止，那它就是终止事件。如果程序的执行在中断之后继续，那它就是恢复事件。终止执行的异常实现起来更容易一些，因为CPU不需要在处理异常之后重启同一程序。

表C-15根据这5个类别对表C-14中的示例进行了划分。难点在于实现指令之间发生的中断，对于这种中断必须恢复指令的执行。此类异常的实现要求必须调用另一个程序，以保存所执行程序的状态、解决导致异常的原因，然后恢复程序的状态，之后才再次尝试导致该异常的指令。对正在执行的程序来说，这个过程事实上必须是不可见的。如果流水线使处理器能够在不影响程序执行的前提下处理异常、保存状态并重新启动，那就说流水线或处理器是可重新启动的。早期的超级计算机和微处理器通常缺少这一特性，但今天的几乎所有处理器都支持这一特性，至少整数流水线是这样的，因为虚拟存储器的实现需要这一特性。

表C-15 用5个类别来确定表C-14所示不同异常类型所需要的操作

• 必须允许恢复的异步被标记为恢复，尽管软件可能选择终止程序。发生在指令内部的可恢复、同步、强制异常是最难实现的。我们可能希望违反存储器保护访问的异常总是导致终止；但是，现代操作系统使用存储器保护来裣测事件，比如首次尝试使用一个页面，或者首次尝试写入一个页面。因此，CPU应当能够在此类异常之后恢复执行。

停止和恢复执行

和在非流水化实现中一样，最困难的异步有两种特征:

1. 发生在指令内部（即，在指令执行过程期间发生，与EX或MEM流水级相对应）；
2. 必须可以重新启动。

比如，在MIPS流水线中，由数据提取导致的虚拟存储器页面错误只可能发生在该指令MEM级的某一时间之后。在出现该错误时，会有其他几条指令正在执行。页面错误必须是可重新启动的，需要另一进程（比如操作系统）的干预。因此，必须能够安全关闭流水线并保存其状态，使指令能够以正确状
态重新启动。重启过程的实现通常是通过保存待重启指令的PC来实现的。如果被重启的指令不是分支，则继续提取依次排在后面的指令，以正常方式开始执行。如果被重启的指令为分支指令，则重新计算分支条件，根据计算结果提取目标指令或直通指令。在发生异步时，流水线控制可以采取以下步骤安全地保存流水线状态。

1. 在下一个IF向流水线中强制插入一个陷阱指令。
2. 在选中该陷阱指令之前，禁止错误指令的所有写入操作，禁止流水线中后续所有指令的写入操作。可以通过以下方式来实现：从生成该异常的指令开始（不包括该指令之前的指令），将流水线中所有指令的流水线锁存置零。这样可以禁止在处理异常之前对未完成指令的状态进行任何更改。
3. 在操作系统的异常处理例程接收控制权之后，它会立即保存故障指令的PC。后面从异常返回时会用到这个值。

当我们使用延迟分支时，如上一节所述，由于流水线中的指令可能不是顺序相关的，所以仅用一个PC不再可能重建处理器的状态。因此，我们需要保存和恢复的PC数目等于分支延迟的长度加1。这一步骤是在上述第（3）步完成的。

在处理异常之后，特殊指令通过重新加载PC并重启指令流（在MPS中使用指令RFE）从异常中返回处理器。如果流水线可以停止，使紧临错误指令之前的指令能够完成，使其之后的指令可以从头重新启动，那就说该流水线拥有精确异常。在理想情况下，错误指令可能还没有改变状态，要正确地处理一些异常，要求错误指令不产生任何影响。对于其他异常，比如浮点异常，某些处理器上的错误指令会首先写入其结果，然后才能处理异常。在此种情况下，即使目标位置与源操作数之一的目标位置相同，也必须准备硬件来提取源操作数。因为浮点操作可能持续许多个周期，所以其他某一指令非常可能已经写入了这些源操作数（在下一节将会看到，浮点操作经常是乱序完成的）。为了克服这一问题，最近的许多高性能CPU引入了两种操作模
式。一种模式有精确异常，另一种（快速或性能模式）则没有精确异常。当然，精确异常模式要慢一些，因为它允许浮点指令之间的重叠较少。在一些高性能CPU中，精确模式通常要慢得多（相差10倍以上），因此仅能用于代码调试。

在许多系统中对精确异常的支持是必备功能，而在其他一些系统中，它“只是”存在一定的价值，因为它可以简化操作系统接口。至少，任何需要分页或IEEE算术陷阱处理程序的处理器都必须使其异常为精确异常，可以用硬件实现，也可以辅以一定的软件支持。对于整数流水线，创建精确异常的任务比较简单，支持虚拟内存是存储器引用支持精确异常的极大动力。

MIPS中的异常

表C-16显示了MIPS流水级，以及每一级中可能发生哪些问题异常。采用流水化时，由于有多条指令同时执行，所以在同一时钟周期中可能出现多个异常。例如，考虑如下指令序列：

1
2

LD     IF     ID     EX     MEM     WB
DADD          IF     ID     EX      MEM     WB

• 由指令或数据存储器访问产生的异常可能占到8种情景的6种。现实中的情景并不像这个简单例子中那样明了。异常可能乱序发生；也就是说，可能在一条指令先行产生异常之后，排在前面的指令才产生异常。再次考虑上述序列，LD后面跟着DADD。当LD处于IF时可能产生数据页面错误，而DADD指令位于IF时可能会产生指令页面错误。指令页面错误尽管由后一指令导致，但实际上它将会首先发生。

由于我们正在实现精确异常，所以流水线需要首先处理由LD指令导致的异常。为了解释如何实现这一过程，我们将位于LD指令位置的指令称为i，将位于DADD 指令位置的指令称为i+1。流水线不能在发生异常时直接处理它，因为这样会导致这些异常的发生顺序不同于非流水化顺序。硬件会将一条给定指令 产生的所有异常都记录在一个与该指令相关联的状态向量中。这个异常状态向量将一直随该指令 向流水线下方移动。一且在异常状态向量中设定了异常指示，则关闭任何可能导致数据值写入（包括寄存器写入和存储器写入）的控制信号。由于存储指令可能在MEM期间导致异常，所以硬件必须准备好在存储指令产生异常时阻止其完成。

当一条指令进入WB时（或者将要离开MEM时），将检查异步状态向量。如果发现存在任何异常，则按照它们在非流水化处理器中的发生顺序进行处理——首先处理与最早指令相对应的异常（通常位于该指令的最早流水级）。这样可以保证：指令i引发的所有异常将优先得到处理，早于指令i+1引发的所有异常。当然，任何在较早流水级中以指令i名义采取的操作都是无效的，但由于对寄存器堆和存储器的写入操作都被禁用，所以还没有改变任何状态。

一些处理器拥有功能更强大、运行时间更长的指令，下一小节将介绍在此类处理器的流水线中实现异常时存在的问题。

指令集的复杂性

所有MIPS指令的结果都不会超过1个，我们的MIPS流水线仅在指令执行结束时写入结果。在保证一条指令完成时，称为已提交。在MIPS整数流水线中，当所有指令到达MEM级的末尾（或者WB的开头），而且没有指令在该级之前更新状态，则说这些指令已提交。因此，精确异常非常简单。一些处理器的指令会在指令执行中间更改状态，更改状态时，该指令及其之前的指令可能还未完成。例如，IA-32体系结构中的自动递增寻址模式可以在一条指令的执行过程中更新寄存器。在这种情况下，如果该指令由于异常而终止，则会使处理器状态发生变化。尽管我们知道哪些指令会导致异常，但由于该指令处于半完成状态，所以在未添加硬件支持的情况下，异常是不准确的。在这样一个非精确异常之后重启指令流是有难度的。我们也可以避免在指令提交之前更新状态，但这种做法的难度很大，或者成本很高，这是因为可能会用到经过更新的状态：考虑一条VAX指令，它多次递增同一寄存器。为了保持精确异常模型，大多数拥有此类指令的处理器能够在提交指令之间回退所做的状态更改。如果发生异常，处理器将使用这一功能将处理器状态还原为开始中断指令之前的值。

一些在执行期间更新存储器状态的指令也会增加难度。为中断和重启这些指令，规定这些指令使用通用寄存器作为工作寄存器。因此，部分完成指令的状态总是位于寄存器中，这些寄存器在发生异常时被保存，在异常之后恢复，使指令可以继续执行。在VAX中，有另外一个状态位记录指令何时开始更新存储器状态，从而在重启流水线时，CPU知道是从头开始重启指令，还是从指令的中间开始。IA-32字符串指令也使用寄存器作为工作存储器，这样，在保存和恢复寄存器时，也会保存和恢复这些指令的状态。

奇数个状态位可能会导致另外一组不同的难题：可能另外增加流水线冒险，可能需要额外的硬件来进行保存和恢复。条件代码就是这种情况的一个好例子。许多处理器隐式设定条件码，将其作为指令的一部分。这种方法具有一定的优势，因为条件码将条件的判断与实际分支分离开来。但是，在调度条件代码设定与分支之间的流水线延迟时，由于大多数指令都会设定条件码，而且不能在条件判定与分支之间的延迟时隙中使用，所以隐式设定条件可能会增加调度难度。

另外，在具有条件码的处理器中，处理器必须判断何时确定分支条件。这就需要找出分支之前最后一次设置条件代码是在什么时候。 在大多数隐式设定条件码的处理器中，其实现方式是推迟分支条件判断，直到先前的所有指令都有机会设定条件代码为止。当然，显式设定条件码的体系结构允许在条件测量与待调度分支之间插入延迟；但是，流水线控制必须跟踪最后一条设定条件码的指令，以便知道何时确定分支条件。实际上，必须将条件码当作一个操作数对待，需要进行RAW冒险检测，就像MIPS必须对寄存器进行检测一样。流水线中最后一个棘手领域是多周期操作。

假定我们尝试实现下面这样一个VAX指令序列的流水化：

1
2
3
4

MOVL        R1, R2                 ;在寄存器之间移动
ADDL3       42(R1), 56(R1)+,@(R1)  ;对存储器位置求和
SUBL2       R2, R3                 ;减去寄存器
MOVC3       @(R1)[R2], 74(R2), R3  ;移动字符串

这些指令所需要的时钟周期数有很大差别，低至1 个，高至数百个。它们所需要的数据存储器访问数也不一定，有的不需要访向数据存储器，有的可能需要数百次访问。数据冒险非常复杂，在指令之间和指令内部均会发生。一种简单的解决方案是让所有指令的执行周期数相同，但这种解决方案是不可接受的，因为它会引入数目庞大的冒险和旁通条件，形成-条极长的流水线。在指令级实现VAX的流水化是很困难的，但VAX 8800设计师找到了-种非常聪明的解决方案。他们实现了微指令执行的流水化。微指令就是一种简 单指令，在序列中用于实现更复杂的指令集。由于微指令都很简单（它们看起来与MIPS非常相似），所以流水线控制要容易得多。从1995年开始，所有Intel IA-32微处理器都使用这一策略将IA-32 指令转换为微操作，然后再实现微操作的流水化。

作为对比，载入-存储处理器拥有一些简 单操作，完成的工作数量相似，更容易实现流水化。如果架构师认识到指令集设计与流水化之间的关系，他们就可以设计出能够高效流水化的设计体系结构。20 世纪80年代，人们认识到指令集的复杂性会增加流水化的难度、降低流水化的效率。20 世纪90年代，所有公司都转向更简单的指令集，目标在于降低积极实现的复杂性。

扩展MIPS流水线，以处理多周期操作

我们现在希望研究如何扩展MIPS流水线，以处理浮点运算。这一节的重点是介绍基本方法和各种候选设计方案，最后是对一种MIPS浮点流水线的性能测量。要求所有MTPS浮点运算都在1个时钟周期内完成是不太现实的，甚至在2个时钟周期内也有很大难度。这样做就意味着要么接受缓慢的时钟，要么在浮点单元中使用大量逻辑，或者同时接受两者。而实际情况是，浮点流水线将会允许更长的操作延迟。如果我们设想浮点指令拥有与整数指令相同的流水线，那就容易理解了，当然流水线中会有两处重要改变。第一，为了完成操作，EX周期可能要根据需要重复多次，不同操作的重复次数可能不同。第二，可能存在多个浮点功能单元。如果待发射指令会导致它所用功能单元的结构性冒险，或者导致数据冒险，将会出现停顿。

针对本节，我们假定MIPS实现中有以下4个独立的功能单元。

1. 主整数单元，处理载入和存储、整型ALU操作，还有分支。
2. 浮点与整数乘法器。
3. 浮点加法器，处理浮点加、减和转换。
4. 浮点和整型除法器。

如果我们还假定这些功能单元的执行级没有实现流水化，那么图C-17给出了最终的流水线结构。由于EX未被流水化，所以在前一指令离开EX之前，不会发射任何其他使用这一功能单元的指令。另外，如果一条指令不能进入EX级，该指令之后的整个流水线都会被停顿。

图C-17 增加了三个未流水化浮点功能单元的MIPS流水线。因为每个时钟周期仅发射一条指令，所以所有指令都会经历整型运算的标准流水线。只是浮点运算在到达EX级时会循环。在它们完成EX级之后，则进入MEM和WB级，以完成执行

事实上，中间结果可能不会像图C-17所建议的那样围绕EX单元循环；而是在EX流水级拥有一些大于1的时钟延迟。我们可以推广如图C-17所示的浮点流水线结构，以允许实现某些级的流水化，并允许多个操作同时进行。为了描述这样一个流水线，我们必须定义功能单元的延迟以及启动间隔（或称重复间隔）。我们采用之前的相同方式来定义延迟：生成结果的指令与使用结果的指令之间的周期数。起始间隔或重复间隔是指在发出两个给定类型的操作之间必须间隔的周期数。例如，我们将使用如表C-17所示的延迟和启动间隔。根据这一延迟定义，整型ALU运算的延迟为0，因为其结果可以在下一时钟周期使用；载入指令的延迟为1，因为这些结果可以相隔一个周期之后使用。由于大多数操作都会在EX的开头使用其操作数，所以延迟通常是指eX之后的级数（一条指令在EX生成结果），例如，ALU运算之后有0个流水级，而载入指令则有1级。一个重要的例外是存储指令，它会在一个周期之后使用被存储的值。因此，存储指令的延迟是针对被存储的值而言，而不是针对基址寄存器，所以少1个周期。流水线延迟基本上等于执行流水线深度减去1个时钟周期，而流水线深度等于从EX级到生成结果的流水级之间的级数。因此，对于上面的示例流水线，浮点加法中的级数为4，而浮点乘法的级数为7。为了获得更高的时钟频率，设计师需要降低每个流水级中的逻辑级数，而这样会增大更复杂操作所需要的流水级数。高时钟频率的代价是延长了操作的延迟。

表C-17中的示例流水线结构允许多达4个同时执行的浮点加、7个同时执行的浮点/整数乘，和一个浮点除。图C-18说明了如何通过扩展图C-17来绘制这个流水线。在图C-18中，重复间隔是通过增加额外的流水级来实现的，它们由增加的流水线寄存器隔开。由于这些单元是相互独立的，所以我们分别对各级进行命名。需要多个时钟周期的流水级，比如除法单元，将被进一步细分，以显示这些流水级的延迟。由于它们不是完整的流水级，所以只有一个操作是活动的。这一流水线结构还可以使用本附录前面的类似图表展示，表C-18显示了一组独立的浮点运算和浮点载入、存储指令。自然，浮点运算的较长延迟增加了RAW冒险和所导致停顿的频率，在本节后面将会看到这一点。

图C-18 一条支持同时执行多个浮点操作的流水线。浮点乘法器和加法器被完全流水化，深度分别为7级和4级。浮点除法器未被流水化，而是需要24个时钟周期才能完成。在未招致RAW停顿的情况下，从发射浮点操作到使用操作结果之间的指令延迟由执行级中消耗的周期数来决定。例如，浮点加之后的第四条指令可以使用浮点加的结果。对于整数AlU操作，执行流水线的深度总是为1，下一条指令就可以使用这些结果

• 用斜体表示的流水级显示了需要数据的位置，而用粗体表示的流水级显示了有结果可用的位置。指令标记符上的“.D”扩展表示双精度（64位）浮点运算。浮点载入和存储使用64位路径连向存储器，所以流水线时序与整数载入或存储一样。

图C-18中的流水线结构需要另外引入流水线寄存器（例如，A1/A2、 A2/A3、A3/A4），并修改连向这些寄存器的连接。ID/EX 寄存器必须进行扩展，以将ID 连接到EX、DIV、M1和A1；我们可以用标记ID/EX、ID/DIV、ID/M1或ID/A1来引用与之后流水线之一相关联的寄存器部分。ID 与所有其他流水级之间的流水线寄存器可以看作逻辑分离的寄存器，事实上也确实可以实现为分离寄存器。由于在一个流水级中只能同时有一个操作，所以控制信息可以与该流水级头部的寄存器关联在一起。

长延迟流水线 中的冒险与转发

对于如图C-18所示的流水线，冒险检测与转发有许多不同方面。

1. 因为除法单元未被完全流水化，所以可能发生结构冒险。需要对这些冒险进行检测，还将需要停顿指令发射。
2. 因为指令的运行时间不同，所以一个周期内需要的寄存器写入次数可能会大于1。
3. 由于指令不会循序到达WB，所以有可能存在写后写（WAW）冒险。注意，由于寄存器读总是在ID中发生，所以不可能存在读后写（WAR）冒险。
4. 指令的完成顺序可能不同于其发射顺序，从而导致异常问题。
5. 由于操作的延迟较长，所以RAW冒险的停顿将会变得更为频繁。

由于操作延迟较长而导致停顿的增加，基本上与整数流水线一样。在描述这一浮点流水线中出现的新问题并探讨其解决方案之前，先让我们研究一下RAW冒险的可能影响。表C-19给出了一个典型浮点代码序列和最终的停顿。在这一节的末尾，将会研究这一浮点流水线中我们所选部分SPEC的性能。

• 与较浅的整数流水线相比，较长的流水线大体会增大停顿频率。这个序列中的每条指令都会依赖于先前的指令，而且只要数据可用就可以继续进行，这里假定流水线具有完全旁通和转发。S.D必须多停顿一个周期，使其MEM不会与ADD.D冲突。添加硬件可以很轻松地处理这种情况。

现在看看因为写入导致的问题，如前面列表中第(2)项和第(3)项所述。如果我们假定浮点寄存器堆有一个写端口，那么浮点操作序列（以及浮点载入指令与浮点运算的结合）可能导致寄存器写端口的冲突。考虑表C-20所示的流水线序列。在时钟周期11中，所有3条指令将到达WB，希望写入寄存器堆。由于仅有一个寄存器堆写入端口，所以处理器必须依次完成各条指令。这个单一寄存器端口就代表着一种结构化冒险。我们可以增加端口的数目来解决这一问题，但由于所增加的写入端口可能很少用到，所以这种解决方案可能并没有什么吸引力。之所以很少用到这些端口，是因为写入端口的最大稳定状态数为1。 我们选择检测对写端口的访问，将其作为结构胃险加以实施。

• 这不是最坏情况，因为浮点单元中的先前除法操作也可能在同一时钟周期完成。注意，尽管在时钟周期10中，MUL.D、ADD.D和L.D都处于MEM级，但仅有L.D在实际使用该存储器，所以关于MEM不存在结构性冒险。

共有两种不同方法来实现这一互锁。 第一种方法是跟踪ID级对写端口的使用，并在一条指令发射之前使其停顿，就像对于任何其他结构冒险一样。可以用一个移位寄存器来跟踪写端口的使用，这个移位寄存器可以指示已发射指令将会在何时使用这个寄存器堆。如果ID中的指令需要与已发射指令同时使用寄存器堆，那ID中的指令将会停顿一个周期。在每个时钟周期，保留寄存器将会移动1位。这种实现有一个好处一它能保持一个特性：所有互连检测与停顿插入都在ID流水级内进行。其成本是需要增加移位寄存器和写冲突逻辑。我们在本节始终假定采用这一机制。

一种替代方案是当一个冲突指令尝试进入MEM级或WB级时，使其停顿。如果我们等到冲突指令希望进入MEM或WB级时才使其停顿，可以选择停顿任一指令。一种简单的启动式方法（尽管有时是次优方法）是为那些延迟最长的单元赋予优先级，这是因为它是最可能导致另一指令因RAW冒险而停顿的指令。这种方案的好处在于在进入容易检测冲突的MEM或WB级之前不需要检测冲突。缺点是，由于停顿现在可能会出现在两个地方，所以使流水线控制变得复杂。注意，在进入MEM之前的停顿将会导致EX、A4或M7流水级被占用，可能会强制停顿返回流水线中。同样，WB之前的停顿将会导致MEM倒退。

我们的另一个问题是可能出现WAW冒险。为了看到这些冒险的存在，考虑表C-20中的示例。如果L.D指令早一个周期发射，且其目的地为F2，则会产生WAW冒险，因为它会早于ADD.D一个周期写入F2。注意，只有当ADD.D的结果被改写，而且从来没有任何指令使用这一结果时，才会发生这一冒险!如果在ADD.D和L.D之间会用到F2，那流水线将会因为RAW冒险而需要停顿，在ADD.D完成之前不会发射L.D。对于这个流水线，我们可以宣称只有在发射无用指令时才会发生WAW冒险，但仍然必须检测这些冒险，并在完成工作时确保L.D的结果出现在F2中。

有两种可能方式来处理这一WAW冒险。第一种方法是延迟载入指令的发射，直到ADD.D进入MEM为止。第二种方法是废除ADD.D的结果：检测冒险并改变控制，使ADD.D不会写入其结果。之后L.D就可以立即发射。由于这种冒险非常少见，所以两种方案都很有效一可以选择任何一种易于实现的方案。在任一情况下， 都可以在发射L.D的ID期间检测冒险，使L.D停顿或者使ADD.D成为空操作都很容易。难以处理的情景是检测L.D可能在ADD.D之前完成，因为这时需要知道流水线的长度和ADD.D 的当前位置。幸运的是，这一代码序列 （两个写操作之间没有插入读操作)很少出现，所以可以使用一种简单的解决方案：如果ID中的一条指令希望和一条已经发射的指令同时写同一寄存器，就不要向EX发射指令。

在检测可能出现的冒险时，必须考虑浮点指令之间的冒险，以及浮点指令与整型指令之间的冒险。除了浮点载入-存储和浮点-整数寄存器移动之外，浮点与整数寄存器是相互分离的。所有整数指令都是针对整数寄存器进行操作，而浮点操作仅对它们自己的寄存器进行操作。因此，在检测浮点与整数指令之间的冒险时，只需要考虑浮点载入-存储和浮点寄存器移动。流水线控制的这种简化是整数和浮点数据采用分离寄存器堆的另一项好处。（其主要好处是在各寄存器堆数目不变的情况下使寄存器数目加倍，还能在不增加各寄存器端口的情况下增加带宽。除了需要增加寄存器堆之外，其主要缺点是偶尔需要在两组寄存器之间进行移动所带来的微小成本。）假定流水线在ID中进行所有冒险检测，必须在执行3种检查之后才能发射一条指令。

（1）检查结构冒险——一直等到所需要功能单元不再繁忙为止（在这个流水线中，只有除法操作需要），并确保在需要寄存器写端口时可用。

（2）检查RAW数据冒险——一直等到源寄存器未被列为流水线寄存器中的目的地为止。（当这一指令需要结果时，这些寄存器不可用。）这里需要进行大量检查，具体取决于源指令和目标指令，前者决定结果何时可用，后者决定何时需要该取值。例如，如果ID中的指令是一个浮点运算，其源寄存器为F2，那F2在ID/A1、A1/A2或A2/A3中不能被列为目的地，它们与一些浮点加法指令相对应，当ID中的指令需要结果时，这些指令还不能完成。（ID/A1 是ID输出寄存器中被发送给A1的部分。）如果我们希望重叠执行除法的最后几个周期，由于需要将除法接近完成时的情景作为特殊情况加以处理，所以除法运算需要的技巧性更强-些。实际上，设计师可能会忽略这一优化，以简化发射测试。

（3）检查WAW数据冒险——判断A1，… A4，D，M1，…，M7中是否有任何指令的目标寄存器与这一指令相同。如果确实如此，则暂停发射ID中的指令。尽管对于多周期浮点运算来说，冒险检测要更复杂一些，但其概念与MIPS整数流水线是一样的。对于转发逻辑也是如此。可通过以下方式来实现转发：检查EXMEM、A4/MEM、M7MEM、D/MEM或MEM/WB寄存器中的目标寄存器是否为浮点指令的源寄存器之一。如果确实如此，则必须启用适当的输入多工器，以选择转发数据。

保持精确异常处理

用以下代码序列可以说明长时间运行指令所导致的另一个问题：

1
2
3

DIV.D     F0,F2, F4
ADD.D     F10,F10,F8
SUB.D     F12,F12,F14

第一种是忽略问题，容忍非精确异常。20世纪60年代和70年代早期采用这一方法。在某些超级计算机中仍在使用这种方法，在这种超级计算机中，某些特定类型的异常或者不允许出现，或者由硬件进行处理，不需要使流水线停止。在大多数现代处理器中很难使用这一方法，因为虚拟存储器等功能和IEEE 浮点标准都需要通过软件和硬件的组合来实现精确异常。前面曾经提到，最近的一些处理器已经通过引入两种执行模式解决了这一问题，一种模式速度很快，但可能是非精确的，另一种模式较慢，但却是精确的。在实现较慢的精确模式时，或者使用模式切换，或者显式插入一些指令，用于测试浮点异常。无论采用哪种实现方式，浮点流水线中所允许的重叠和重新排序数目都受到严重限制，以实现在同一时间只有一条浮点指令是活动的。

第二种方法是缓冲一个操作的结果，直到先前发射的所有操作都完成为止。一些CPU实际上使用了这一方案，但是，当操作的运行时间差别很大时，由于要缓冲的结果数变得非常庞大，所以这种方法的成本就会非常高昂。此外，必须绕过来自队列的结果，以便在等待较长指令的同时继续发射指令。这就需要大量比较器和一个非常大的乘法器。

这一基本方法有两种可行的变化形式。第一种形式是历史文件。历史文件跟踪寄存器的原始值。在发生异常而且必须将状态回滚到某一乱序完成的指令之前时，可以从历史文件中恢复寄存器的原始值。在诸如VAX之类的处理器上，采用一种类似技术来实现自动递增和自动递减寻址。另一种方法是未来文件，它跟踪寄存器的较新值；当所有先前指令均已完成时，则从未来文件中更新主寄存器堆。当发生异常时，主寄存器堆拥有中断状态的精确值。

所使用的第三种方法是允许异常变得不十分精确，但保存足够的信息，以便陷阱处理例程可以生成精确的异常序列。这意味着要知道流水线中有哪些操作以及其PC。因此，在处理异常之后，由软件完成那些最后完成指令之前的所有指令，然后该序列就能重新启动了。考虑以下最糟代码序列:

1
2
3

指令1——最终中断执行的长时运行指令。
指令2, ...，指令m-1 ——系列未完成的指令。
指令n——一条已完成指令。

对于简单的类MIPS流水线，有一个重要简化：如果指令2，…，指令n都是整数指令，那我们就知道当指令n完成时，指令2，…，指令n-1也都已完成。因此，只有浮点操作需要处理。为使这一情况易于处理，必须限制可以重叠执行的浮点指令数。例如，如果我们仅重叠两条指令，那只有中断指令需要由软件来完成。如果浮点流水线很深，或者如果存在大量浮点功能单元，那这一限制可能会限制吞吐量。SPARC 体系结构中使用了这一方法，以允许重叠浮点与整数操作。最后一种方法是一种混合方案，它仅在确保所发射指令之前的所有指令都已完成，而且没有导致异常时，才允许继续指令发射。这样就能确保在发生异常时，中断指令之后的指令都不会完成，而中断指令之前的全部指令都可以完成。这意味着有时要停顿CPU，以保持精确异常。为使这一方案有效，浮点功能单元必须在EX流水级的早期判断是否可能存在异常

MIPS浮点流水线的性能

图C-18中的MIPS浮点流水线既可以对除法单元生成结构性停顿，也可以对RAW冒险生成停顿（它还可能拥有WAW冒险，但在实际中很少发生）。图C-19以各实例为基础，列出了每种浮点操作的停顿周期数目（即，每个浮点基准测试的第一个长条表示每个浮点加、减或转换的浮点结果停顿数）。可以看到，每个操怍的停顿周期与浮点运算的延迟相关，介于功能单元延迟的46%~59%之间。

图C-19 对于SPEC89浮点基准测试，每种主要浮点运算类型的停顿。

图C-20给出了5种SPECfp基准测试整数与浮点停顿的完整分类。图中共给出4类停顿：浮点结果停顿、浮点比较停顿、载入与分支延迟、浮点结构延迟。编译器尝试在调度分支延迟之前调度载入与浮点延迟。每个指令的总停顿数介于0.65~1.21之间。

图C-20 针对5种SPEC89浮点基准测试，MIPS浮点流水线上发生的停顿。在所有情况下，浮点结果停顿都占绝大多数，每条指令平均为0.71次停顿，也就是停顿周期的82%。比较操作生成的停顿数为每条指令平均0.1次，为第二大停顿源。除法结构性冒险的影响仅在doduc测试中比较明显一些

融会贯通: MIPS R4000流水线

在本节，我们将研究MIPS R4000 处理器系列的流水线结构和性能，该系列包括4400。R4000实现MIPS64，但它为整数和浮点程序使用的流水线深度都超过我们使用的五级流水线设计。这一较深流水线可以将五级整数流水线分解为八级，以允许实现更高的时钟频率。由于缓存访问的时间要求很高，所以通过分解存储器访问可以获得更多的流水级。这种更深的流水线有时被称为超流水线。

图C-21显示了八级流水线结构，其中使用了数据路径的抽象版本。图C-22显示了流水线中连续指令的重叠。注意，尽管指令和数据存储器占用多个周期，但它们已经完全实现流水化，所以在每个时钟 周期都可以开始一条新指令。事实上，流水线会在完成缓存命中检测之前使用数据。每一流水级的过程如下所述。

• IF——指令提取的前半部分，PC选择与指令缓存访问的初始化实际上发生在这里。
• IS——指令提取的后半部分，完成指令缓存访问。
• RF——指令译码与寄存器提取、冒险检查、指令缓存命中检测。
• EX——执行，包括实际地址计算、ALU操作和分支目标计算与条件判断。
• DF——数据提取，数据缓存访问的前半部分。
• DS——数据提取的后半 部分，完成数据缓存访问。
• TC——标记检查 ，判断数据缓存访问是否命中。
• WB——载入和寄存器-寄存器操作的写回过程。

图C-21 R4000 的八级流水线结构使用流水化指令与数据缓存。图中对流水级进行了标记，它们的详细功能用文字描述。垂直虚线表示流水级界限以及流水线锁的位置。指令实际上在IS结束时可供使用，但标记检查是在RF完成的，与此同时提取寄存器值。因此，我们将指令存储器标记为在整个RF中运行。由于在知道缓存访问是否命中之前，不能将数据写入寄存器，所以数据存储器访问需要TC级

图C-22 R4000 整数流水线的结构导致了2周期载入延迟。由于数据值在DS结束时可用，而且可能被旁路，所以有可能产生2周期延迟。如果TC中的标记检查显示这是一次缺失，则流水线将回退一个周期，在此时刻有正确数据可供使用

除了显著增加所需要的转发数量之外，这种较长延迟的流水线既会增加载入延迟，又会增加分支延迟。由于数据值在DS的末尾才可用，所以图C-22将载入延迟显示为2个周期。表C-21显示了在载入指令之后立即使用的简略流水线调度。它显示在3个或4个周期之后使用载入指令的结果时，就需要进行转发。

图C-23显示基本分支延迟为3个周期，这是因为分支条件是在EX期间计算的。MIPS体系结构有一个延迟1周期的分支。R4000 为该分支延迟的其余2个周期使用预测未选中策略。如表C-22所示，未选中分支就是延迟1个周期的分支，而选中分支是在一个1周期延迟时隙之后跟有2个空闲周期。这一指令集提供了一种类似于分支的指令，前面已经对其进行了介绍，它可以帮助填充该延迟时隙。流水线互锁一方面要插入选中分支的2周期分支停顿代价，另一方面也造成因为使用载入结果而导致的数据冒险停顿。

• 通常的转发路径可在2个周期之后使用，所以DADD和DSUB通过停顿之后的转发来获取其取值。OR指令从寄存器堆中获取该值。由于载入之后的两条指令可能是独立的，因此不会停顿，所以旁路可能指向载入之后3或4个周期的指令。

深度流水线除了增加载入与分支的停顿之外，还会增加ALU运算的转发级别数。在MIPS五级流水线中，两个寄存器-寄存器ALU指令之间的转发可能发生于ALUMEM或MEMWB寄存器。在R4000流水线中，ALU旁路可能有4种可能来源: EX/DF、DF/DS、DS/TC和TC/WB。表C-22如表中上半部分所示，选中分支有一个1周期延迟时隙，后面跟有一个2周期停顿，而如表中下半部分所示，未选中分支只有一个1周期延迟时隙

浮点流水线

R4000浮点单元由3个功能单元缓存：浮点除法器、浮点乘法器和浮点加法器。加法器逻辑在乘法或除法的最后一个步骤使用。双精度浮点运算可能占用2个周期（对于求相反数）到112个周期（对于求平方根）。此外，各种单元的起始速度不同。浮点功能单元可以看作拥有8个不同流水级，如表C-23中所列；以不同顺序组合这些流水级，即可执行各种浮点运算。

这些流水级的每个流水级都有单个副本，各种指令对一个流水级可以使用0次或多次，使用顺序也可以不同。表C-24给出了最常见双精度浮点运算所使用的延迟、初始速率和流水级。

• 延迟值假定目标指令是一个浮点运算。当目标指令为存储指令时，延迟会少1个周期。流水级的显示顺序就是各个运算使用它们的顺序。标记S+A表示在这个时钟周期内同时使用S和A流水级。标记D28表示D流水级在一行中使用28次。

根据表C-24中的信息，我们可以判断一个由不同独立浮点运算组成的序列是否可以无停顿发射。如果因为该序列的时序而对于共享流水级发生冲突，则需要停顿。表C-25、表C-26、表C-27、表C-28给出了4种可能存在的常见两指令序列：乘法后面跟有加法、加法后面跟有乘法、除法后面跟有加法、加法后面跟有除法。这些表中显示了第二条指令所有感兴趣的起始位置，以及第二条指令在每个位置是发射还是停顿。当然，可能一共有三条指令是活动的，在这种情况下，发生停顿的可能性要高得多，列表也要更为复杂。

• 第二列指出一个特定类型的指令在n个周期之后发射时是否会停顿，其中n为时钟周期编号，在此周期内发生第二指令的U级。导致停顿的流水级用黑体表示。注意，这个表仅给出了乘法指令与时钟周期1、7之间发射的一个加法指令之间的交互。在这种情况下，如果加法指令在乘法之后4或5个周期发射，则该加法指令会停顿;否则，它会无停顿发射。注意，如果加法指令在周期4发射，由于它在下一个时钟周期仍然会与乘法指令相冲突，所以加法指令会停顿2个周期;但是，如果加法指令在周期5发射，由于这样会消除冲突，所以它仍然仅停顿1个时钟周期。

• 除法在周期0处开始，在周期35处完成；表中给出除法的最后10个周期。由于除法指令大量使用了加法指令所需要的舍入硬件，因此，只要加法指令是在周期28至周期33中的任一周期中启动，该除法指令都会使其停顿。注意，在周期28处启动的加法指令将一直停顿到周期36。如果加法指令在除法指令之后立即启动，由于加法指令可能在除法指令用到共享流水级之前完成，所以不会导致冲突，如同我们在表C-26中的乘加一样。和前面的表一样，这个示例假定在时钟周期26和35之间只有一个加法指令到达U级。

• 如果除法指令晚于加法1个周期启动，则除法指令会停顿，但在此之后不存在冲突。

R4000流水线的性能

本节，我们将研究在R4000流水线结构上运行SPEC92基准测试时所发生的停顿。流水线停顿或损失的原因共有四大类。

1. 载入停顿——在载入之后1或2个周期再使用载入结果时导致的延迟。
2. 分支停顿——每个选中分支上发生的两周期停顿再加上未填充或已取消分支延迟时隙。
3. 浮点结果停顿——因为浮点操作数的RAW冒险所导致的停顿。
4. 浮点结构停顿——因为浮点流水线中功能单元的冲突产生发射限制，进而导致的延迟。

图C-24给出了对于10个SPEC92基准测试，R4000 流水线的流水线CPI分类。表C-29给出了相同的数据。

图C-24 10个SPEC92基准测试的流水线CPI，假定采用完美缓存。流水线CPI的变化范围为1.2~2.8。最左边的5个程序为整数程序，分支延迟是CPI的主要组成因素。最右边5个程序为浮点程序，浮点结果停顿是其主要因素。表C-29给出了绘制这一图形的数值

• 主要因素为浮点结果停顿（对于分支和浮点输入均是如此）和分支停顿，载入停顿和浮点结构性停顿的影响很小。

根据图C-24和表C-29中的数据，可以看出深度流水线的代价。与经典五级流水线相比，R4000流水线的分支延迟要长得多。较长的分支延迟会显著增加在分支上花费的周期数，特别是对于分支频率较高的整数程序。浮点程序一个值得注意的影响是: 与结构性冒险相比，浮点功能单元的延迟会导致更多的停顿，主要源于初始间隔限制和不同浮点指令对功能单元的冲突。因此，降低浮点运算的延迟应当是第一目标， 而不是实现功能单元的更多流水线或重复。当然，降低延迟可能会增加结构性停顿，这是因为许多潜在的结构性停顿被隐藏在数据冒险之后。

交叉问题

RISC指令 集及流水线效率

我们已经讨论了指令集简化对于构建流水线的好处。简单指令集还有另外一个好处:这样可以更轻松地调度代码，以提高流水线的执行效率。为了解这一点，考虑一个简单示例：假定我们需要对存储器中的两个值相加，并将结果存回存储器。在一些高级指令集中，这一任务只需要一条指令;而在其他一些指令集中则需要两条或三条指令。一个典型的RISC 体系结构需要四条指令（两条载入指令、一条加法指令和一条存储指令）。在大多数流水线中，不可能在没有插入停顿的情况下顺序调度这些指令。对于RISC指令集，各个操作都是单独的指令，可以使用编译器进行各别调度或动态硬件调度技术进行各别调度。这些效率优势如此明显，再加上其实现非常容易，所以复杂指令集的几乎所有近期流水线实现实际上都将其复杂指令转换为类似于RISC的简单操作，然后再对这些操作进行调度和流水化。

动态调度流水线

简单流水线提取一条指令并发射它，除非流水线中的已有指令和被提取的指令之间存在数据相关性，而且不能通过旁路或转发来隐藏。转发逻辑降低了实际流水线延迟，使特定的相关性不会导致冒险。如果存在不可避免的冒险，则冒险检测硬件会使流水线停顿（从使用该结构的冒险开始)。在清除这种相关性之前，不会提取或发射新指令。为了弥补这些性能损失，编译器可以尝试调度指令来避免冒险；这种方法称为编译器调度或静态调度。几种早期处理器使用了另外一种名为动态调度的方法，硬件借此方法重新安排指令的执行过程，以减少停顿。

到目前为止，本附录讨论的所有技术都使用循序指令发射，这意味着如果一条指令在流水线中停顿，将不能处理后续指令。在采用循序发射时，如果两条指令之间存在冒险，即使后面存在一些不相关的、不会停顿的指令，流水线也会停顿。在前面开发的MIPS流水线中，结构性冒险和数据冒险都是在指令译码（ID）期间进行检查的：当一条指令可以正确执行时，该指令是从ID发射出去的。为使一条指令在其操作数可用时立即开始执行，不受其先前停顿指令的影响，我们必须将发射过程分为两部分：检查结构性冒险，等待数据冒险的消失。循序对指令进行译码和发射；但是，我们希望指令在其数据操作数可用时立即开始执行。因此，流水线是乱序执行的，也就暗示是乱序完成的。为了实现乱序执行，我们必须将ID流水级分为两级。

1. 发射——指令译码，检查结构性冒险。
2. 读取操作数——等到没有数据冒险，随后读取操作数。

IF级进入发射级，EX级跟在读取操作数级之后，这一点与MIPS流水线中一样。同MIPS浮点流水线一样，执行可能占用多个周期，具体取决于所执行的操作。因此，我们可能需要区分一条指令何时开始执行，何时完成执行；在这两个时刻之间，指令处于执行过程中。这样就允许多条指令同时处于执行过程中。除了对流水线结构的修改之外，我们还将改变功能单元设计：改变单元数、操作延迟和功能单元流水化，以更好地探索这些更高级的流水线技术。

采用记分卡的动态调度

在动态调度流水线中，所有指令都循序通过发射级（循序发射）；但是，它们可能在第二级（读取操作数级）停顿，或绕过其他指令，然后进行乱序执行状态。记分卡技术在有足够资源、没有数据依赖性时，允许指令乱序执行;这一功能是在CDC 6600记分卡中开发的，并因此而得名。

在我们了解如何在MIPS流水线中使用记分卡之前，非常重要的一点是要观察到当指令乱序执行时可能会出现WAR冒险，这种冒险在MPS浮点或整数流水线中是不存在的。例如，考虑以下代码序列:

1
2
3

DIV.D         F0,F2,F4
ADD.D         F10,F0,F8
SUB.D         F8,F8,F14

图C-25 带有记分卡的MIPS处理器的基本结构。记分卡的功能是控制指令执行（垂直控制线）。所有数据在寄存器堆和总线上的功能单元之间流动（水平线，在CDC6600中称为干线）。共有两个浮点乘法器、一个浮点除法器、一个浮点加法器和一个整数单元。一组总线（两个输入和一个输出）充当一组功能单元。记分卡的细节在表C-30至表C-33中给出

每条指令都进入记分卡，在这里构建一条数据相关性记录；这一步与指令发射相对应，并替换MIPS流水线中的ID步骤。记分卡随后判断指令什么时候能够读取它的操作数并开始执行。如果记分卡判断该指令不能立即执行，它监控硬件中的所有变化，以判断该指令何时能够执行。记分卡还控制一条指令什么时候能将其结果写到目标寄存器中。因此，所有冒险检测与解决都集中在记分卡。我们后面将会看到记分卡的一张表格（表C-30），但首先需要理解流水线发射与执行部分的步骤。

每条指令需要经历4个执行步骤。（由于我们现在主要考虑浮点运算，所以不考虑存储器访问步骤。）我们先粗略地查看一下这些步骤，然后再详细研究记分卡如何记录一些必要信息，用于判断执行过程何时由一个步骤进行到下一个步骤。这四个步骤代替了标准MIPS流水线中的ID、EX和WB步骤，如下所示。
（1）发射——如果指令的一个功能单元空闲，没有其他活动指令以同一寄存器为目标寄存器，则记分卡向功能单元发射指令，并更新其内部数据结构。这一步代替了MIPS流水线中ID步骤的一部分。只要确保没有其他活动功能单元希望将自己的结果写入目标寄存器，就能保证不会出现WAW冒险。如果存在结构性冒险或WAW冒险，则指令发射停顿，在清除这些冒险之前，不会再发射其他指令。当发射级停顿时，会导致指令提取与发射之间的缓冲区填满；如果缓冲区只是一项，则指令提取立即停顿。如果缓冲区是拥有多条指令的队列，则在队列填满后停顿。

（2）读取操作数——记分卡监视源操作数的可用性。如果先前发射的活动指令都不再写入源操作数，而该源操作数可用。当源操作数可用时，记分卡告诉功能单元继续从寄存器读取操作数，并开始执行。记分卡在这一步动态解决 RAW冒险，可以发送指令以进行乱序执行。这一步和发射步骤一起，完成了简单MIPS流水线中ID步骤的功能。

（3）执行——功能单元接收到操作数后开始执行。结果准备就绪后，它通知记分卡已经完成执行。这一步代替了MIPS流水线中的EX步骤，在MIPS浮点流水线中耗用多个周期。

（4）写结果——一旦记分卡知道功能单元已经完成执行，则检查WAR冒险，并在必要时停顿正在完成的指令。

如果有一个与我们先前示例相类似的代码序列，其中ADD.D和SUB.D都使用F8，则存在WAR冒险。在这个示例中，有如下代码:

1
2
3

DIV.D     F0,F2,F4
ADD.D     F10,F0,F8
SUB.D    F8,F8,F14

• 在正在执行的指令前面（即按发射顺序）有一条指令还没有读取其操作数;
• 这些操作数之一与正执行指令的结果是同一寄存器。

如果不存在这一WAR冒险，或者已经清除，则记分卡会告诉功能单元将其结果存储到目标寄存器中。这一步骤代替了简单MIPS流水线中的WB步骤。

乍看起来，记分卡在区分RAW和WAR冒险时似乎会有困难。

因为只有当寄存器堆中拥有一条指令的两个操作数时，才会读取这些操作数，所以记分卡未能利用转发。只有当寄存器都可用时才会进行读取。这一代价并没有读者最初想象得那么严重。这里与我们前面的简单流水线不同，指令会在完成执行之后立即将结果写入寄存器堆（假定没有WAR冒险），而不是等待可能间隔几个周期的静态指定写入时隙。由于结果的写入和操作数的读取不能重叠，所以仍然会增加一个周期的延迟。我们需要增加缓冲，以消除这一开销。记分卡根据自已的数据结构，通过与功能单元的沟通来控制指令从一个步骤到下一个步骤的进展。但这种做法有一点点复杂。指向寄存器堆的源操作数总线和结果总线数目是有限的，所以可能会存在结构性冒险。记分卡必须确保允许进入第（2）、（4）步的功能单元数不会超过可用总线数。这里不会进行深入讨论，仅提及CDC 6600在解决这一问题时，将16个功能单元分为四组，并为每一组提供一组总线，称为数据干线。在一个时钟周期内，一个组中只有一个单元可以读取其操作数或写入其结果。

现在让我们看一个拥有五个功能单元的MIPS记分卡所保持的详尽数据结构。表C-30显示了在如下这一简单指令序列执行时，记分卡中的信息。

1
2
3
4
5
6

L.D      F6 ,34(R2)
L.D      F2 ,45(R3)
MUL.D    F0,F2,F4
SUB.D    F8,F6,F2
DIV.D    F10,F0,F6
ADD.D    F6, F8,F2

• 每个功能单元在功能单元状态表中有一个对应项。一旦发射一条指令后，就在功能单元状态表中保留其操作数记录。最后，寄存器状态表指示哪个单元将生成每个未给出的结果；项数与寄存器数相等。指令状态表表明: （1）第一个L.D已经完成并写入其结果，（2） 第二个L.D已经完成执行，但还没有写入其结果。MUL.D、SUB.D 和DIV.D都已经发射，但正在停顿，等待其操作数。功能单元状态表明第一个乘法单元正在等待整数单元，加法单元正在等待整数单元，除法单元正在等待第一个乘法单元。ADD.D 指令因为结构性冒险而停顿，当SUB.D完成时将会清除这一冒险。如果这些记分卡中某个中的项目没有用到，则保持为空。例如，Rk字段在载入时没有用到，Mult2单元没有用到，因此它们的字段没有意义。另外，一旦读取一个操作数之后，Rj和Rk字段将被设置为“否”。表C-33表明了最后一步为什么至关重要。

记分卡共有三个部分，如下所述。

• 指令状态——指出该指令处于四个步骤中的哪一步。
• 功能单元状态——指出功能单元（FU）的状态。共有9个字段用来表示每个功能单元的状态。
  • 忙——指示该单元是否繁忙。
  • Op一在此单元中执行的运算 （例如，加或减）。
  • Fi——目标寄存器。
  • Fj, Fk——源寄存器编号 。
  • Qj, Qk——生成源寄存器Fj、 Fk的功能单元。
  • Rj, Rk——指示Fj、 Fk已准备就绪但尚未读取的标记。在读取操作数后将其设置为“否”。
• 寄存器结果状态——如果一条活动指令以该寄存器为目标寄存器，则指出哪个功能单元将写入每个寄存器。只要没有向该寄存器写入的未完成指令，则将此字段设置为空。

现在让我们看一下在表C-30中开始的代码序列如何继续执行。之后，我们就能更详细地研究记分卡用于控制执行的条件了。

假定浮点功能单元的EX周期延迟如下（选择这些延迟是为了说明行为特性，并非代表性数值）：加法为2个时钟周期，乘法为10个时钟周期，除法为40个时钟周期。利用表C-30前面的代码段，并从表C-30中指令状态指示的时刻开始，说明当MUL.D和DIV.D分别准备好写入结果状态时，状态表中是什么样的。

从第二个L.D到MUL.D、ADD.D和SUB.D，从MUL.D到DIV.D和从SUB.D到ADD.D，存在RAW数据冒险。在DIV.D和ADD.D以及SUB.D之间存在WAR数据冒险。最后，加法功能单元对于ADD.D和SUB.D中存在结构性冒险。当MUL.D和DIVD准备好写入其结果时，这些表分别如表C-31和表C-32所示。

现在，我们可以研究一下为使每条指令能够继续，记分卡必须做些什么，以此来详细了解记分卡是如何工作的。表C-33说明，为使每条指令能够继续执行，记分卡需要些什么，并记录在指令继续执行时需要哪些必要的操作。记分卡记录操作数标志符信息，比如寄存器编号。例如，在发射指令时，必须记录源寄存器。因为我们将寄存器的内容称为Regs[D]，其中D为寄存器名称，所以不存在模糊性。例如，Fj[FU]←S1会导致寄存器名称S1被放在Fj[FU]中，而不是寄存器S1的内容。

记分卡的成本和收益也是人们的关注点。CDC 6600设计师测量到FORTRAN程序的性能改进因数为1.7，对于人工编码的汇编语言改进因数为2.5。但是，这些数据是在软件流水线调度、半导体主存储器和缓存（缩短了存储器访问时间）之前的那一时期测得的。CDC 6600上记分卡所拥有的逻辑数与一个功能单元相当，这是相当低的。主要成本在于存在大量总线——其数量大约是CPU循序执行（或者每个执行周期仅启动一条执行）时所需数量的四倍。人们近来对动态调度的关注有所增加，其目的就是希望在每个时钟周期内发射更多条指令（反正都要支付增加总线带来的成本），一些很自然地以动态调度为基础的思想也是提升此关注度的推动因素。记分卡利用可用ILP，在最大程度上降低因为程序真数据相关所导致的停顿数目。在消除停顿方面，记分卡受以下几个因素的影响。

（1）指令间可用并行数——这一因素决定了能否找到要执行的独立指令。如果每条指令都依赖于它前面的指令，那就找不到减少停顿的动态调度方案。如果必须从同一基本模块中选择同时存在于流水线中的指令（在6600中就是如此），那这一限制是 十分严重的。

（2）记分卡的项数——这一因素决定 了流水线为了查找不相关指令可以向前查找多少条指令。这组作为潜在执行对象的指令被称为窗口。记分卡的大小决定了窗口的大小。在这一节，我们假定窗口不会超过一个分支，所以窗口（及记分卡）总是包含来自单个基本模块的直行代码。第3章说明如何将窗口扩展到超出一个分支之外。

（3）功能单元的数目和类型——这一因素决定 了结构性冒险的重要性，它可能会在使用动态调度时增加。

（4）存在反相关和输出相关——它们会 导致WAR和WAW停顿。

谬论与易犯错误

乍看起来，WAW冒险似乎永远不可能在一个代码序列中出现，因为没有哪个编译器会生成对同一寄存器的两次写入操作，却在中间没有读取操作，但当序列出乎意料之外时，却可能发生WAW冒险。例如，第一次写入操作可能在-个选中分支的延迟时隙中，而调度器认为该分支未被选中。下面是可能导致这一情景的代码序列:

1
2
3
4

        BNEZ R1 , foo
        DIV.D F0,F2,F4 ;从未被选中移入延迟时隙
...
foo:    L.D   F0,qrs

向量、SIMD和GPU体系结构中的数据级并行

引言

由于单条指令可以启动许多数据运算，所以SIMD在能耗效率方面可能要比多指令多数据（MIMD）更高效一些，MIMD每进行一次数据运算都需要提取和执行一条指令。 这两个答案使SIMD对于个人移动设备极具吸引力。最后，SMID与MIMD相比的最大优势可能就是：由于数据操作是并行的，所以程序员可以采用顺序思维方式但却能获得并行加速比。

本章介绍SIMD的3种变体：向量体系结构、多媒体SIMD指令集扩展和图形处理单元（GPU）。

第一种变体的出现要比其他两个早30年以上，它实际上就是以流水线形式来执行许多数据操作。与其他SIMD变体相比，这些向量体系结构更容易理解和编译，但过去一直认为它们对于微处理器来说太过昂贵了，这一看法直到最近才有所改变。这种体系结构的成本，一部分用在晶体管上，另一部分用于提供足够的DRAM带宽，因为它广泛依赖于缓存来满足传统微处理器的存储器性能要求。

第二种SIMD变体借用SIMD名称来表示基本同时进行的并行数据操作，在今天支持多媒体应用程序的大多数指令集体系结构中都可以找到这种变体。x86体系结构的SIMD指令扩展是在1996年以MMX（多媒体扩展）开始的，在接下来的10年间出现了几个SSE（流式SIMD扩展）版本，一直发展到今天的AVX （高级向量扩展）。为了使x86计算机达到最高计算速度，通常需要使用这些SIMD指令，特别是对于浮点程序。

SIMD的第三种变体来自GPU社区，它的潜在性能要高于当今传统多核计算机的性能。尽管GPU的一些特征与向量体系结构相同，但它们有自已的一些独特特征，部分原因在于它们的发展生态系统。在GPU的发展环境中，除了GPU及其图形存储器之外，还有系统处理器和系统存储器。事实上，为了辨识这些差别，GPU社区将这种体系结构称为异类。

对于拥有大量数据并行的问题，所有这三种SIMD变体都有一个共同的好处：与经典的并行MIMD编程相比，程序员的工作更轻松-些。为了对比SIMD与MIMD的重要性，图4-1绘制了x86计算机中MIMD的核心数与SIMD模式中每个时钟周期的32位及64位运算数随时间的变化曲线。

对于x86计算机，我们预期每个芯片上每两年增加两个核心，SIMD 的宽度每四年翻一番。给定这些假设，在接下来的10年里，由SIMD并行获得的潜在加速比为MIMD并行的两倍。因此，尽管MIMD并行最近受到的关注要多得多，但理解SIMD并行至少与理解MIMD并行一样重要。对于同时具有数据级并行和线程级并行的应用程序，2020年的潜在加速比将比今天的加速比高一个数量级。

向量体系结构

执行可向量化应用程序的最高效方法就是向量处理器。

向量体系结构获得在存储器中散布的数据元素集，将它们放在一些大型的顺序寄存器堆中，对这些寄存器堆中的数据进行操作，然后将结果放回存储器中。一条指令对数据向量执行操作，从而会对独立数据元素进行数十个“寄存器-寄存器”操作。

这些大型寄存器堆相当于由编译器控制的缓冲区，一方面用于隐藏存储器延迟，另一方面用于充分利用存储器带宽。由于向量载入和存储是尝试流水化的，所以这个程序仅在每个向量载入或存储操作中付出较长的存储器延迟时间，而不需要在载入或存储每个元素时耗费这一时间，从而将这一延迟时间分散在比如64个元素上。事实上，向量程序会尽力使存储器保持繁忙状态。

VMIPS

我们首先看一个向量处理器，它由图4-2所示的主要组件组成。这个处理器大体以Cray-1为基础，它是本节讨论的基础。我们将这种指令集体系结构称为VMIPS；它的标量部分为MIPS，它的向量部分是MIPS的逻辑向量扩展。这一小节的其他部分研究VMIPS的基本体系结构与其他处理器有什么关系。

VMIPS的基本结构。这一处理器拥有类似于MIPS的标量体系结构。它还有8个64元素向量寄存器，所有功能单元都是向量功能单元。这一章为算术和存储器访问定义了特殊的向量指令。图中显示了用于逻辑运算与整数运算的向量单元，所以VMIPS看起来像是一种通常包含此类单元的标准向量处理器；但是，我们不会讨论这些单元。这些向量与标量寄存器有大量读写端口，允许同时进行多个向量运算。一组交叉交换器(粗灰线)将这些端口连接到向量功能单元的输入和输出

VMIPS指令集体系结构的主要组件如下所示。

• 向量寄存器——每个向量寄存器都是一个固定长度的寄存器组，保存一个向量。VMIPS有8个向量寄存器，每个向量寄存器保留64个元素，每个元素的宽度为64位。向量寄存器堆需要提供足够的端口，向所有向量功能单元馈送数据。这些端口允许将向量操作高度重叠，发送到不同向量寄存器。利用一对交叉交换器将读写端口(至少共有16个读取端口和8个写入端口)连接到功能单元的输入或输出。
• 向量功能单元——每个单元都完全实现流水化，它可以在每个时钟周期开始一个新的操作。需要有个控制单元来检测冒险，既包括功能单元的结构性冒险，又包括关于寄存器访问的数据冒险。图4-2显示VMIPS有5个功能单元。为简单起见，我们仅关注浮点功能单元。
• 向量载入/存储单元——这个向量存储器单元从存储器中载入向量或者将向量存储到存储器中。VMIPS向量载入与存储操作是完全流水化的，所以在初始延迟之后，可以在向量寄存器与存储器之间以每个时钟周期一个字的带宽移动字。这个单元通常还会处理标量载入和存储。
• 标量寄存器集合——标量寄存器还可以提供数据，作为向量功能单元的输入，还可以计算传送给向量载入存储单元的地址。它们通常是MIPS的32个通用寄存器和32个浮点寄存器。在从标量寄存器堆读取标量值时，向量功能单元的一个输入会闩锁住这些值。

表4-1列出了VMIPS向量指令。在VMIPS中，向量运算使用的名字与标量MIPS指令的名字相同，但后面追加了字母“VV”。 因此，ADVV.D就是两个双精度向量的加法。向量指令的输入或者为一对向量寄存器(ADDVV.D)，或者为一个向量寄存器和一个标量寄存器，通过附加“VS”来标识(ADDVS.D)。在后一种情况下，所有操作使用标量寄存器的相同值来作为一个输入：运算ADDVS.D将向量寄存器中的每个元素都加上标量寄存器的内容。向量功能单元在发射时获得标量值的一个副本。大多数向量运算有一个向量目标寄存器，尽管其中一些(比如入口计数)会产生标量值，这个值将存储在标量寄存器中。

除了向量寄存器外，还有两个特殊寄存器VLR和VM，下面将进行讨论。这些特殊寄存器假定存在子MIPS协处理器1空间中，与FPU寄存器位于一起。后面将解释带有步幅的运算以及索引创建及索引载入/存储操作的应用。

名字LV和SV表示向量载入和向量存储，它们载入或存储整个双精度数据向量。一个操作数是要载入或存储的向量寄存器，另一个操作数是MIPS通用寄存器，它是该向量在存储器中的起始地址。后面将会看到，除了这些向量寄存器之外，我们还需要两个通用寄存器：向量长度寄存器和向量遮罩寄存器。当向量长度不是64时使用前者，当循环中涉及IF语句时使用后者。

功率瓶颈使架构师非常看重具有以下特点的体系结构：一方面能够提供高性能，另一方面又不需要高度乱序超标量处理器的能耗与设计复杂度。向量指令天生就与这一趋势吻合，架构师可以用它们来提高简单循序标量处理器的性能，而又不会显著增大能耗要求和设计复杂度。在实践中，开发人员可以采用向量指令的方式来表达许多程序，采用数据级并行可以很高效地在复杂乱序设计中运行。

采用向量指令，系统可以采用许多方式对向量数据元素进行运算，其中包括对许多元素同时进行操作。因为有了这种灵活性，向量设计可以采用慢而宽的执行单元，以较低功率获得高性能。此外，向量指令集中各个元素是相互独立的，这样不需要进行成本高昂的相关性检查就能调整功能单元，而超标量处理器是需要进行这检查的。

向量本身就可以容纳不同大小的数据。因此，如果一个向量寄存器可以容纳64个64位元素，那同样可以容纳128个32位元素、256个16位元素，甚至512个8位元素。向量体系结构之所以既能用于多媒体应用，又能用于科学应用，就是因为具备这种硬件多样性。

向量处理器如何工作：一个示例

通过查看VMIPS的向量循环，可以更好地理解向量处理器。让我们来看一个典型的向量问题，在本节将一直使用这个例子：

1

Y=a × X + Y

现在假定向量寄存器的元素数或者说其长度为64，与我们关心的向量运算长度匹配。(稍后将取消这一限制。)

给出DAXPY循环的MIPS和VMIPS代码。假定X和Y的起始地址分别为Rx和Ry。

MIPS代码如下。

1
2
3
4
5
6
7
8
9
10
11

        L.D       F0,a        ;载入标量a
        DADDIU    R4,Rx,#512  ;要载入的最后地址
Loop：  L.D       F2,0(Rx)    ;载入X[i] 
        MUL.D     F2,F2,F0    ;ax X[i]
        L.D       F4,0(Ry)    ;载入Y[i]
        ADD.D     F4,F4,F2    ;axX[i] + YEi]
        S.D       F4,9(Ry)    ;存储到Y[i]
        DADDIU    Rx,Rx,#8    ;递增X的索引
        DADDIU    Ry,Ry,#8    ;递增Y的索引
        DSUBU     R20,R4,Rx   ;计算范围.
        BNEZ      R20, Loop   ;检查是否完成.

1
2
3
4
5
6

L.D       F0,a        ;载入标量a
LV        V1,R        ;载入向量X
MULVS.D   V2,V1,F0    ;向量-标量乘
LV        V3,Ry       ;载入向量Y
ADDVV.D   V4,V2,V3    ;相加
SV        V4,Ry       ;存储结果

MIPS与VMIPS之间的另一个重要区别是流水线互锁的频率。在简单的MIPS代码中，每个ADD.D都必须等待MUL.D，每个S.D都必须等待ADD.D。在向量处理器中，每个向量指令只会因为等待每个向量的第一个元素而停顿，然后后续元素会沿着流水线顺畅流动。因此，每条向量指令仅需要一次流水线停顿，而不是每个向量元素需要一次。向量架构师将元素相关操作的转发称为链接(chaining)，因为这些相关操作是被“链接”在一起的。在这个例子中，MIPS中的流水线停顿频率大约比VMIPS高64倍。软件流水线或循环展开可以减少MIPS中的流水线停顿，但很难大幅缩减指令带宽方面的巨大差别。

向量执行时间

向量运算序列的执行时间主要取决于3个因素：(1)操作数向量的长度；(2)操作之间的结构冒险；(3)数据相关。给定向量长度和初始速率(初始速率就是向量单元接受新操作数并生成新结果的速率)，我们可以计算一条向量指令的执行时间。所有现代向量计算机都有具备多条并行流水线(或车道)的向量功能单元，它们在每个时钟周期可以生成两个或更多个结果，但这些计算机还可能拥有一些未完全流水化的功能单元。为简便起见，我们的VMIPS实现方式有一条车道，各个操作的初始速率为每个时钟周期一个元素。 因此，一条向量指令的执行时间(以时钟周期为单位)大约就是向量长度。

为了简化对向量执行和向量性能的讨论，我们使用了一种护航指令组(convoy)的概念，它是一组可以一直执行的向量指令。稍后可以看到，我们可以通过计算护航指令组的数目来估计一段代码的性能。护航指令组中的指令不能包含任何结构性冒险，如果存在这种冒险，则需要在不同护航指令组中序列化和启动这些指令。为了保持分析过程的简单性，假定在开始执行任意其他指令(标量或向量)之前，护航指令都必须已经完成。

除了具有结构性冒险的向量指令序列之外，具有写后读相关冒险的序列也应该位于不同护航指令组中，但通过链接操作可以允许它们位于同一护航指令组中。链接操作允许向量操作在其向量源操作数的各个元素变为可用状态之后立即启动：链中第一个功能单元的结果被“转发”给第二个功能单元。在实践中经常采用以下方式来实现链接：

允许处理器同时读、写一个特定的向量寄存器，不过读写的是不同元素。早期的链接实现类似于标量流水线中的转发，但这限制了链中源指令与目标指令的定时。最近的链接实现采用灵活链接，这种方式允许向量指令链接到几乎任意其他活动向量指令，只要不生成结构性冒险就行。所有现代向量体系结构都支持灵活链接，这也是本章的假设之一。

为了将护航指令组转换为执行时间，我们需要有一种定时度量，用来估计护航指令组的时间。这种度量被称为钟鸣(chime)，就是执行护航指令组所花费的时间单位。执行由m个护航指令组构成的向量序列需要m次钟鸣。当向量长度为n时，对于VMIPS来说，大约为mxn个时钟周期。钟鸣近似值忽略处理器特有的一些开销，许多此类开销都依赖于向量长度。因此，以钟鸣为单位测量时间时，对于长向量的近似要优于对短向量的近似。我们将使用钟鸣测量结果(而不是每个结果的时钟周期)，用来明确表示忽略了特定的开销。

如果知道向量序列中的护航指令组数，那就知道了用钟鸣表示的执行时间。在以钟鸣为单位测试执行时间时，所忽略的一个开销源是对单个时钟周期内启动多条向量指令的限制。如果在一个时钟周期内只能启动一条向量指令(大多数向量处理器都是如此)，那钟鸣数会低估护航指令组的实际执行时间。由于向量的长度通常远大于护航指令组中的指令数，所以简单地假定这个护航指令组是在一次钟鸣中执行的。

给出以下代码序列在护航指令组中是如何排列的，假定每个向量功能单元只有一个副本：

1
2
3
4
5

LV        V1,Rx      ;载入向量X
MULVS.D   V2,V1,FO   ;向量-标量乘
LV        V3,Ry      ;载入向量Y
ADDVV.D   V4,V2,V3   ;两个向量相加
SV        V4,Ry      ;存储所得之和

第一个护航指令组从第一个LV指令处开始。MULVS.D依赖于第一个LV，但链接操作允许它位于同一护航指令组中。第二个LV指令必须放在另一个护航指令组中，因为它与上一个LV指令的载入存储单元存在结构性冒险。ADDVV.D 与第二个LV相关，但它也可以通过链接操作位于同一护航指令组中。最后，SV与第二个护航指令组中的LV存在结构冒险，所以必须把它放在第三护航指令组中。通过这一分析，将得出向量指令在护航指令组的如下排列：

1
2
3

1. LV     MULYS.D
2. LV     ADDVV.D
3. SV

另一个开销源要比发射限制明显得多。钟鸣模型中忽略的最重要开销源就是向量启动时间。启动时间主要由向量功能单元的流水线延迟决定。对于VMIPS，我们使用与Cray-1相同的流水线深度，不过在更多的现代处理器中，这些延迟有增加的趋势，特别是向量载入操作的延迟。所有功能单元都被完全流水化。浮点加的流水线深度为6个时钟周期、浮点乘为7个、浮点除为20个、向量载入为12个。

有了这些向量基础知识之后，接下来的几小节将介绍一些优化方式，或者用来提高性能，或者增加可以在向量体系结构中完美运行的程序类型。具体来说，它们将回答如下问题。

• 向量处理器怎样执行单个向量才能快于每个时钟周期一个元素？每个时钟周期处理多个元素可以提高性能。
• 向量处理器如何处理那些向量长度与向量寄存器长度(对于VMIPS，此长度为64)不相同的程序？由于大多数应用程序向量与体系结构向量长度不匹配，所以需要一种高效的解决方案来处理这一常见情景。
• 如果要向量化的代码中含有If语句，会发生什么？如果可以高效地处理条件语句，就能向量化更多的代码。
• 向量处理器需要从存储器系统中获得什么?没有充分的存储器带宽，向量执行可能会徒劳无益。
• 向量处理器如何处理多维矩阵?为使向量体系结构能够很好地工作，必须对这个常见数据结构进行向量化。
• 向量处理器如何处理稀疏矩阵?这一常 见数据结构也必须进行向量化。
• 如何为向量计算机进行编程?如果体系结构方面的创新不能与编译器技术相匹配，那可能不会被广泛应用。

多条车道：每个时钟周期超过一个元素

向量指令集的一个重要好处是它允许软件仅使用一条很短的指令就能向硬件传送大量并行任务。一条向量指令可以包含数十个独立运算，而其编码使用的位数与一条传统的标量指令相同。向量指令的并行语义允许实现方式在执行这些元素运算时使用：深度流水化的功能单元(就像我们目前研究过的VMIPS实现方式一样)；一组并行功能单元；或者并行与流水线功能单元的组合方式。图4-3说明如何使用并行流水线来执行一个向量加法指令，从而提
高向量性能。

图4-3 使用多个功能单元提高单个向量加法指令C=A+B的性能。左边的向量处理器(a)有一条加法流水线，每个时钟周期可以完成一次加法。右边的向量处理器(b)有4条加法流水线，每个时钟周期可以完成4次加法。一条向量加法指令中的元素交错存在于4条流水线中。通过这些流水线结合在一起的元素集被称为元素组

VMIPS指令集有一个特性：所有向量算术指令只允许一个向量寄存器的元素N与其他向量寄存器的元素N进行运算。这一特性极大地简化了一个高度并行向量单元的构造，将其结构设定为多个并行车道。和高速公路一样，我们可以通过添加更多车道来提高向量单元的峰值吞吐量。图4-4给出了一种四车道向量单元的结构。这样，从单车道变为四车道之后，将一次钟鸣的时钟周期数由64个变为16个。由于多车道非常有利，所以应用程序和体系结构都必须支持长向量；否则，它们的快速执行速度会耗尽指令带宽。

图4-4 包含4个车道的向量t单元的结构。向量寄存器存储分散在各个车道中，每个车道保存每个向量寄存器每4个元素中的1个。此图显示了三个向量功能单元：一个浮点加法、一个浮点乘法和一个载入-存储单元。向量算术单元各包含4条执行流水线，每个车道1条，它们共同完成一条向量指令。注意，向量寄存器堆的每一部分只需要为其车道本地的流水线提供足够的端口即可。

每个车道都包含向量寄存器堆的一部分和来自每个向量功能单元的一个执行流水线。每个向量功能单元使用多条流水线，以每个时钟周期一个元素组的速度执行向量指令，每个车道一条流水线。第一个车道保存所有向量寄存器的第一个元素(元素0)，所以任何向量指令的第一个元素都会将其源操作数与目标操作数放在第一车道中。这种分配方式使该车道本地的算术流水线无须与其他车道通信就能完成运算。主存储器的访问也只需要车道内的连接。邇过避免车道间的通信减少了构建高并行执行单元所需要的连接成本与寄存器堆端口，有助于解释向量计算机为什么能够在每个时钟周期内完成高达64个运算(跨越16个车道的2个算术单元和2个载入存储单元)。

增加多个车道是一种提高向量性能的常见技术，它不需要增加太多控制复杂性，也不需要对现有机器代码进行修改。它还允许设计人员在晶片面积、时钟频率、电压和能耗之间进行权衡，而且不需要牺牲峰值性能。如果向量处理器的时钟频率减半，只需要使车道数目加倍就能保持原性能。

向量长度寄存器：处理不等于64的循环

向量寄存器处理器有一个自然向量长度，这一长度由每个向量寄存器中的元素数目决定。对于VMIPS来说，这一长度为64，它不大可能与程序中的实际向量长度相匹配。此外，在实际程序中，特定向量运算的长度在编译时通常是未知的。事实上，一段代码可能需要不同的向量长度。例如，考虑以下代码：

1
2

for(i = 0; i < n; i = i + 1)
    Y[] = a * X[i] + Y[i];

对这些问题的解决方案就是创建一个向量长度寄存器(VLR)。VLR控制所有向量运算的长度，包括向量载入与存储运算。但VLR中的值不能大于向量寄存器的长度。只要实际长度小于或等于最大向量长度(MVL)，就能解决上述问题。MVL确定了体系结构的一个向量中的数据元素数目。这个参数意味着向量寄存器的长度可以随着计算机的发展而增大，不需要改变指令集；

如果n的值在编译时未知，从而可能大于MVL，那该怎么办呢？为了解决向量长于最大长度的第二问题，可以使用一种名为条带挖掘(strip mining)的技术。条带挖掘是指生成一些代码，使每个向量运算都是针对小于或等于MVL的大小来完成的。我们创建两个循环，一个循环处理迭代数为MVL倍数的情况，另一个循环处理所有其他迭代及小于MVL的情况。在实践中，编译器通常会生成一个条带挖掘循环，为其设定一个参数，通过改变长度来处理这两种情况。我们以C语言给出DAXPY循环的条带挖掘版本：

1
2
3
4
5
6
7

low = 0;
VL = (n%MVL); /*使用求模运算%找出不规则大小部分*/
for (j = 0; j <= (n/MVL); j = j + 1) { /*外层循环*/
    for (i = low; i < (1ow+VL); i = i + 1) /*执行长度VL */
        Y[i] = a * X[i] + Y[i];/*主运算*/
    low = low + VL; /*开始下一个向量*/
VL = MVL; /*将长度复位为最大向量长度*/

图4-5 用条带处理的任意长度的向量。除第一块外，所有其他块的长度都是MVL，充分利用了向量处理器的功能。本图中使用变量m来表示表达式(n%MVL)，以上代码的内层循环可以进行向量化，长度为VL，或者等于(n%MVL)，或者等于MVL。在此代码中，必须对VLR寄存器设置两次，也就是在代码中为变量VL进行赋值时各设置一次。

向量遮罩寄存器：处理向量循环中的IF语句

根据Amdahl定律，我们知道对于中低向量化级别的程序，加速比是非常有限的。循环内部存在条件(IF语句)稀疏矩阵是向量化程度较低的两个主要原因。如果程序的循环中包含IF语句，由于IF语句会在循环中引入控制相关，所以不能使用前面讨论的技术以向量模式运行这种程序。同样，利用前面看到的各项功能也不能高效地实现稀疏矩阵。我们现在将讨论处理条件执行的策略，稀疏矩阵留待后文讨论。考虑以C语言编写的以下循环：

1
2
3

for(i = 0; i < 64; i = i + 1)
    if (X[i] != 0)
        x[i] = X[i] - Y[i];

1
2
3
4
5
6

LV      V1,Rx      ;将向量X载入V1
LV      V2,Ry      ;载入向量Y
L.D     F0,#0      ;将浮点零载入F0
SNEYS.D V1,F0      ;若Vl(i)!=F0,则将VM(i)设置为1
SUBVV.D V1,V1,V2   ;在向量t遮罩下执行减法
SV      V1,Rx      ;将结果存到X中

在4.4节将会看到，向量处理器与GPU之间的一个区别就是它们处理条件语句的方式不同。向量处理器将遮罩寄存器作为体系结构状态的一部分，依靠编译器来显式操控遮罩寄存器。而GPU则是使用硬件来操控GPU软件无法看到的内部遮罩寄存器，以实现相同效果。在这两种情况下，无论遮罩是1还是0，硬件都需要花费时间来执行向量元素，所以GFLPS速率在使用遮罩时会下降。

内存组：为向量载入/存储单元提供带宽

载入存储向量单元的行为要比算术功能单元的行为复杂得多。载入操作的开始时间就是它从存储器向寄存器中载入第一个字的时间。如果在无停顿情况下提供向量的其他元素，那么向量初始化速率就等于提取或存储新字的速度。这一初始化速率不一定是一个时钟周期，因为存储器组的停顿可能会降低有效吞吐量，这一点不同于较简单的功能单元。

一般情况下，载入存储单元的起始代价要高于算术单元的这一代价——在许多处理器中要多于100个时钟周期。对于VMIPS，我们假定起始时间为12个时钟周期，与Cray-1相同。(最近的向量计算机使用缓存来降低向量载入与存储的延迟。)为了保持每个时钟周期提取或存储一个字的初始化速率，存储器系统必须能够生成或接受这么多的数据。将访问对象分散在多个独立的存储器组中，通常可以保证所需速率。稍后将会看到，拥有大量存储器组可以很高效地处理那些访问多行或多列数据的向量载入或存储指令。

大多数向量处理器都使用存储器组，允许进行多个独立访问，而不是进行简单的存储器交错，其原因有以下3个。

• 许多向量计算机每个时钟周期可以进行多个载入或存储操作，存储器组的周期时间通常比处理器周期时间高几倍。为了支持多个载入或存储操作的同时访问请求，存储器系统需要有多个组，并能够独立控制对这些组的寻址。
• 大多数向量处理器支持载入或存储非连续数据字的功能。在此类情况下，需要进行独立的组寻址，而不是交叉寻址。
• 大多数向量计算机支持多个共享同-存储器系统的处理器，所以每个处理器会生成其自己的独立寻址流。

这些特征综合起来，就有了大量的独立存储器组，如下例所示。

Cray T90 (Cray T932)的最高配置有32个处理器，每个处理器每个时钟周期可以生成4个载入操作和2个存储操作。处理器时钟周期为2.167 ns，而存储器系统所用SRAM的周期时间为15 ns。计算：为使所有处理器都以完全存储器带宽运行，最少需要多少个存储器组。

每个时钟周期产生的最大存储器引用数目为192：每个处理器每个时钟周期产生6次引用共32个处理器。每个SRAM组的繁忙时钟周期数为15/2.167=6.92，四舍五入为7个处理器时钟周期。因此，至少需要192 x 7= 1344个存储器组！Cray T932实际上有1024个存储器组，所以早期型号不能让所有处理器都同时维持完全带宽。后来对存储器进行升级时，用流水化同步SRAM代替了15 ns的异步SRAM，存储器周期时间缩短一半，从而可以提供足够的带宽。

从更高一级的角度来看，向量载入存储单元与向量处理器中的预取单元扮演着类似的角色，它们都是通过向处理器提供数据流来尝试提供数据带宽。

步幅：处理向量体系结构中的多维数组

向量中的相邻元素在内存中的位置可能并不一定是连续的。考虑下面一段非常简单的矩阵乘法C语言代码：

1
2
3
4
5
6

for(i = 0; i < 100; i = i + 1) 
    for(j= 0; j < 100; j = j + 1) {
        A[i][j] = 0.0;
        for(k = 0; k < 100; k = k + 1)
            A[i][j] = A[i][j] + B[i][k] * D[k][j];
    }

为此，我们必须考虑如何对B中的相邻元素及D中的相邻元素进行寻址。在为数组分配内存时，该数组是线性化的，其排序方式要么以行为主(如C语言)，要么以列为主(如Fortran语言)。这种线性化意味着：要么行中的元素在内存中不相邻，要么列中的元素在内存中不相邻。例如，上面的C代码是按照以行为主的排序来分配内存的，所以内层循环中各次迭代在访问D元素时，这些元素之间的间隔等于行大小乘以8 (每一项的字节数)，共为800个字节。在第2章中，我们已经知道在基于缓存的系统中通过分层有可能提高局域性。对于没有缓存的向量处理器，需要使用另一种方法来提取向量在内存中不相邻的元素。

对于那些要收集到一个寄存器中的元素，它们之间的距离称为步幅。在这个例子中，矩阵D的步幅为100个双字(800个字节)，矩阵B的步幅可能为1个双字(8个字节)。对于以列为主的排序(Fortran语言采用这一顺序)，这两个步幅的大小会颠倒过来。矩阵D的步幅为1，也就是说连续元素之间相隔1个双字(8个字节)，而矩阵B的步幅为100，也就是100个双字(800个字节)。因此，如果不对循环进行重新排序，编译器就不能隐藏矩阵B和D中连续元素之间的较长距离。

将向量载入向量寄存器后，它的表现行为就好像它的元素在逻辑上是相邻的。仅利用具有步幅功能的向量载入及向量存储操作，向量处理器可以处理大于1的步幅，这种步幅称为非单位步幅。向量处理器的主要优势之一就是能够访问非连续存储器位置，并对其进行调整，放到一个密集结构中。缓存在本质上是处理单位步幅数据的。增大块大小有助于降低大型科学数据集(其步幅为单位步幅)的缺失率，但增大块大小也可能会对那些以非单位步幅访问的数据产生负面影响。尽管分块技术可以解决其中一些问题，但高效访问非连续数据的功能仍然是向量处理器的一个优势。

在VMIPS结构中，可寻址单位为1个字节，所以我们示例的步幅将为800。由于矩阵的大小在编译时可能是未知的，或者就像向量长度一样，在每次执行相同语句时可能会发生变化，所以必须对步幅值进行动态计算。向量步幅可以和向量起始地址一样，放在通用寄存器中。然后，VMIPS指令LVWS (load vector with stride)将向量提取到向量寄存器中。同样，在存储非单位步幅向量时，使用指令SVwS (store vector with stride)。为了支持大于1的步幅，会使存储器系统变得复杂。在引入非单位步幅之后，就有可能频繁访问同一个组。当多个访问对一个存储器组产生竞争时，就会发生存储器组冲突，从而使某个访问陷入停顿。如果满足以下条件则会产生组冲突，从而产生停顿。

组数/步幅与组数的最小公倍数 < 组繁忙时间

假定有8个存储器组，组繁忙时间为6个时钟周期，总存储器延迟为12个时钟周期。要以步幅1完成一个64元素的向量载入操作，需要多长时间？步幅为32呢？

由于组数大于组繁忙时间，所以当步幅为1时，该载入操作将耗费12+64=76个时钟周期，也就是每个元素需要1.2个时钟周期。最糟糕的步幅是存储器组数目的倍数，在本例中就是步幅为32、存储器组为8的情况。(在第一次访问之后，)对存储器的每次访问都会与上一次访问发生冲突，必须等候长度为6个时钟周期的组繁忙时间。总时间为12+1+6x63=391个时钟周期，即每个元素6.1个时钟周期。

集中-分散：在向量体系结构中处理稀疏矩阵

前面曾经提到，稀疏矩阵是很常见的，所以非常需要一些技术，能够以向量模式运行那些处理稀疏矩阵的程序。在稀疏矩阵中，向量的元素通常以某种紧凑形式存储，然后对其进行间接访问。假定有一种简化的稀疏结构，我们可能会看到类似下面的代码：

1
2

for(i = 0; i < n; i = i + 1)
    A[K[i]] = A[K[i]] + C[M[i]];

1
2
3
4
5
6

LV      Vk, Rk        ;载入K
LVI     Va,(Ra+Vk)    ;载入A[K[]]
LV      Vm,Rm         ;载入M
LVI     VC, (Rc+Ym)   ;载入C[M[]]
ADDVV.D Va, Va, Vc    ;求和
SVI     (Ra+Vk), Va   ;存储A[K[]]

向量体系结构编程

向量体系结构的优势在于编译器可以在编译时告诉程序员：某段代码是否可以向量化，通常还会给出一些暗示，说明这段代码为什么不能向量化。这种简单的执行模型可以让其他领域的专家了解如何通过修改自己的代码来提高性能。

让我们看一下在Perfect Club基准测试中观测到的向量化水平，用以指示科学程序中所能实现的向量化水平。表4-2显示了两种代码版本在Cray Y-MP上运行时，以向量模式运行的运算比例。第一个版本仅对原代码进行了编译器优化，而第二个版本则利用了Cray Research程序员团队给出的一些提示。对向量处理器上的应用程序性能进行多次研究后发现，编译器向量化水平的变化范围很大。

对于编译器自身不能很好地完成向量化的代码来说，根据大量提示进行修改后的版本会大幅提高向量化水平，现在有超过50%的代码可以进行向量化了。平均向量化水平从大约70%提高至大约90%。

SIMD 指令集多媒体扩展

SIMD多媒体扩展源于一个很容易观察到的事实：许多媒体应用程序操作的数据类型要比对32位处理器进行针对性优化的数据类型更窄一些。假定有一个256位加法器，通过划分这个加法器中的进位链，处理器可以同时对一些短向量进行操作，这些向量可以是32个8位操作数、16个16位操作数、8个32位操作数或者4个64位操作数。这些经过划分的加法器的额外成本很小。表4-3总结了典型的多媒体SIMD指令。和向量指令一样，SIMD指令规定了对数据向量的相同操作。一些向量机器拥有大型寄存器堆，比如VMIPS向量寄存器，8个向量寄存器中的每一个都可以保存64个64位元素，SIMD指令与之不同，它指定的操作数较少，因此使用的寄存器堆也较小。

向量体系结构专门针对向量化编译器提供了一流的指令集，与之相对，SIMD扩展主要进行了以下3项简化。

• 多媒体SIMD扩展固定了操作代码中数据操作数的数目，从而在x86体系结构的MMX、SSE和AVX扩展中添加了数百条指令。向量体系结构有一个向量长度寄存器，用于指定当前操作的操作数个数。一些程序的向量长度小于体系结构的最大支持长度，由于这些向量寄存器的长度可以变化，所以也能够很轻松地适应此类程序。此外，向量体系结构有一个隐含的最大向量长度，它与向量长度寄存器相结合，可以避免使用大量操作码。
• 多媒体SIMD没有提供向量体系结构的更复杂寻址模式，也就是步幅访问和集中分散访问。这些功能增加了向量编译器成功向量化的程序数目。
• 多媒体SIMD通常不会像向量体系结构那样，为了支持元素的条件执行而提供遮罩寄存器。这些省略增大了编译器生成SIMD代码的难度，也加大了SIMD汇编语言编程的难度。

对于x86体系结构，1996年增加的MMX指令重新确定了64位浮点寄存器的用途，所以基本指令可以同时执行8个8位运算或4个16位运算。这些指令与其他各种指令结合在一起，包括并行MAX和MIN运算、各种遮罩和条件指令、通常在数字信号处理器中进行的运算以及人们相信在重要媒体库中有用的专用指令。注意，MMX重复使用浮点数据传送指令来访问存储器。

1999年推出的后续流式SIMD扩展(SSE)添加了原来宽128位的独立寄存器，所以现在的指令可以同时执行16个8位运算、8个16位运算或4个32位运算。它还执行并行单精度浮点运算。由于SSE拥有独立寄存器，所以它需要独立的数据传送指令。Intel 很快在2001年的SSE2、2004 年的SSE3和2007年的SSE4中添加了双精度SIMD浮点数据类型。拥有四个单精度浮点运算或两个并行双精度运算的指令提高了x86计算机的峰值浮点性能，只要程序员将操作数并排放在一起即可。在每一代计算机中都添加了一些专用指令，用于加快一些重要的特定多媒体功能的速度。

2010年增加的高级向量扩展(AVX)再次将寄存器的宽度加倍，变为256位，并提供了一些指令，将针对所有较窄数据类型的运算数目翻了一番。表4-4给出了可用于进行双精度浮点计算的AVX指令。AVX进行了一些准备工作，以便在将来的体系结构中将宽度扩展到512位和1024位。

256位AVX的紧缩双精度是指以SIMD模式执行的4个64位操作数。当AVX指令的宽度增大时，数据置换指令的添加也变得更为重要，以允许将来自宽寄存器中不同部分的窄操作数结合起来。AVX 中的一些指令可以在256位寄存器中分散32位、64位或128位操作数。比如，BROADCAST在AVX寄存器中将一个64位操作数复制4次。AVC还包含大量结合在一起的乘加/乘减指令，这里仅给出了其中的两个。

一般来说，这些扩展的目的是加快那些精心编制的库函数运行速度，而不是由编译器来生成这些库，但近来的x86编译器正在尝试生成此类代码，尤其是针对浮点计算密集的应用程序。

既然有这些弱点，那多媒体SIMD扩展为什么还如此流行呢？第一，它们不需要花费什么成本就能添加标准算术单元，而且易于实施。第二，与向量体系结构相比，它们不需要什么额外状态，上下文切换次数总是要考虑这一因素。第三，需要大量存储器带宽来支持向量体系结构，而这是许多计算机所不具备的。第四，当一条能够生成64个存储器访问的指令在向量中间发生页面错误时，SIMD不必处理虚拟内存中的问题。SIMD扩展对于操作数的每个SIMD组使用独立的数据传送(这些操作数在存储器中是对齐的)，所以它们不能跨越页面边界。固定长度的简短SIMD“向量”还有另一个好处：能够很轻松地引入一些符合新媒体标准的指令，比如执行置换操作的指令或者所用操作数少于或多于所生成向量的指令。最后，人们还关注向量体系结构在使用缓存方面的表现。最近的向量体系结构已经解决了所有这些问题，但由于过去些缺陷的影响，架构师还是对向量抱有怀疑态度。

为了了解多媒体指令是什么样子的，假定我们向MIPS中添加了256位SIMD多媒体指令。在这个例子中主要讨论浮点指令。对于一次能够对4个双精度运箅数执行操作的指令添加后缀“4D”。 和向量体系结构一样，可以把SIMD处理器看作是拥有车道的处理器，在本例中为4个车道。MIPS SIMD会重复利用浮点寄存器，作为4D指令的操作数，就像原始MIP中的双精度运算重复利用单精度寄存器一样。这一示例显示了DAXPY循环的MIPS SIMD代码。假定X和Y的起始地址分别为Rx和Ry。用下划线划出为添加SIMD而对MIPS代码进行的修改。

下面是MIPS代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

        L.D        F0,a       ;载入标量a
        MOV        F1, FQ     ;将a复制到F1,以完成SIMD MUL
        MOV        F2, FQ     ;将a复制到F2,以完成SIMD MUL
        MOV        F3, F0     ;将a复制到F3,以完成SIMD MUL
        DADDIU     R4,Rx,#512 ;要载入的最后一个地址
Loop：  L.4D       F4,0(Rx)   ;载入X[i], X[i+1], X[i+2]，X[i+3]
        MUL.4D     F4.F4,F0   ;a.X[i], a*X[i+1],a*X[i+2], a*X[i+3]
        L.4D       F8,0(Ry)   ;载入Y[i], Y[i+1], Y[i+2]，Y[i+3]
        ADD.4D     F8,F8,F4   ;a*X[i]+Y[i], ..., a*X[i+3]+Y[i+3]
        S.4D       F8,0(Rx)   ;存储到Y[i], Y[i+1], Y[i+2], Y[i+3]
        DADDIU     Rx,Rx,#32  ;将索引递增至X
        DADDIU     Ry,Ry,#32  ;将索引递增至Y
        DSUBU      R20,R4,RX  ;计算范围
        BNEZ       R20,Loop   ;检查是否完成

多媒体SIMD体系结构编程

由于SIMD多媒体扩展的特有本质，使用这些指令的最简便方法就是通过库或用汇编语言编写。

最近的扩展变得更加规整，为编译器提供了更为合理的目标。通过借用向量化编译器的技术，这些编译器也开始自动生成SIMD指令。例如，目前的高级编译器可以生成SIMD浮点指令，大幅提高科学代码的性能。但是，程序员必须确保存储器中的所有数据都与运行代码的SIMD单元的宽度对齐，以防止编译器为本来可以向量化的代码生成标量指令。

Roofline 可视性能模型

有一种直观的可视方法可以对比各种SIMD体系结构变体的潜在浮点性能，那就是Roofline模型。它将浮点性能、存储器性能和运算密度汇总在一个两维图形中。运算密度等于浮点运算数与所访问存储器字节的比值。其计算方法为：获取一个程序的总浮点运算数，然后再除以在程序执行期间向主存储器传送的总数据字节。图4-6给出了几种示例内核的相对运算密度。

图4-6 运算密度，定义为：运行程序时所执行的浮点运算数除以在主存储器中访问的字节数。一些内核的运算密度会随问题的规模(比如密集矩阵)而缩放，但有许多核心的运算密度与问题规模无关

峰值浮点性能可以使用硬件规范求得。这一实例研究中的许多核心都不能放到片上缓存中，所以峰值性能是由缓存背后的存储器系统确定的。注意，我们需要的是可供处理器使用的蜂值存储器带宽。要求出峰值存储器性能，其中一种方法是运行Stream基准测试。

图4-7在左侧给出NEC SX-9向量处理器的Roofline模型，在右侧给出Intel Core i7 920多核计算机的相应模型。垂直的Y轴是可以实现的浮点性能，为2 ~ 256 GFLOP/s。水平的X轴是运算密度，在两个图中都是从1/8 FLOP/DARM访问字节到16 FLOP/DARM访向字节。注意，该图为对数-对数图尺，Roofline 对于一种计算机仅完成一次。对于一个给定内核，我们可以根据它的运算密度在X轴上找到一个点。如果过该点画一条垂线，此内核在该计算机上的性能必须位于该垂线上的某一位置。 我们可以绘制一个水平线，显示该计算机的浮点性能。显然，由于硬件限制，实际浮点性能不可能高于该水平线。

如何绘制峰值存储器性能呢?由于X轴为FLOP/字节，Y轴为FLOP/s，所以字节/s就是图中45度角的对角线。因此，我们可以画出第三条线，显示该计算机的存储器系统对于给定运算密度所能支持的最大浮点性能。我们可以用公式来表示这些限制，以绘制图4-7中的相应曲线：

可获得的GFLOP/s=Min(峰值存储器带宽x运算密度，峰值浮点性能)

图4-7 左为NEC SX-9向量处理器上的Rofine模型，右为采用SIMD扩展的Intel Core 1i7 920多核计算机的相应模型。 这个Roofie模型针对的单位步幅的存储器访问和双精度浮点性能。NEC SC-9是在2008 年发布的超级向量计算机，耗费了数百万美元。根据Stream基准测试，它的峰值DP FP性能为102.4 GFLOP/s，峰值存储器宽度为162GB/s。Core i7 920的峰值DP FP性能为42.66 GFLOP/s和峰值存储器带宽为16.4 GB/s。在运算密度为4FLOP/字节处的垂直虚线显示两个处理器都以峰值性能运行。在这个示例中，102.4 GFL0P/s处的Sx-9要比42.66 GFLOP/s处的Core i7快2.4倍。在运算密度为0.25 FLOP/字节处，SX-9 为40.5 GFLOP/s，比Corei7的4.1GFLOP/s快10倍

水平线和对角线给出了这个简单模型的名字，并指出了它的取值。Roofline 根据内核的运算密度设定了其内核的性能上限。如果我们把运算密度看作是触及房顶的柱子，它既可能触及房顶的平坦部分(表示这一性能是受计算功能限制的)，也可能触及房顶的倾斜部分(表示这一性能最终受存储器带宽的限制)。在图4-7中，右侧的垂直虚线(运算密度为4)是前者的示例，左侧的垂直虚线(运算密度为1/4)是后者的示例。给定一台计算机的Rooline模型，就可以重复应用它，因为它是不会随内核变化的。

注意对角线与水平线交汇的“屋脊点”，通过它可以深入了解这台计算机的性能。如果它非常靠右，那么只有运算密度非常高的内核才能实现这台计算机的最大性能。如果它非常靠左，那么几乎所有内核都可能达到最高性能。后面将会看到，与其他SIMD处理器相比，这个向量处理器的存储器带宽要高得多，屋脊点非常靠左。

图4-7显示sx-9的峰值计算性能比Core i7快2.4倍，但存储器性能要快10倍。对于运算密度为0.25的程序，sx-9 快10倍(40.5 GFLOP/s比4.1 GFLOP/s)。更宽的存储器带宽将屋脊点从Corei7的2.6移动到sx-9的0.6，这就意味着有更多的程序可以在这个向量处理器上达到峰值计算性能。

图形处理器

GPU和CPU在计算机体系结构谱系中不会上溯到同一个祖先，GPU的祖先是图形加速器，而极强的图形处理能力正是GPU得以存在的原因。尽管GPU正在转向主流计算领域，但它们不能放弃继续在图形处理领域保持优异表现的责任。因此，对于能够出色处理图形的硬件，当架构师询问应当如何进行补充才能提高更广泛应用程序的性能时，GPU的设计就可能体现出更重要
的价值。

GPU编程

关于如何表示算法中的并行，CUDA在某种方式上与我们的思考与编码方式相吻合，可以更轻松、更自然地表达超越任务级别的并行。

CPU程序员的挑战不只是在GPU上获得出色的性能，还要协调系统处理器与GPU上的计算调度、系统存储器与GPU存储器之间的数据传输。GPU几乎拥有所有可以由编程环境捕获的并行类型：多线程、MIMD、SIMD，甚至还有指令级并行。

NVIDIA决定开发一种与C类似的语言和编程环境，通过克服异质计算及多种并行带来的双重挑战来提高GPU程序员的生产效率。这一系统的名称为CUDA，表示“计算统一设备体系结构”(Compute Unifed Device Architecture)。CUDA为系统处理器(主机)生成C/C++，为GPU(设备，也就是CUDA中的D)生成C和C++方言。一种类似的编程语言是OpenGL。

NVIDIA认为，所有这些并行形式的统一主题就是CUDA线程。以这种最低级别的并行作为编程原型，编译器和硬件可以将数以千记的CUDA线程聚合在一起，利用CPU中的各种并行类型：多线程、MIMD、SIMD和指令级并行。因此，NVIDIA将CUDA编程模型定义为“单指令多线程”(SIMT)。这些线程进行了分块，在执行时以32个线程为一组，称为线程块。我们将执行整个线程块的硬件称为多线程SIMD处理器。

我们只需要几个细节就能给出CUDA程序的示例。

• 为了区分GPU(设备)的功能与系统处理器(主机)的功能，CUDA使用__device__或__global__表示前者，使用___host__表示后者。
• 被声明为__device__或__global__functions的CUDA变量被分配给GPU存储器(见下文)，可以供所有多线程SIMD处理器访问。
• 对于在GPU上运行的函数name进行扩展函数调用的语法为：name<<<dimGrid, dimBlock>>>(... parameter list ...)，其中dimGrid和dimB1ock规定了代码的大小(用块表示)和块的大小(用线程表示)。
• 除了块识别符(blockIdx)和每个块的线程识别符(threadIdx) 之外，CUDA还为每个块的线程数提供了一个关键字(blockDim)，它来自上一个细节中提到的dimBlock参数。

在查看CUDA代码之前，首先来看看4.2节DAXPY循环的传统C代码：

1
2
3
4
5
6
7

//调用DAXPY
daxpy(n, 2.0, x, y);
// C语言编写的DAXPY
void daxpy(int n, double a, double *x, double *y) {
    for(int i = 0; i < n; ++ i)
        y[i] = a*x[i] + y[i];
}

1
2
3
4
5
6
7
8
9
10
11

//调用DAXPY，每个线程块中有256个线程
__host__
int nblocks = (n + 255) / 256;
daxpy<<<nblocks, 256>>>(n, 2.0, x, y);
// CUDA中的DAXPY
__device__
void daxpy(int n, double a, double *X, double *y) {
    int i = blockIdx.x * blockDim.x + threadIdx.X;
    if(i < n) 
        y[i] = a*x[i] + y[i];
}

行执行和线程管理由GPU硬件负责，而不是由应用程序或操作系统完成。为了简化硬件处理的排程，CUDA要求线程块能够按任意顺序独立执行。尽管不同的线程块可以使用全局存储器中的原子存储器操作进行协调，但它们之间不能直接通信。

马上可以看到，许多GPU硬件概念在CUDA中不是非常明显。从程序员生产效率的角度来看，这是一件好事，但大多数程序员使用GPU而不是CPU来提高性能。重视性能的程序员在用CUDA编写程序时必须时刻惦记着GPU硬件。他们知道需要将控制流中的32个线程分为一组，以从多线程SIMD处理器中获得最佳性能，并在每个多线程SIMD处理器中另外创建许多线程，以隐藏访向DRAM的延迟。它们还需要将数据地址保持在一个或一些存储器块的局部范围内，以获得所期望的存储器性能。

和许多并行系统一样，CUDA在生产效率和性能之间进行了一点折中：提供一些本身固有的功能，让程序员能够显式控制硬件。一方面是生产效率，另-方面是使程序员能够表达硬件所能完成的所有操作，在并行计算中，这两个方面之间经常会发生竞争。了解编程语言在这一著名的生产效率与性能大战中如何发展，了解CUDA是否能够在其他GPU或者其他类型的体系结构中变得普及，都将是非常有意义的一件事。

NVIDIA GPU计算结构

上文提到的这些罕见传统可以帮助解释为什么GPU拥有自己的体系结构类型，为什么拥有与CPU独立的专门术语。理解GPU的一个障碍就是术语，有些词汇的名称甚至可能导致误解。表4-5从左至右列出了本节使用的一些更具描述性的术语、主流计算中的最接近术语、我们关心的官方NVIDIA GPU术语，以及这些术语的简短描述。本节的后续部分将使用该表左侧的描述性术语来解释GPU的微体系结构特征。

这11种术语分为4个组。从上至下为：程序抽象、机器对象、处理硬件和存储器硬件。表4-8将向量术语与这里的最接近术语关联在一起，表4-10和表4-11揭示了官方CUDA NVIDIA和AMD术语与定义，以及OpenCL使用的术语。

我们将以NVIDIA系统为例，它们是GPU体系结构的代表。具体来说，我们将使用上面CUDA并行编程语言的术语，以Fermi体系结构为例。

和向量体系结构一样，GPU只能很好地解决数据级并行问题。这两种类型都拥有集中分散数据传送和遮罩寄存器，GPU 处理器的寄存器要比向量处理器更多。由于它们没有一种接近的标量处理器，所以GPU有时会在运行时以硬件实现一些功能，而向量计算机通常是在编译时用软件来实现这些功能的。与大多数向量体系结构不同的是，GPU 还依靠单个多线程SIMD处理
器中的多线程来隐藏存储器延迟。但是，要想为向量体系结构和GPU编写出高效代码，程序员还需要考虑SIMD操作分组。

网格是在GPU上运行、由一组线程块构成的代码。表4-5给出了网格与向量化循环、线程块与循环体(已经进行了条带挖掘，所以它是完整的计算循环)之间的相似之处。作为一个具体例子，假定我们希望把两个向量乘在一起，每个向量的长度为8192个元素。本节中，我们将反复使用这一示例。图4-8给出了这个示例与前两个GPU术语之间的关系。执行所有8192个
元素乘法的GPU代码被称为网格(或向量化循环)。为了将它分解为更便于管理的大小，网格可以由线程块(或向量化循环体)组成，每个线程块最多512个元素。注意，一条SIMD指令一次执行32个元素。由于向量中有8192个元素，所以这个示例中有16个线程块(16=8192/512)。网络和线程块是在GPU硬件中实现的编程抽象，可以帮助程序员组织自己的CUDA代
码。(线程块类似于一个向量长度为32的条带挖掘向量循环。)

线程块调度程序将线程块指定给执行该代码的处理器，我们将这种处理器称为多线程SIMD处理器。线程块调度程序与向量体系结构中的控制处理器有某些相似。它决定了该循环所需要的线程块数，在完成循环之前，一直将它们分配给不同的多线程SIMD处理器。在这个示例中，会将16个线程块发送给多线程SIMD处理器，计算这个循环的所有8192个元素。

图4-8 网格(可向量化循环)、线程块(SIMD 基本块)和SIMD指令线程与向量-向量乘法的对应，每个向量的长度为8192个元素。每个SIMD指令线程的每条指令计算32个元素，在这个示例中，每个线程块包含16个SIMD指令线程，网格包含16个线程块。硬件线程块调度程序将线程块指定给多线程SIMD处理器，硬件线程调度程序选择某个SIMD指令线程来运行一个SIMD处理器中的每个时钟周期。只有同一线程块中的SIMD线程可以通过本地存储器进行通信。

图4-9显示了多线程SIMD处理器的简化框图。它与向量处理器类似，但它有许多并行功能单元都是深度流水化的，而不是像向量处理器一样只有一小部分如此。在图4-8中的编程示例中，向每个多线程SIMD处理器分配这些向量的512个元素以进行处理。SIMD处理器都是具有独立PC的完整处理器，使用线程进行编程。

图4-9 多线程SIMD处理器的简化框图。它有16个SIMD车道。SIMD线程调度程序拥有大约48个独立的SIMD指令线程，它用一个包括48个PC的表进行调度

GPU硬件包含一组用来执行线程块网络(向量化循环体)的多线程SIMD处理器，也就是说，GPU是一个由多线程SIMD处理器组成的多处理器。

Fermi体系结构的前四种实现拥有7、11、14 或15个多线程SIMD处理器；未来的版本可能仅有2个或4个。为了在拥有不同个多线程SIMD处理器的GPU型号之间实现透明的可伸缩功能，线程块调度程序将线程块(向量化循环主体)指定给多线程SIMD处理器。图4-10给出了Fermi 体系结构的GTX 480实现的平面图。

图4-10 Fermi GTX 480 GPU的平面图。本图显示了16个多线程SIMD处理器。在左侧突出显示了线程块调度程序。GTX480有6个GDDR5端口，每个端口的宽度为64位，支持最多6GB的容量。主机接口为PCI Express 2.0 x 16。Giga线程是将线程块分发给多处理器的调度程序名称，其中每个处理器都有其自己的SIMD线程调度程序

具体地说，硬件创建、管理、调度和执行的机器对象是SIMD指令线程。它是一个包含专用SIMD指令的传统线程。这些SIMD指令线程有其自己的PC，它们运行在多线程SIMD处理器上。SIMD线程调度程序包括一个记分板，让你知道哪些SIMD指令线程已经做好运行准备，然后将它们发送给分发单元，以在多线程SIMD处理器上运行。它与传统多线程处理器中的硬件线程调度程序相同，就是对SIMD指令线程进行调度。因此GPU硬件有两级硬件调度程序：

1. 线程块调度程序，将线程块(向量化循环体)分配给多线程SIMD处理器，确保线程块被分配给其局部存储器拥有相应数据的处理器，
2. SIMD 处理器内部的SIMD线程调度程序，由它来调度应当何时运行SIMD指令线程。

这些线程的SIMD指令的宽度为32，所以这个示例中每个SIMD指令线程将执行32个元素运算。在本示例中，线程块将包含512 * 32=16 SIMD线程。

由于线程由SIMD指令组成，所以SIMD处理器必须拥有并行功能单元来执行运算。我们称之为SIMD车道，它们与4.2节的向量车道非常类似。

每个SIMD处理器中的车道数在各代GPU中是不同的。对于Fermi，每个宽度为32的SIMD指令线程被映射到16个物理SIMD车道，所以一个SIMD指令线程中的每条SIMD指令需要两个时钟周期才能完成。每个SIMD指令线程在锁定步骤执行，仅在开始时进行调度。将SIMD处理器类比为向量处理器，可以说它有16个车道，向量长度为32，钟鸣为2个时钟周期。

根据定义，由于SIMD指令的线程是独立的，SIMD线程调度程序可以选择任何已经准备就绪的SIMD指令线程，而不需要一直盯着线程序列中的下一条SIMD指令。SIMD线程调度程序包括一个记分板，用于跟踪多达48个SIMD线程，以了解哪个SIMD指令已经做好运行准备。之所以需要这个记分板，是因为存储器访问指令占用的时钟周期数可能无法预测，比如存储器组的冲突就可能导致这一现象。 图4-11给出的SIMD线程调度程序在不同时间以不同顺序选取SIMD指令线程。GPU架构师假定GPU应用程序拥有如此之多的SIMD指令线程，因此，实施多线程既可以隐藏到DRAM的延迟，又可以提高多线程SIMD处理器的使用率。

但是，为了防止损失，最近的NVIDIA Fermi GPU包含了一个L2缓存。

图4-11 SIMD 指令线程的调度。调度程序选择一个准备就绪的SIMD指令线程，并同时向所有执行该SIMD线程的SIMD车道发出一条指令。由于SIMD指令线程是独立的，所以调度程序可以每次选择不同的SIMD线程

继续探讨向量乘法示例，每个多线程SIMD处理器必须将两个向量的32个元素从存储器载入寄存器中，通过读、写寄存器来执行乘法，然后将乘积从寄存器存回存储器中。为了保存这些存储器元素，SIMD处理器拥有32 768个32位寄存器，给人以深刻印象。就像向量处理器样，从逻辑上在向量车道之间划分这些寄存器，这里自然是在SIMD车道之间划分。每个SIMD线程被限制为不超过64个寄存器，所以我们可以认为一个SIMD线程最多拥有64个向量寄存器，每个向量寄存器有32个元素，每个元素的宽度为32位。(由于双精度浮点操作数使用两个相邻的32位寄存器，所以另一种意见是每个SIMD线程拥有32个各包括32个元素的向量寄存器，每个宽度为64位。)

由于Fermi拥有16个物理SIMD车道，各包含2048个寄存器。(GPU没有尝试根据位来设计硬件寄存器，使其拥有许多读取端口和写入端口，而是像向量处理器一样，使用较简单的存储器结构，但将它们划分为组，以获得足够的带宽。)每个CUDA线程获取每个向量寄存器中的一个元素。为了用16个SIMD车道处理每个SIMD指令线程的32个元素，线程块的CUDA线程可以共同使用2048个寄存器的一半。

为了能够执行许多个SIMD指令线程，需要在创建SIMD指令线程时在每个SIMD处理器上动态分配一组物理寄存器，并在退出SIMD线程时加以释放。

注意，CUDA线程就是SIMD指令线程的垂直抽取，与-个SIMD车道上执行的元素相对应。要当心，CUDA线程与POSIX线程完全不同;不能从CUDA线程进行任意系统调用。现在可以去看看GPU指令是什么样的了。

NVIDA GPU指令集体系结构

与大多数系统处理器不同，NVIDIA 编译器的指令集目标是硬件指令集的一种抽象。 PTX(并行线程执行)为编译器提供了一种稳定的指令集，可以实现各代GPU之间的兼容性。它向程序员隐藏了硬件指令集。PTX指令描述了对单个CUDA线程的操作，通常与硬件指令一对一映射，但一个PTX可以扩展到许多机器指令，反之亦然。PTX使用虚拟寄存器，所以编译器指出一个SIMD线程需要多少物理向量寄存器，然后，由优化程序在SIMD线程之间划分可用的寄存器存储。这一优化程序还会清除死亡代码，将指令打包在一起，并计算分支发生发散的位置和发散路径可能会聚的位置。

尽管x86微体系结构与PTX之间有某种类似，这两者都会转换为一种内部形式(x86的微指令)，区别在于：对于x86，这一转换是在执行过程中在运行时以硬件实现的，而对于GPU，则是在载入时以软件实现的。

PTX指令的格式为：opcode.type d, a, b, c;，其中d是目标操作数，a、b和c是源操作数；操作类型如表4-6所示。

源操作数为32位或64位整数或常值。目标操作数为寄存器，存储指令除外。

表4-7显示了基本PTX指令集。所有指令都可以由1位谓词寄存器进行判定，这些寄存器可以由设置谓词指令(setp)来设定。控制流指令为函数ca1l和return，线程exit、branch 以及线程块内线程的屏障同步(bar.sync)。在分支指令之前放置谓词就可以提供条件分支。编译器或PTX程序员将虚拟寄存器声明为32位或64位有类型或无类型值。例如，R0，R1，…用于32位值，RD0，R1…用于64位寄存器。回想一下，将虚拟寄存器指定给物理寄存器的过程是在载入时由PTX进行的。

表4-7基本PTX GPU线程指令

下面的PTX指令序列是4.4.1节DAXPY循环一次迭代的指令：

1
2
3
4
5
6
7
8

shl.u32 R8, b1ockIdx, 9   ; 线程块ID *块大小(512 或29)
add,u32 R8, R8, threadIdx ; R8 = i =我的CUDA线程ID
sh1.u32 R8, R8, 3         ; 字节偏移
ld.global.f64 RD0, [X+R8] ; RD0 = X[i]
ld.global.f64 RD2, [Y+R8] ; RD2 = Y[i]
mul.f64 RD0, RD0, RD4     ; 在RD0中求乘积RD0 = RD0 * RD4 (标量a)
add.f64 RD0, RD0, RD2     ; 在RD0中求和RD0 = RD0 + RD2 (Y[i])
st.global.f64 [Y+R8], RD0 ; Y[i] = sum (X[i]*a + Y[i])

注意，GPU与向量体系结构不同，它们没有分别用于顺序数据传送、步幅数据传送和集中-分散数据传送的指令。所有数据传送都是集中-分散的！为了重新获得顺序(单位步幅)数据传送的效率，GPU包含了特殊的“地址接合”硬件，用于判断SIMD指令线程中的SIMD车道什么时候一同发出顺序地址。运行时硬件随后通知存储器接口单元来请求发送32个顺序字的分块
传送。为了实现这一重要的性能改进，GPU程序员必须确保相邻的CUDA线程同时访问可以接合为一个或一些存储器或缓存块的相邻地址，我们的示例就是这样做的。

GPU中的条件分支

和单位步幅数据传送的情况一样，向量体系结构和GPU在处理IF语句方面非常相似，前者主要以软件实现这一机制，硬件支持非常有限，而后者则利用了更多的硬件。后面将会看到，除了显式谓词寄存器之外，GPU分支硬件使用了内部遮罩、分支同步栈和指令标记来控制分支何时分为多个执行路径，这些路径何时会汇合。

在PTX汇编程序级别，一个CUDA线程的控制流是由PTX指令分支、调用、返回和退出描述的，另外还要加上每条指令的各个按线程车道给出的谓词来描述，这些谓词由程序员用每个线程车道的1位谓词寄存器指定。PTX汇编程序分析了PTX分支图，对其进行优化，实现最快速的GPU硬件指令序列。

在GPU硬件指令级别，控制流包括分支、跳转、索引跳转、调用、索引调用、返回、退出和管理分支同步栈的特殊指令。GPU硬件提供了每个拥有自己栈的SIMD线程；一个堆栈项包含一个标识符标记、一个目标指令地址和一个目标线程活动遮罩。有一些GPU特殊指令为SIMD项目压入栈项，还有一些特殊指令和指令标记用于弹出栈项或者将栈展开为特殊项，并跳转到具有目标线程活动遮罩的目标指令地址。GPU硬件指令还拥有一些为不同车道设置的不同谓词(启用/禁用)，这些谓词是利用每个车道的1位谓词寄存器指定的。

PTX汇编程序通常会将用PTX分支指令编码的简单外层IF/THEN/ELSE语句优化为设有谓词的GPU指令，不采用任何GPU分支指令。更复杂控制流的优化通常会混合采用谓词与GPU分支指令，这些分支指令带有一些特殊指令和标记，当某些车道跳转到目标地址时，这些GPU分支指令会使用分支同步栈压入一个栈项，而其他各项将会失败。在这种情况下，NVIDIA 称
为发生了分支分岔。当SIMD车道执行同步标记或汇合时，也会使用这种混合方式，它会弹出一个栈项，并跳转到具有栈项线程活动遮罩的栈项地址。

PTX汇编程序识别出循环分支，并生成GPU分支指令，跳转到循环的顶部，用特殊栈指令来处理各个跳出循环的车道，并在所有车道完成循环之后，使这些SIMD车道汇合。GPU索引跳转和索引调用指令向栈中压入项目，以便在所有车道完成开关语句或函数调用时，SIMD线程汇合。

GPU设定谓词指令(表4-7中的setp)对IF语句的条件部分求值。PTX分支指令随后将根据该谓词来执行。如果PTX汇编程序生成了没有GPU分支指令的有谓词指令，它会使用各个车道的谓词寄存器来启用或禁用每条指令的每个SIMD车道。IF语句THEN部分线程中的SIMD指令向所有SIMD车道广播操作。谓词被设置为1的车道将执行操作并存储结果，其他SIMD车道不会执行操作和存储结果。对于ELSE语句，指令使用谓词的补数(与THEN语句相对)，所以原来空闲的SIMD车道现在执行操作，并存储结果，而它们前面的对应车道则不会执行相关操作。在ELSE语句的结尾，会取消这些指令的谓词，以便原始计算能够继续进行。因此，对于相同长度的路径，IF-THEN-ELSE 的工作效率为50%。

IF语句可以嵌套，因而栈的使用也可以嵌套，所以PTX汇编程序通常会混合使用设有谓词的指令和GPU分支与特殊分支指令，用于复杂控制流。注意，尝试嵌套可能意味着大多数SIMD车道在执行嵌套条件语句期间是空闲的。因此，等长路径的双重嵌套IF语句的执行效率为25%，三重嵌套为12.5%，以此类推。与此类似的情景是仅有少数几个遮罩位为1时向量处理器的运行情况。

具体来说，PTX汇编程序在每个SIMD线程中的适当条件分支指令上设置“分支同步”标记，这个标记会在栈中压入当前活动遮罩。如果条件分支分岔(有些车道进行跳转，有些失败)，它会压入栈项，并根据条件设置当前内容活动遮罩。分支同步标记弹出分岔的分支项，并在ELSE部分之前翻转遮罩位。在IF语句的末尾，PTX汇编程序添加了另一个分支同步标记，它会将先前的活动遮罩从栈中弹出，放入当前的活动遮罩中。

如果所有遮罩位都被设置为1，那么THEN结束的分支指令将略过ELSE部分的指令。当所有遮罩位都为零时，对于THEN部分也有类似优化，条件分支将跳过THEN指令。并行的IF语句和PTX分支经常使用没有异议的分支条件(所有车道都同意遵循同一路径)，所以SIMD指令不会分岔到各个不同的车道控制流。PTX汇编程序对此类分支进行了优化，跳过SIMD线程中所有车道都不会执行的指令块。这种优化在错误条件检查时是有用的，在这种情况下，必须进行测试，但很少会被选中。

以下是一个类似于4.2节的条件语句，其代码为：

1
2
3
4

if (X[i] != 0)
    X[i] = X[i] - Y[i];
else 
    X[i] = Z[i];

1
2
3
4
5
6
7
8
9
10
11
12
13
14

ld.global .f64 RD0, [X+R8]    ; RD0 = X[i]
setp.neq.s32 P1, R00, #0      ; Pl是谓词寄存器l
@lP1, bra ELSE1, *Push        ; 压入旧遮罩，设定新遮罩位
                              ; if P1为假，则转至ELSE1
ld.g1oba1. f64 RD2, [Y+R8]    ; RD2 =Y[i]
sub.f64 RD0, RD0, RD2         ; RD0中的差
st.global.f64 [X+R8], RD0     ; X[i] = RDC
@P1, bra ENDIF1, *Comp        ; 对遮罩位求补
                              ; if P1为真，则转至ENDIF1
ELSE1：
    ld.globa1.f64 RD0, [Z+R8] ; RDO = Z[i]
    st.global.f64 [X+R8], RD  ; X[i] = RD0
ENDIF1：
    <next instruction>, *Pop  ; 弹出以恢复旧遮罩

这一灵活性还有助于解释为SIMD指令线程中每个元素指定的名称——CUDA线程，它会给人以独立运行的错觉。编程新手可能会认为这一线程抽象意味着GPU能够更出色地处理条件分支。一些线程会沿一条路径执行，其他线程则会沿另一路径执行，只要你不着急，那似乎就是如此。每个CUDA线程要么与线程块中的所有其他线程执行相同指令，要么就处于空闲状态。利用这一同步可以较轻松地处理带有条件分支的循环，这是因为遮罩功能可以关闭SIMD车道，自动检测循环的结束点。

最终得到的性能结果可能会与这种简单的抽象不相符。如果编写一些程序，以这种高度独立的MIMD模式来操作SIMD车道，就好像是编写了一些程序，在一个物理存储器很小的计算机上使用大量虚拟地址空间。这两种程序都是正确的，但它们的运行速度可能非常慢，程序员可能会对结果感到不快。

向量编译器可以用遮罩寄存器做到GPU用硬件完成的小技巧，但可能需要使用标量指令来保存、求补和恢复遮罩寄存器。条件执行就是这样一个例子：GPU在运行时用硬件完成向量体系结构在编译时完成的工作。有一种优化方法，可以在运行时针对GPU应用，但不能在编译时对向量体系结构应用，那就是在遮罩位全0或全1时略过THEN或ELSE部分。因此，GPU执行条件分支的效率决定了分支的分岔频率。例如，某个特征值计算具有深度条件嵌套，但通过代码测试表明，大约82%的时钟周期发射将32个遮罩位中的29至32位设置为1，所以GPU执行这一代码的效率可能要超出人们的预期。

注意，同一机制处理向量循环的条带挖掘——当元素数与硬件不完全匹配时。本节开始的例子表明，用一个If语句检查SIMD车道元素数(在上例中，该数目存储在R8中)是否小于限值(i<n)，并适当设置遮罩。

NVIDIA GPU存储器结构

图4-12给出了NVIDIA GPU的存储器结构。多线程SIMD处理器中的每个SIMD车道获得片外DRAM的一个专用部分，称之为专用存储器，用于栈帧、溢出寄存器和不能放在寄存器中的私有变量。SIMD车道不共享专用存储器。最近的GPU将这一专用存储器缓存在L1和L2缓存中，用于辅助寄存器溢出并加速函数调用。

图4-12 GPU存储器结构。GPU存储器由所有网格(向量化循环)共享，本地存储器由线程块(向量化循环体)中的所有SIMD指令线程共享，专用存储器由单个CUDA线程专用

我们将每个多线程SIMD处理器本地的片上存储器称为本地存储器。这一存储器由多线程SIMD处理器内的SIMD车道共享，但这一存储器不会在多线程SIMD处理器之间共享。多线程SIMD处理器在创建线程块时，将部分本地存储器动态分配给此线程块，当线程块中的所有线程都退出时，释放此存储器。这一本地存储器部分由该线程块专用。

最后，我们将由整个GPU和所有线程块共享的片外DRAM称为GPU存储器。这里的向量乘法示例仅使用GPU存储器。

被称为主机的系统处理器可以读取或写入GPU存储器。本地存储器不能供主机使用，它是每个多线程SIMD专用的。专用存储器也不可供主机使用。

GPU通常不是依赖大型缓存来包含应用程序的整个工作集，而是使用较少的流式缓存，依靠大量的SIMD指令多线程来隐藏DRAM的较长延迟，其主要原因是它们的工作集可能达到数百MB。在利用多线程隐藏DRAM延迟的情况下，系统处理器中供缓存使用的芯片面积可以用于计算资源和大量的寄存器，以保存许多SIMD指令线程的状态。如前文所述，向量的载入和存储与之相对，是将这些延迟分散在许多元素之间，因为它只需要有一次延迟，随后即可实现其余访问的流水化。

尽管隐藏存储器延迟是一种优选方法，但要注意，最新的GPU和向量处理器都已经添加了缓存。例如，最近的Fermi体系结构已经添加了缓存，但它们要么被看作带宽滤选器，以减少对GPU存储器的要求，要么被看作有限几种变量的加速器，这些变量的修改不能通过多线程来隐藏。因此，用于栈帧、函数调用和寄存器溢出的本地存储器与缓存是绝配，这是因为延迟对于函数调用是有影响的。由于片上缓存访问所需要的能量要远远小于对多个外部DRAM芯片的访问，所以使用缓存还可以节省能量。

为了提高存储器带宽、降低开销，如上所述，当地址属于相同块时，PTX数据传送指令会将来自同一SIMD线程的各个并行线程请求接合在一起，变成单个存储器块请求。对GPU程序设置的这些限制，多少类似于系统处理器程序在硬件预取方面的一些准则。GPU存储器控制器还会保留请求，将一些请求一同发送给同一个打开的页面，以提高存储器带宽。

Fermi GPU体系结构中的创新

为了提高硬件利用率，每个SIMD处理器有两个SIMD线程调度程序和两个指令分派单元。双重SIMD线程调度程序选择两个SIMD指令线程，并将来自每个线程的一条指令发射给由16个SIMD车道、16个载入存储单元或4个特殊功能单元组成的集合。因此，每两个时钟周期将两个SNMD指令线程调度至这些集合中的任何一个。由于这些线程是独立的，所以不需要检查指令流中的数据相关性。这一创新类似于多线程向量处理器，它可以发射来自两个独立线程的向量指令。

图4-13展示了发射指令的双重调度程序，图4-14展示了Fermi GPU的多线程SIMD处理器的框图。

图4-13 Fermi 双SIMD线程调度程序的框图。将这一设计与图4-11中的单SIMD线程设计进行对比

图4-14 Fermi GPU多线程SIMD处理器的框图。每个SIMD车道有一个流水线浮点单元、一个流水线整数单元、还有某些逻辑，用于将指令和操作数分发给这些单元，以及一个队列用于保存结果。4个特殊函数单元(SFU)计算诸如平方根、求倒数、正弦和余弦等函数

Fermi引入了几种创新，使GPU与主流系统处理器的接近程度远远超过Tesla和前几代GPU体系结构。

• 快速双精度浮点运算——Fermi对比发现，传统处理器的相对双精度速度大约为单精度速度的一半，是先前Tesla代处理器单精度速度的十分之一。也就是说，当准确性需要双精度时，使用单精度在速度方面没有太大的诱惑力。在使用乘加指令时，峰值双精度性能从过去GPU的78 GFLOP/s增长到515 GFLOP/s。
• GPU存储器——尽管GPU的基本思想是使用足够多的线程来隐藏DRAM延迟，但仍然需要在线程之间使用一些变量，比如前面提到的局部变量。Fermi 在GPU中为每个多线程SIMD处理器包含了L1数据缓存和L1指令缓存，还包含了由所有多线程SIMD处理器共享的单个768KB L2缓存。如上所述，除了降低对GPU存储器的带宽压力之外，缓存因为驻留在芯片上，不用连到片外DRAM，所以还能节省能量。L1缓存实际上与本地存储器使用同一SRAM。Fermi有一个模式位，为用户提供了两种使用64KB SRAM的选择：两种16KBL1缓存和48KB本地存储器，另一种是48KBL1缓存和16KB本地存储器。注意，GTX 480有一个倒转的存储器层次结构：聚合寄存器堆的大小为2 MB，所有L1数据缓存的大小介于0.25与0.75 MB之间(取决于它们是16KB，还是48 KB)，L2缓存的大小为0.75 MB。了解这一反转比值对GPU应用程序的影响是有意义的。
• 全部GPU存储器的64位寻址和统一地址空间——利用这一创新可以非常轻松地提供C和C++所需要的指针。
• 纠错码检测和纠正存储器与寄存器中的错误，为了提高数千个服务器上长期运行的应用程序的可靠性，ECC是数据中心的一种标准配置。
• 更快速的上下文切换——由于多线程SIMD处理器拥有大量状态，所以Fermi以硬件支持大幅加速上下文的切换速度。Fermi 可以在不到25微秒内完成切换，比之前的处理器大约快10倍。
• 更快速的原子指令——这一特征最早包含 在Telsa体系结构中，Fermi将原子指令的性能提高了5~20倍，达到几微秒的级别。有一个与L2缓存相关的特殊硬件单元(不是在多线程SIMD处理器内部)用来处理原子指令。

向量体系结构与GPU的相似与不同

我们已经看到，向量体系结构与GPU之间确实有许多相似之处。这些相似之处和GPU那些怪异的术语一样，也让体系结构圈的人们难以真正了解新奇的GPU本质。既然我们现在已经了解了向量体系结构和GPU的一些内幕，那就可以体味一下 它们的相似与不同了。这两种体系结构都是为了执行数据级并行程序而设计的，但它们选取了不同的路径，对比它们是希望更深入地了解DLP硬件到底需要什么。表4-8首先给出向量术语，然后给出GPU中最接近的对等术语。

SIMD处理器与向量处理器类似。GPU中的多个SIMD处理器像独立MIMD核心一样操作，就好像是许多向量计算机拥有多个向量处理器。这种观点将NVIDIA GTX 480看作一个具有多线程硬件支持的15核心机器，其中每个核心有16个车道。两者之间最大的区别是多线程，它是GPU的基本必备技术，而大多数向量处理器则没有采用。

看一下这两种体系结构中的寄存器，VMIPS寄存器堆拥有整个向量，也就是说，由64个双精度值构成的连续块。相反，GPU中的单个向量会分散在所有SIMD车道的寄存器中。VMIPS处理器有8个向量寄存器，各有64个元素，总共512个元素。一个GPU的SIMD指令线程拥有多达64个寄存器，各有32个元素，总共2048个元素。这些额外的GPU寄存器支持多线程。

图4-15的左边是向量处理器执行单元的框图，右侧是GPU的多线程SIMD处理器。为便于讲解，假定向量处理器有4个车道，多线程SIMD处理器也有4个SIMD车道。此图表明，4个SIMD车道的工作方式非常像4车道向量单元，SIMD处理器的工作方式与向量处理器非常类似。

图4-15 左侧为具有4个车道的向量处理器，右侧为GPU的多线程SIMD处理器。(GPU通常有8~ 16个SIMD车道。)控制处理器为标量一向量运算提供标量操作数，为对存储器进行单位步幅或非单位步幅访问而递增地址，执行其他“记账类型” (accounting-type)的运算。只有当地址接合单元可以发现本地寻址时，才会在GPU中实现峰值存储器性能。与此类似，当所有内部遮罩位被设置为相同时，会实现峰值计算性能。注意，SIMD处理器中每个SIMD线程有一个PC，以帮助实现多线程

实际上，GPU中的车道要多很多，所以GPU“钟鸣”更短一些。尽管向量处理器可能拥有2~8个车道，向量长度例如为32 (因此，钟鸣为4~16个时钟周期)，多线程SIMD处理器可能拥有8~16个车道。SIMD线程的宽度为32个元素，所以GPU钟鸣仅为2或4个时钟周期。这一差别就是为什么要使用“SIMD 处理器”作为更具描述性术语的原因，这一术语更接近于SIMD设计，而不是传统的向量处理器设计。与向量化循环最接近的GPU术语是网格，PTX指令与向量指令最接近，这是因为SIMD线程向所有SIMD车道广播PTX指令。

关于两种体系结构中的存储器访问指令，所有GPU载入都是集中指令，所有GPU存储都是分散指令。如果CUDA线程的地址引用同一缓存/存储器块的邻近地址，那GPU的地址接合单元将会确保较高的存储器带宽。向量体系结构采用显式单位步幅载入并存储指令，而GPU编程则采用隐式单位步幅，这两者的对比说明为什么在编写高效GPU代码时，需要程序员从SIMD运算的角度来思考，尽管CUDA编程模型与MIMD看起来非常类似。由于CUDA线程可以生成自己的地址、步幅以及集中-分散，所有在向量体系结构和GPU中都可以找到寻址向量。我们已经多次提到，这两种体系结构采用了非常不同的方法来隐藏存储器延迟。向量体系结构通过深度流水化访问让向量的所有元素分担这一延迟，所以每次向量载入或存储只需要付出一次延迟代价。因此，向量载入和存储类似于在存储器和向量寄存器之间进行的块传送。与之相对的是，GPU使用多线程隐藏存储器延迟。(一些研究人员正在研究为向量体系结构添加多线程，以实现这两者的最佳性能。)

关于条件分支指令，两种体系结构都使用遮罩寄存器来实现。两个条件分支路径即使在未存储结果时也会占用时间以及(或者)空间。区别在于，向量编译器以软件显式管理遮罩寄存器，而GPU硬件和汇编程序则使用分支同步标记来隐式管理它们，使用内部栈来保存、求补和恢复遮罩。

前面曾经提到，GPU的条件分支机制很好地处理了向量体系结构的条带挖掘问题。如果向量长度在编译时未知，那么程序必须计算应用程序向量长度的模和最大向量长度，并将它存储在向量长度寄存器中。条带挖掘循环随后将向量长度寄存器重设剩余循环部分的最大向量长度。这种情况用GPU处理起来要更容易一些，因为它们将会一直迭代循环，直到所有SIMD车道到达循环范围为止。在最后一次迭代中，一些SIMD车道将被遮罩屏蔽，然后在循环完成后恢复。

向量计算机的控制处理器在向量指令的执行过程中扮演着重要角色。它向所有向量车道广播操作，并广播用于向量标量运算的标量寄存器值。它还执行一些在GPU中显式执行的隐式计算，比如自动为单位步幅和非单位幅载入、存储指令递增存储器地址。GPU中没有控制处理器。最类似的是线程块调度程序，它将线程块(向量循环体)指定给多线程SIMD处理器。GPU中的运行时硬件机制一方面生成地址，另一方面还会查看它们是否相邻，这在许多DLP应用程序中都是很常见的，其功耗效率可能要低于控制处理器。

向量计算机中的标量处理器执行向量程序的标量指令。也就是说，它执行那些在向量单元中可能速度过慢的运算。尽管与GPU相关联的系统处理器与向量体系结构中的标量处理器最为相似，但独立的地址空间再加上通过PCle总线传送，往往会耗费数千个时钟周期的开销。对于在向量计算机中执行的浮点计算，标量处理器可能要比向量处理器慢一些，但它们的速度比值不会达到系统处理器与多线程SIMD处理器的比值(在给定开销的前提下)。

因此，GPU中的每个“向量单元”必须执行本来指望在向量计算机标量处理器上进行的计算。也就是说，如果不是在系统处理器上进行计算然后再发送结果，而是使用谓词寄存器和内置遮罩禁用其他SIMD车道，仅留下其中一个SIMD车道，并用它来完成标量操作，那可以更快一些。向量计算机中比较简单的标量处理器可能要比GPU解决方案更快一些、功耗效率更高一些。如果系统处理器和GPU将来更紧密地结合在一起，那了解一下系统处理器能否扮演标量处理器在向量及多媒体SIMD体系结构中的角色，那将是很有意义的。

多媒体SIMD计算机与GPU之间的相似与不同

从较高级别的角度来看，具有多媒体SIMD指令扩展的多核计算机的确与GPU有一些相似之处。表4-9总结了它们之间的相似与不同。

这两种多处理器的处理器都使用多个SIMD车道，只不过GPU的处理器更多一些，车道数要多很多。它们都使用硬件多线程来提高处理器利用率，不过GPU为大幅增加线程数目提供了硬件支持。由于GPU中最近的一些创新，现在这两者的单、双精度浮点运算性能比相当。它们都使用缓存，不过GPU使用的流式缓存要小一些，多核计算机使用大型多级缓存，以尝试完全包含整个工作集。它们都使用64位地址空间，不过GPU中的物理主存储器要小得多。尽管GPU支持页面级别的存储器保护，但它们都不支持需求分页。除了在处理器、SIMD车道、硬件线程支持和缓存大小等大量的数字差异之外，还有许多体系结构方面的区别。在传统计算机中，标量处理器和多媒体SIMD指令紧密集成在一起；它们由GPU中的I/O总线隔离，它们甚至还有独立的主存储器。GPU中的多个SIMD处理器使用单一地址空间，但这些缓存不是像传统的多核计算机那样是一致的。多媒体SIMD指令与GPU不同，它不支持集中-分散存储器访问。

小结

现在，GPU的神秘面纱已经揭开，可以看出GPU实际上就是多线程SIMD处理器，只不过与传统的多核计算机相比，它们的处理器更多、每个处理器的车道更多，多线程硬件更多。例如，Fermi GTX 480拥有15个SIMD处理器，每个处理器有16个车道，为32个SIMD线程提供硬件支持。Fermi甚至包括指令级并行，可以从两个SIMD线程向两个SIMD车道集合发射指令。另外，它们的缓存存储器较少——Fermi 的L2缓存为0.75 MB，而且与标量处理器不一致。

CUDA编程模型将所有这些形式的并行包含在一种抽象中，即CUDA线程中。因此，CUDA程序员可以看作是在对数千个线程进行编程，而实际上他们是在许多SIMD处理器的许多车道上执行各个由32个线程组成的块。希望获得良好性能的CUDA程序员一定要记住 ，这些线程是分块的，一次执行32个，而且为了从存储器系统获得良好性能，其地址需要是相邻的。尽管本节使用了CUDA和NVIDIA GPU，但我们确信在OpenCL编程语言和其他公司的GPU中也采用了相同思想。

在读者已经很好地理解了GPU的工作原理之后，现在可以揭示真正的术语了。表4-10和4-11将本节的描述性术语及定义与官方CUDANVIDIA和AMD术语及定义对应起来，而且还给出了OpenCL术语。我们相信，GPU 学习曲线非常陡峭，一部分原因就是因为使用了如下术语：用“流式多处理器”表示SIMD处理器，“线程处理器”表示SIMD车道，“共享存储器”表示本地存储器，而本地存储器实际上并非在SIMD处理器之间共享!我们希望，这种“两步走”方法可以帮助读者更快速地沿学习曲线上升，尽管这种方法有些不够直接。

检测与增强循环强并行

程序中的循环是我们前面讨论以及将在第5章讨论的许多并行类型的根源。本节，我们讨论用于发现并行以在程序中加以开发的编译器技术，以及这些编译器技术的硬件支持。我们准确地定义一个循环何时是并行的(或可向量化的)、相关性是如何妨碍循环成为并行的，以及用于消除几类相关性的技术。发现和利用循环级并行对于开发DLP和TLP以及将在附录H中研究的更主动静态ILP方法(例如，VLIW)都至关重要。

循环级并行通常是在源代码级别或接近级别进行分析的，而在编译器生成指令之后，就完成了对ILP的大多数分析。循环级分析需要确定循环的操作数在这个循环的各次迭代之间存在哪种相关性。就目前来说，我们将仅考虑数据相关，在某一时刻写入操作数，并在稍后时刻读取时会出现这种相关性。名称相关也是存在的，利用第3章讨论的重命名技术可以消除这种相关。

循环级并行的分析主要是判断后续迭代中的数据访问是否依赖于在先前迭代中生成的数据值；这种相关被称为循环间相关。我们在第2章和第3章考虑的大多数示例都没有循环间相关，而是循环级并行的。为了了解一个循环是并行的，让我们首先看看源代码：

1
2

for (i=999; i>=0; i=i-1) 
    x[i] = x[i] + s;

在这个循环中，对x[i]的两次使用是相关的，但这是同一个迭代内的相关，不是循环间相关。在不同迭代中对i的连续使用之间存在循环间相关，但这种相关涉及一个容易识别和消除的归纳变量。

要寻找循环之间的并行，需要识别诸如循环、数组引用和归纳变量计算之类的结构，所以与机器码级别相比，编译器在源代码级别或相近级别进行这一分析要更轻松一些。让我们看一个更复杂的例子。

考虑下面这样一个循环：

1
2
3

for (i=0; i<100; i=i+1) {
    A[i+1] = A[i] + C[i];   /*S1 */
    B[i+1] = B[i] + A[i+1]; /* S2 */

假定A、B和C是没有重叠的不同数组。(在实践中，这些数组有时可能相同，或可能重叠。因为这些数组可能是作为参数传递给包含这一循环的过程，为了判断数组是否重叠或相同，通常需要对程序进行复杂的过程间分析。)在这个循环中，语句S1和S2之间的数据相关如何?

共有以下两种不同相关。

• S1使用一个在先前迭代中由S1计算的值，这是因为迭代i计算A[i+1]，然后在迭代i+1中读取它。对B[i]和B[i+1]来说，S2 也是如此。
• S2使用由同一迭代中S1计算的值A[i+1]。这两种相关是不同的，拥有不同的效果。为了了解它们如何不同，我们假定此类相关只能同时存在一个。因为语句S1依赖于S1的先前迭代，所以这种相关是循环间相关。这种相关迫使这个循环的连续迭代必须按顺序执行。

第二种相关(S2对S1的依赖)位于一个迭代内，不是循环间相关。因此，如果它是仅有的相关，那这个循环的多个迭代就能并行执行，只要一个迭代中的每对语句保持相对顺序即可。我们在2.2节的例子中看到过这种类型的相关，通过循环展开可以暴露这种并行。这种循环内的相关是很常见的，例如，使用链接(chaining)的向量指令序列就存在此类相关。

还有可能存在一种不会妨碍并行的循环间相关，如下例所示。

考虑下面这样一个循环：

1
2
3
4

for (i=0; i<100; i=i+1) {
    A[i] = A[i] + B[i];   /* S1 */
    B[i+1] = C[i] + D[i]; /* S2 */
}

语句S1使用了在上一次迭代中由语句S2指定的值，所以在S2与S1之间存在循环间相关。尽管存在这一循环间相关，依然可以使这一循环变为并行。与前面的循环不同，这种相关不存在环式相关：这些语句都没有依赖于自身，而且尽管S1依赖于S2，但S2没有依赖于S1。如果可以将一个循环改写为没有环式相关的形式，那这个循环就是并行的，因为没有这种环式相关形式就意味着这种相关性对语句进行了部分排序。

尽管以上循环中没有环式相关，但必须对其进行转换，以符合部分排序，并暴露出并行。两个观察结果对于这一转换至关重要。

• 不存在从S1到S2的相关。如果存在这种相关，那就可能存在环式相关，那循环就不是并行的。由于没有其他相关，所以两个语句之间的互换不会影响S2的执行。
• 在循环的第一次迭代中，语句S2依赖于B[0]值，它是在开始循环之前计算的。这两个观察结果可以让我们用以下代码序列来代替以上循环：

1
2
3
4
5
6

A[0] = A[0] + B[0];
for (i=0; i<99; i=i+1) {
    B[i+1] = C[i] + D[i];
    A[i+1] = A[i+1] + B[i+1];
}
B[100] = C[99] + D[99];

这两个语句之间的相关不再是循环间相关，所以循环的各次迭代可以重叠，只要每次迭代中的语句保持相对顺序即可。

我们的分析需要首先找出所有循环间相关。这一相关信息是不确切的，也就是说，它告诉我们此相关可能存在。考虑以下示例：

1
2
3
4

for (i=0;i<100;i=i+1) {
    A[i] = B[i] + C[i];
    D[i] = A[i] * E[i];
}

循环间相关经常会是一种递归(recurrence)形式。如果要确定变量的取值，需要先知道该变量在前面迭代中的取值时，就会发生递归，这个先前迭代往往就是前面的相邻近代，如以下代码段所示：

1
2
3

for (i=1;i<100;i=i+1) {
    Y[i] = Y[i-1] + Y[i];
}

查找相关

显然，查找程序中的相关对于确定哪些循环可能包含并行以及如何消除名称相关都很重要。诸如C或C++语言中存在数组和指针，Fortran 中存在按引用传送的参数传递，这些也都增加了相关分析的复杂度。由于标量变量引用明确指向名称，所以用别名对它们进行分析是比较轻松的，因为指针和引用参数会增加分析过程的复杂性和不确定性。

编译器通常是如何检测相关的呢?几乎所有相关分析算法都假定数组索引是仿射的(affine)。用最简单的话说，一维数组索引可以写为ai + b的形式，其中a和b是常数，i是循环索引变量，也就说这个索引是仿射的。如果多维数组每一维的索引都是仿射的，那就称这个多维数组的索引是仿射的。稀疏数组访问(其典型形式为x[y[i]])是非仿射访问的主要示例之一。要判断一个循环中对同一数组的两次访问之间是否存在相关，等价于判断两个仿射函数能否针对不同索引取同一个值(这些索引当然没有超出循环范围)。例如，假定我们已经以索引值ai + b存储了一个数组元素，并以索引值ci + d从同一数组中载入，其中i是FOR循环索引变量，其变化范围是m~n。如果满足以下两个条件，则存在相关性。

1. 有两个迭代索引j和k，它们都在循环范围内。即m≤j≤n、m≤k≤n
2. 此循环以索引aj+b存储一个数组元素，然后以ck+d提取同一数组元素。即aj+b=ck+d。

一般来说，我们在编译时不能判断是否存在相关。例如，a、b、c和d的值可能是未和的(它们可能是其他数组中的值)，从而不可能判断是否存在相关。在其他情况下，在编译时进行相关测试的开销可能非常高，但的确可以确定是否存在；例如，可能要依靠多重嵌套循环的迭代索引来进行访问。但是，许多项目主要包含一些简单的索引，其中a、b、c和d都是常数。对于这些情况，有可能设计出一些合理的测试程序，在编译时测试。

举个例子，最大公约数(GCD)测试非常简单，但足以判定不存在相关的情况。它基于以下事实：如果存在循环间相关，那么GCD(c，a)必须能够整除(d-b)。(回想一下，有两个整数x、y，在计算y/x除法运算时，如果能够找到一个整数商，使运算结果没有余数，则说x能够整除y。)

使用GCD测试判断以下循环中是否存在相关：

1
2
3

for (i=0; i<100; i=i+1) {
    X[2*i+3] = X[2*i] * 5.0;
}

GCD测试足以确保不存在相关，但在某些情况下，GCD测试成功但却不存在相关。例如，这种情况可能因为GCD测试没有考虑循环范围。

一般来说，要确定是否实际存在相关，就是一个NP完全(NP-complete)问题。但实际上，有许多常见情况能够以低成本来准确分析。最近出现了一些既准确又高效的方法，它们使用不同层次的精确测试，通用性和成本都有所提高。(如果一个测试能够确切地判断是否存在相关，就说这一测试是确切的。尽管一般情况是“NP 完全”的，但对于一些有一定限制的情况，是存在确切测试的，其成本也要低廉得多。)

除了检测是否存在相关以外，编译器还希望划分相关的种类。编译器可以通过这种分类来识别名称相关，并在编译时通过重命名和复制操作来消除这些相关。

下面的循环有多种类型的相关。找出所有真相关、输出相关和反相关，并通过重命名消除输出相关和反相关。

1
2
3
4
5
6

for (i=0; i<100; i=i+1) {
    Y[i]=X[i]/c;/*S1*/
    X[i]=X[i]+c;/*S2*/
    Z[i]=Y[i]+c;/*S3*/
    Y[i]=c-Y[i];/*S4*/
}

4个语句之间存在以下相关。

1. 由于Y[i]的原因，从S1至S3、从S1至S4存在真相关。这些相关不是循环间相关，所以它们并不妨碍将该循环看作是并行的。这些相关将强制S3和S4等待S1完成。
2. 从S1到S2有基于X[i]的反相关。
3. 从S3到S4有关于Y[i]的反相关。
4. 从S1到S4有基于Y[i]的输出相关。

以下版本的循环消除了这些假(或伪)相关。

1
2
3
4
5
6

for (i=0; i<100; i=i+1) {
    T[i] = X[u] / c; /* Y重命名为T，以消除输出相关*/
    X1[i] = X[i] + c; /* X重命名为X1，以消除反相关*/
    Z[i] = T[i] + c;/*Y重命名为T，以消除反相关*/
    Y[i] = c - T[i];
}

相关分析是一种非常关键的技术，不仅对开发并行如此，对于第2章介绍的转换分块也是如此。相关分析是检测循环级别并行的一种基本工具。要针对向量计算机、SIMD 计算机或多处理器进行有效的程序编译，都依赖于这一分析。相关分析的主要缺点是它仅适用于非常有限的一些情况，也就是用于分析单个循环嵌套中引用之间的相关以及使用仿射索引功能的情景。

因此，在许多情况下，面向数组的相关分析不能告诉我们希望知道的内容；例如，在分析用指针而不是数据索引完成的访问时，可能要困难得多。(对于许多为并行计算机设计的科学应用程序，Fortran 仍然优于C和C++，上述内容就是其中一个理由。)同理，分析过程调用之间的引用也极为困难。因此，尽管依然需要分析那些以顺序语言编写的代码，但我们也需要一些编写显式并行循环的方法，比如OpenMP和CUDA。

消除相关计算

上面曾经提到，相关计算的最重要形式之一就是“递归”。点积是递归的一个完美示例：

1
2

for (i = 9999; i>=0; i=i-1)
    sum=sum+x[i]*y[i];

1
2

for (i=9999; i>=0; i=i-1)
    sum[i] = x[i] * y[i];

1
2

for (i=9999; i>=0; i=1-1)
    finalsum = finalsum + sum[i];

在向量和SIMD体系结构中，约简有时是由特殊硬件处理的，使约简步骤的执行速度远快于在标量模式中的完成速度。具体做法是实施一种技术，类似于可在多处理器环境中实现的技术。尽管一般转换可以使用任意个处理器，但为简便起见，假定有10个处理器。在对求和进行约简的第一个步骤中，每个处理器执行以下运算(p是变化范围为0~9的进程号)：

1
2

for (i=999; i>=0; i=i-1)
    finalsum[p] = finalsum[p] + sum[1+1000*p];

以上转换依赖于加法的结合性质，观察到这一点是非常重要的。尽管拥有无限范围与精度的算术运算具有结合性质，但计算机运算却不具备结合性：对于整数运算来说，是因为其范围有限；对于浮点运算来说，既有范围原因，又有精度原因。因此，使用这些重构技术有时可能会导致一些错误行为，尽管这种现象很少会发生。为此，大多数编译器要求显式启用那些依赖结合性的优化。

交叉问题

能耗与DLP：慢而宽与快而窄

数据级并行体系结构的主要功耗优势来自第1章的能耗公式。由于我们假定有充足的数据级并行，所以，如果将时钟频率折半、执行资源加倍：将向量计算机的车道数加倍，将多媒体SIMD的寄存器和ALU加宽、增加GPU的SIMD车道数，那性能是一样的。如果我们在降低时钟频率的同时降低电压，那就可以降低计算过程的功耗和功率，同时保持峰值性能不变。因此，DLP处理器的时钟频率可以低于系统处理器，后者依靠高时钟频率来获取性能。

与乱序处理器相比，DLP 处理器可以采用较简单的控制逻辑，在每个时钟周期中启动大量计算；例如，这一控制对于向量处理器中的所有车道都是相同的，没有用于决定多指令发射的逻辑和推测执行逻辑。利用向量体系结构还可以轻松地关闭芯片中的未使用部分。在发射指令时，每条向量指令都明确指明它在大量周期内所需要的全部资源。

分组存储器和图形存储器

4.2节提到了实际存储器带宽对于向量体系结构支持单位步幅、非单位步幅和集中-分散访问的重要性。

为了实现高性能，GPU也需要充足的存储器带宽。专为GPU设计的特殊DRAM芯片可以帮助提供这一带宽，这种芯片被称为GDRAM，即图形DARM。与传统DARM芯片相比，GDRAM芯片的带宽较高，容量较低。为了提供这一带宽，GDRAM芯片经常被直接焊接在GPU所在的同一电路板上，而不是像系统存储器那样设置在DIMM模块中，DIMM是插在主板插槽中的。DIMM模块便于系统升级和提供更大的容量，这一点与GDRAM不同。这一有限容量(2011年大约为4 GB)与解决更大问题的目标相冲突，随着GPU计算能力的增长，这冲突将成为它的一个必然趋势。

为了提供最佳性能，GPU 试图考虑GDRAM的所有特性。它们在内部通常被安排为4~8组，行数是2的幂(通常为16384)，每行的位数也是2的幂(通常为8192)。

在给出计算任务及图形加速任务对GDRAM的所有潜在要求之后，存储器系统可能会面对大量的不相关请求。然而，这种多样性会伤害到存储器性能。为了应对这种情况，GPU的存储器控制器为不同GDRAM组设定分离的通信量限度队列，要等到具有足够的通信量后才会打开一行，并同时传送所请求的全部数据。这一延迟提升了带宽，但使延迟时间增长，控制器必须确保所有处理过程不会因为等待数据而“挨饿”，否则，相邻的处理器可能会处于空闲状态。

步幅访问和TLB缺失

步幅访问的一个问题是它们如何与转换旁视缓冲区(TLB)进行交换，以在向量体系结构或GPU中获得虚拟存储器。(GPU使用TLB来实现存储器映射。)根据TLB的组织方式以及存储器中受访数组的大小，甚至有可能在每次访问数组的元素时都会遇到一次TLB缺失。

线程级并行

引言

多重处理的重要性在不断提升，这反映了以下几个重要因素。

• 如何使性能的增长速度超过基础技术的发展速度呢？除了ILP之外，我们所知道的唯一可伸缩、通用方式就是通过多重处理。
• 随着云计算和软件即服务变得越来越重要，人们对高端服务器的兴趣也在增加。
• 因特网上有海量数据可供利用，推动了数据密集型应用程序的发展。
• 人们认识到提高台式计算机性能的重要性在下降（至少图形处理功能之外的性能如此），要么是因为当前的性能已经可以接受，要么是因为计算高度密集、数据高度密集的应用程序都是在云中完成的。
• 人们更深入地了解到如何才能有效地利用多处理器，特别是在服务器环境中如何加以有效利用，这种环境中存在大量自然并行，而并行源于大型数据集、科学代码中的自然并行，或者大量独立请求之间的并行(请求级并行)。
• 通过可复用设计而不是独特设计来充分发挥设计投入的效用，所有多处理器设计都具备这一特点。

本章主要研究线程级并行(TLP)的开发。TLP意味着存在多个程序计数器，因此主要通过MIMD加以开发。尽管MIMD的出现已经有几十年了，但在从嵌入式应用到高端服务器的计算领域中，线程级并行移向前台还是最近的事情。同样，线程级并行大量用于通用应用程序而不只是科学应用程序，也是最近的事情。

这一章的重点是多处理器，我们将多处理器定义为由紧耦合处理器组成的计算机，这些处理器的协调与使用由单一处理器系统控制，通过共享地址空间来共享存储器。此类处理器通过两种不同的软件模型来开发线程级并行。第一种模型是运行一组紧密耦合的线程，协同完成同一项任务，这种情况通常被称为并行处理。第二种模型是执行可能由一或多位用户发起的多个相对独立的进程，这是一种请求级并行形式，其规模要远小于将在下一章研究的内容。请求级并行可以由单个应用程序开发(这个应用程序在多个处理器上运行，比如响应查询请求的数据库程序)，也可以由多个独立运行的应用程序开发，通常称为多重编程。

本章所研究多处理器的典型范围小到一个双处理器，大至包括数十个处理器，通过存储器的共享进行通信与协调。尽管通过存储器进行共享隐含着对地址空间的共享，但并不一定意味着只有一个物理存储器。这些多处理器既包括拥有多个核心的单片系统(称为多核)，也包括由多个芯片构成的计算机，每个芯片可能采用多核心设计。

除了真正的多处理器之外，我们还将再次讨论多线程主题，这一技术支持多个线程以交错形式在单个多发射处理器上运行。许多多核处理器也包括对多线程的支持。

我们的焦点是含有中小量处理器(2 ~ 32个)的多处理器。无论是在数量方面，还是在金额方面，此类设计都占据着主导地位。对于更大规模的多处理器设计领域(33个或更多个处理器)，我们仅给予一点点关注。

多处理器体系结构：问题与方法

为了充分利用拥有n个处理器的MIMD多处理器，通常必须拥有至少n个要执行的线程或进程。单个进程中的独立线程通常由程序员确认或由操作系统创建(来自多个独立请求)。在另一极端情况下，一个线程可能由一个循环的数十次迭代组成，这些迭代是由开发该循环数据并行的并行编译器生成的。指定给一个线程的计算量称为粒度大小，尽管这一数值在考虑如何高效开发线程级并行时非常重要，但线程级并行与指令级并行的重要定性区别在于：线程级并行是由软件系统或程序员在较高层级确认的；这些线程由数百条乃至数百万条可以并行执行的指令组成。

线程还能用来开发数据级并行，当然，其开销可能高于使用SIMD处理器或GPU的情况。这一开销意味着粒度大小必须大到能够足以高效开发并行。例如，尽管向量处理器或GPU也许能够高效地实现短向量运算的并行化，但当并行分散在许多线程之间时，粒度大小会非常小，导致在MIMD中开发并行的开销过于昂贵，无法接受。根据所包含的处理器数量，可以将现有共享存储器的多处理器分为两类，而处理器的数量又决定了存储器的组织方式和互连策略。我们是按照存储器组织方式来称呼多处理器的，因为处理器的数目是多还是少，是可能随时间变化的。

第一类称为对称(共享存储器)多处理器（SMP），或集中式共享存储器多处理器，其特点是核心数目较少，通常不超过8个。由于此类多处理器中的处理器数目如此之小，所以处理器有可能共享一个集中式存储器，所有处理器能够平等地访问它，这就是对称一词的由来。在多核芯片中，采用一种集中方式在核心之间高效地共享存储器，现有多核心都是SMP。当连接一个以上的多核心时，每个多核心会有独立的存储器，所以存储器为分布式，而非集中式。

SMP体系结构有时也称为一致存储器访问(UMA)多处理器，这一名称来自以下事实：所有处理器访问存储器的延迟都是一致的，即使存储器的组织方式被分为多个组时也是如此。图5-1展示了这类多处理器的基本结构。SMP的体系结构将在5.2节讨论，我们将结合一种多核心来解释这种体系结构。

图5-1 基于多核芯片的集中式共享存储器多处理器的基本结构。多处理器缓存子系统共享同一物理存储器，通常拥有一级共享缓存、一或多级各核心专用缓存。这一结构的关键特性是所有处理器对所有存储器的访问时间一致。在多芯片版本中，将省略共享缓存，将处理器连接至存储器的总线或互连网络分布在芯片之间，而不是一块芯片内部

在另一种设计方法中，多处理器采用物理分布式存储器，称为分布式共享存储器（DSM）。图5-2展示了此类多处理器的基本结构。为了支持更多的处理器，存储器必须分散在处理器之间，而不应当是集中式的；否则，存储器系统就无法在不大幅延长访问延迟的情况下为大量处理器提供带宽支持。随着处理器性能的快速提高以及处理器存储器带宽需求的相应增加，越来越小的多处理器都优选采用分布式存储器。多核心处理器的推广意味着甚至两芯片多处理器都采用分布式存储器。处理器数目的增大也提升了对高宽带互连的需求。直联网络(即交换机)和间接网络(通常是多维网络)均被用于实现这些互连。

图5-2 2011年的分布式存储器多处理器的基本体系结构通常包括一个带有存储器的多核心多处理器芯片，可能带有I/O和一个接口，连向连接所有节点的互连网络。每个处理器核心共享整个存储器，当然，在访问隶属于该核心芯片的本地存储器时，其速度要远远高于访问远端存储器的速度将存储器分散在节点之间，既增加了带宽，也缩短了到本地存储器的延迟。DSM多处理器也被称为NUMA(非一致存储器访问)，这是因为它的访问时间取决于数据字在存储器中的位置。DSM的关键缺点是在处理器之间传送数据的过程多少变得更复杂了一些，DSM需要在软件中多花费一些力气，以充分利用分布式存储器提升的存储器带宽。因为所有多核心多处理器(处理器芯片或插槽多于一个)都使用了分布式存储器，所以我们将从这个角度来解释分布式存储器多处理器的工作方式。

在SMP和DSM这两种体系结构中，线程之间的通信是通过共享地址空间完成的，也就是说，任何一个拥有正确寻址权限的处理器都可以向任意存储器位置发出存储器引用。与SMP和DSM相关联的共享存储器一词是指共享地址空间这一事实。

与之相对，下一章的集群和仓库级计算机看起来更像是由网络连接的独立计算机，如果两个处理器之间没有运行软件协议加以辅助，那一个处理器就无法访问另一个处理器的存储器。在此类设计中，利用消息传送协议在处理器之间传送数据。

并行处理的挑战

多处理器的应用范围很广，既可用于运行基本上没有通信的独立任务，也可以运行一些必须在线程之间进行通信才能完成任务的并行程序。有两个重要的障碍使并行处理变得极富挑战性。这些障碍的难易程度是由应用方式和体系结构来确定的。

第一个障碍与程序中有限的可用并行相关，第二个障碍源于通信的成本较高。由于可用并行的有限性，所以很难在所有并行处理器中都实现良好的加速比。

并行处理的第二个重要挑战涉及并行处理器进行远程访问所带来的长时延迟。在现有的共享存储器多处理器中，分离核心之间的数据通信通常需要耗费35 ~ 50个时钟周期，分离芯片上的核心之间进行数据通信可能耗费100个时钟周期到500甚至更多个时钟周期(对于大规模多处理器而言)，具体取决于通信机制、互连网络的类型以及多处理器的规模。长时间的通信延迟显然会造成实际影响。让我们看一个简单的例子。

假定有一个应用程序运行在包含32个处理器的多处理器上，它在引用远程存储器时需要的时间为200 ns。对于这一应用程序，假定除涉及通信的引用之外，其他所有引用都会在本地存储器层次结构中命中，这一假定稍微有些乐观了。处理器会在远程请求时停顿，处理器时钟频率为3.3 GHz。如果基础CPI (假定所有引用都在缓存中命中)为0.5，请对比在没有通信、0.2%的指令涉及远程通信引用这两种情况下，多处理器会快多少?

首先计算每条指令占用的时钟周期数更容易一些。当涉及0.2%的远程引用时，多处理器的实际CPI为：

CPI=基础CPI+远程请求率x远程请求成本=0.5+0.2%x远程请求成本

远程请求成本为：远程访问成本/周期时间 = 200 ns/0.3 ns = 666个周期

因此，我们可以得出CPI：CPI=0.5+1.2=1.7

当所有引用均为本地引用时，多处理器要快出1.7/0.5 =3.4倍。实际的性能分析要复杂得多，因为某些非通信引用会在本地层次结构中缺失，远程访问时间也不是一个常数值。例如，在进行远程引用时，由于许多引用试图利用全局互连从而导致争用，增大延迟，从而使远程引用的成本大幅增加。

这些问题(并行度不足、远程通信延迟太长)是多处理器应用中最大的两个性能难题。应用程序并行度不足的问题必须通过软件来解决，在软件中采用一些能够提供更佳并行性能的新算法，而且软件系统应当尽量利用所有处理器来运行软件。远程延迟过长而导致的影响可以由0] 体系结构和程序员来降低。例如，我们可以利用硬件机制(比如缓存共享数据)或软件机制(比如重新调整数据的结构，增加本地访问的数量)来降低远程访问的频率。我们可以利用多线程或利用预取来尝试容忍这些延迟。

集中式共享存储器体系结构

人们发现，使用大型、多级缓存可以充分降低处理器对存储器带宽的需求，这一重要发现刺激了集中式存储器多处理器的发展。最初，这些处理器都是单核心的，经常会占据整个主板，存储器被放置在共享总线上。后来，更高性能的处理器、存储器需求超出了一般总线的能力，最近的微处理器直接将存储器连接到单一芯片中，有时称其为后端或存储器总线，以便将它与连接至I/O的总线区分开来。在访问一个芯片的本地存储器时，无论是为了I/O操作，还是为了从另一个芯片进行访问，都需要通过“拥有”该存储器的芯片。因此，对存储器的访问是非对称的：对本地存储器的访问更快一些，而对远程存储器的远程要慢一些。在多核心结构中，存储器由一个芯片上的所有核心共享，但是从一个多核心的存储器访问另一个核心的存储器时，仍然是非对称的。

采用对称共享存储器的计算机通常支持对共享数据与专用数据的缓存。专用数据供单个处理器使用，而共享数据则由多个处理器使用，基本上是通过读写共享数据来实现处理器之间的通信。在缓存专用项目时，它的位置被移往缓存，缩短平均访问时间并降低所需要的存储器带宽。由于没有其他处理器使用数据，所以程序行为与单处理器中的行为相同。在缓存共享数据时，可能会在多个缓存中复制共享值。除了降低访问延迟和所需要的存储器带宽之外，这一复制过程还可以减少争用，当多个处理器同时读取共享数据项时可能会出现这种争用。不过，共享数据的缓存也引入了一个新问题：缓存一致性。

什么是多处理器缓存一致性

遗憾的是，缓存共享数据会引入一个新的问题，这是因为两个不同的处理器是通过各自的缓存来保留存储器视图的，如果不多加防范，它们最终可能会看到两个不同值。表5-1展示了这一问题，并说明两个不同处理器如何将同一位置的内容看作两个不同值。这一难题一般被称为缓存一致性问题。注意，存在一致性问题是因为既拥有全局状态(主要由主存储器决定)，又拥有本地状态(由各个缓存确定，它是每个处理器核心专用的)。因此，在一个多核心中，可能会共享某一级别的缓存(比如L3)，而另外一些级别的缓存则是专用的(比如L1和L2)，一致性问题仍然存在，必须加以解决。

• 我们最初假定两个缓存都没有包含该变量, X的值为1。我们还假定采用直写缓存，写回缓存会增加一些复杂性，但与此类似。在处理器A写入X值后，A的缓存和存储器中都包含了新值，但B的缓存中没有，如果B读取X的值，将会收到数值1!

通俗地说，如果在每次读取某一数据项时都会返回该数据项的最新写入值，那就说这个存储器系统是一致的。尽管这一定义看起来是正确的，但它有些含混，而且过于简单；实际情况要复杂得多。这一简单定义包含了存储器系统行为的两个方面，这两个方面对于编写正确的共享存储器程序都至关重要。第一个方面称为一致性（coherence），它确定了读取操作可能返回什么值。第二个方面称为连贯性（consistency），它确定了一个写入值什么时候被读取操作返回。首先来看一致性。

如果存储器系统满足以下条件，则说它是一致的。

• 处理器P读取位置X，在此之前是由P对X进行写入，在P执行的这一写入与读取操作之间，没有其他处理器对位置X执行写入操作，此读取操作总是返回P写入的值。
• 一个处理器向位置X执行写入操作之后，另一个处理器读取该位置，如果读写操作的间隔时间足够长，而且在两次访问之间没有其他处理器向X写入，那该读取操作将返回写入值。
• 对同一位置执行的写入操作被串行化，也就是说，在所有处理器看来，任意两个处理器对相同位置执行的两次写入操作看起来都是相同顺序。例如，如果数值1、数值2被依次先后写到一个位置，那处理器永远不可能先从该位置读取到数值2，之后再读取到数值1。

第一个特性只是保持了程序顺序——即使在单处理器中，我们也希望具备这一特性。第二个特性定义了一致性存储器视图的含义：如果处理器可能持续读取到一个旧数据值，我们就能明确地说该存储器是不一致的。

对写操作串行化的要求更加微妙，但却同等重要。假定我们没有实现写操作的串行化，而且处理器P1先写入地址X，然后是P2写入地址X。对写操作进行串行化可以确保每个处理器在某一时刻看到的都是由P2写入的结果。如果没有对写入操作进行串行化，那某些处理器可能会首先看到P2的写入结果，然后看到P1的写入结果，并将P1写入的值无限期保存下去。避免
此类难题的最简单方法是确保对同一位置执行的所有写入操作，在所有处理器看来都是同一顺序；这一特性被称为写入操作串行化。

尽管上述三条属性足以确保一致性了，但什么时候才能看到写入值也是一个很重要的问题。比如，我们不能要求在某个处理器向X中写入一个取值之后，另一个读取x的处理器能够马上看到这个写入值。比如，如果一个处理器对X的写入操作仅比另一个处理器对X的读取操作提前很短的一点时间，那就不可能确保该读取操作会返回这个写入值，因为写入值当时甚至可能还没有离开处理器。写入值到底在多久之后必须能被读取操作读到?这一问题由存储器连贯性模型回答。

一致性和连贯性是互补的：一致性确定了向同一存储器位置的读写行为，而连贯性则确定了有关访问其他存储器位置的读写行为。现在，作出以下两条假定。第一，只有在所有处理器都能看到写入结果之后，写入操作才算完成(并允许进行下一次写入)。第二，处理器不能改变有关任意其他存储器访问的任意写入顺序。这两个条件是指：如果一个处理器先写入位置A，然后再写入位置B，那么任何能够看到B中新值的处理器也必须能够看到A的新值。这些限制条件允许处理器调整读取操作的顺序，但强制要求处理器必须按照程序顺序来完成写入操作。

一致性的基本实现方案

多处理器与I/O的一致性问题尽管在起源上有些类似，但它们却有着不同的特性，会对相应的解决方案产生影响。在IO情景中很少会出现存在多个数据副本的事件（这是一个应当尽可能避免出现的事件），在多个处理器上运行的程序与此不同，它通常会在几个缓存中拥有同一数据的多个副本。在一致性多处理器中，缓存提供了共享数据项的迁移与复制。一致性缓存提供了迁移，可以将数据项移动到本地缓存中，并以透明方式加以使用。这种迁移既缩短了访问远程共享数据项的延迟，也降低了对共享存储器的带宽要求。

一致性缓存还为那些被同时读取的共享数据提供复制功能，在本地缓存中制作数据项的个副本。复制功能既缩短了访问延迟，又减少了对被读共享数据项的争用。支持迁移与复制功能对于共享数据的访问性能非常重要。因此，多处理器没有试图通过软件来避免这一问题的发生，而是采用了一种硬件解决方案，通过引入协议来保持缓存的一致性。

为多个处理器保持缓存一致性的协议被称为缓存一致性协议。实现缓存一致性协议的关键在于跟踪数据块的所有共享状态。目前使用的协议有两类，分别采用不同技术来跟踪共享状态。

• 目录式——特定物理存储器块的共享状态保存的位置称为目录。共有两种不同类型的目录式缓存一致性，它们的差异很大。在SMP中，可以使用一个集中目录，与存储器或其他某个串行化点相关联，比如多核心中的最外层缓存。在DSM中，使用单个目录没有什么意义，因为这种方法会生成单个争用点，当多核心中拥有8个或更多个核心时，由于其存储器要求的原因，很难扩展到许多个多核芯片。分布式目录要比单个目录更复杂。
• 监听式——如果一个缓存拥有某一物理存储器块中的数据副本，它就可以跟踪该块的共享状态，而不是将共享状态保存在同一个目录中。在SMP中，所有缓存通常都可以通过某种广播介质访问(比如将各核心的缓存连接至共享缓存或存储器的总线)，所有缓存控制器都监听这一介质，以确定自己是否拥有该总线或交换访问上所请求块的副本。监听协议也可用作多芯片多处理器的一致性协议，有些设计在每个多核心内部目录协议的顶层支持监听协议!

采用微处理器(单核)的多处理器和缓存通过总线连接到单个共享存储器，所以监听协议的应用越来越多。总线提供了一种非常方便的广播介质，用于实现监听协议。在多核体系结构中，所有多核都共享芯片上的某一级缓存，所以这一状况有了大幅改变。因此，一些设计开始转而使用目录协议，因为其开销较低。为便于读者熟悉这两种协议，我们在这里重点介绍监听协议，在谈到DSM体系结构时再讨论目录协议。

监听一致性协议

有两种方法可以满足上一小节讨论的一致性需求。一种方法是确保处理器在写入某一数据项之前，获取对该数据项的独占访问。这种类型的协议被称为写入失效协议（write invalid protocol），因为它在执行写入操作时会使其他副本失效。到目前为止，这是最常用的协议。独占式访问确保在写入某数据项时，不存在该数据项的任何其他可读或可写副本：这一数据项的所有其他缓存副本都作废。

表5-2给出了一个失效协议的例子，它采用了写回缓存。为了了解这一协议如何确保一致性，我们考虑在处理器执行写入操作之后由另一个处理器进行读取的情景：由于写操作需要独占访问，所以进行读取的处理器所保留的所有副本都必须失效(这就是这一协议名称的来历)。

因此，在进行读取操作时，会在缓存中发生缺失，将被迫提取此数据的新副本。对于写入操作，我们需要执行写入操作的处理器拥有独占访问，禁止任何其他处理器同时写入。如果两个处理器尝试同时写入同一数据，其中一个将会在竞赛中获胜(稍后将会看到如何确定哪个处理器获胜)，从而导致另一处理器的副本失效。另一处理器要完成自己的写入操作，必须获得此数据的新副本，其中现在必须包含更新后的取值。因此，这一协议实施了写入串行化。

• 我们假定两个缓存在开始时都没有保存X的内容，存储器中的X值为0。处理器和存储器内容给出了完成处理器及总线操作之后的取值。空格表示没有操作或没有缓存副本。当B中发生第二次缺失时，处理器A反馈该取值，同时取消来自存储器的响应。此外，B缓存中的内容和X的存储器内容都被更新。存储器的这一更新过程是在存储器块变为共享时进行的，这种更新简化了协议，但只能在替换该块时才可能跟踪所有权，并强制进行写回。这就需要引入另外一个名为“拥有者”的状态，表示某个块可以共享，但当拥有该块的处理器在改变或替换它时，需要更新所有其他处理器和存储器。如果多核处理器使用了共享缓存(比如L3)，那么所有存储器都是透过这个共享缓存看到的；在这个例子中，L3的行为就像存储器一样，一致性必须由每个核心的专用L1和L2处理。正是由于这一观察结果，一些设计人员选择在多核心处理器中使用目录协议。为使这一方法生效，L3缓存必须是包含性的。

失效协议的一种替代方法是在写入一个数据项时更新该数据项的所有缓存副本。这种类型的协议被称为写入更新或写入广播协议。由于写入更新协议必须将所有写入操作都广播到共享缓存线上，所以它要占用相当多的带宽。为此，最近的多处理器已经选择实现一种写失效协议，本章的后续部分将仅关注失效协议。

基本实现技术

实现失效协议的关键在于使用总线或其他广播介质来执行失效操作。在较早的多芯片多处理器中，用于实现一致性的总线是共享存储器访问总线。在多核心处理器中，总线可能是专用缓存(Intel Core i7中的L1和L2)和共享外部缓存(i7中的L3)之间的连接。为了执行一项失效操作，处理器只获得总线访问，并在总线上广播要使其失效的地址。所有处理器持续监听该总线，观测这些地址。处理器检查总线上的地址是否在自己的缓存中。如果在，则使缓存中的相应数据失效。

在写入一个共享块时，执行写入操作的处理器必须获取总线访问权限来广播其失效。如果两个处理器尝试同时写入共享块，当它们争用总线时，会串行安排它们广播其失效操作的尝试。第一个获得总线访问权限的处理器会使它正写入块的所有其他副本失效。如果这些处理器尝试写入同一块，则由总线实现这些写入操作的串行化。这一机制有一层隐含意思：在获得总线访问权限之前，无法实际完成共享数据项的写入操作。所有一致性机制都需要某种方法来串行化对同一缓存块的访问，具体方式可以是审行化对通信介质的访问，也可以是对另一共享结构访问的串行化。

除了使被写入缓存块的副本失效之外，还需要在发生缓存缺失时定位数据项。在直写缓存中，可以很轻松地找到一个数据项的最近值，因为所有写入数据都会发回存储器，所以总是可以从存储器中找到数据项的最新值。(对缓冲区的写入操作可能会增加一些复杂度，必须将其作为额外的缓存项目加以有效处理。)

对于写回缓存，查找最新数据值的问题解决起来要困难一些，因为数据项的最新值可能放在专用缓存中，而不是共享缓存或存储器中。令人开心的是，写回缓存可以为缓存缺失和写入操作使用相同的监听机制：每个处理器都监听放在共享总线上的所有地址。如果处理器发现自已拥有被请求缓存块的脏副本，它会提供该缓存块以回应读取请求，并中止存储器(或L3)访问。由于必须从另一个处理器的专用缓存(L1或L2)提取缓存块，所以增加了复杂性，这一提取过程花费的时间通常长于从L3进行提取的时间。由于写回缓存对存储器带宽的需求较低，所以它们可以支持更多、更快速的处理器。结果，所有多核处理器都在缓存的最外层级别使用写回缓存，接下来研究以写回缓存来实现缓存的方法。

通常的缓存标记可用于实施监听过程，每个块的有效位使失效操作的实施非常轻松。读取缺失(无论是由失效操作导致，还是某一其他事件导致)的处理也非常简单，因为它们就是依赖于监听功能的。对于写入操作，我们希望知道是否缓存了写入块的其他副本，如果不存在其他缓存副本，那在写回缓存中就不需要将写入操作放在总线上。如果不用发送写入操作，既可以缩短写入时间，还可以降低所需带宽。

若要跟踪缓存块是否被共享，可以为每个缓存块添加一个相关状态位，就像有效位和重写标志位(dirty bit)一样。通过添加1个位来指示该数据块是否被共享，可以判断写入操作是否必须生成失效操作。在对处于共享状态的块进行写入时，该缓存在总线上生成失效操作，将这个块标记为独占。这个核心不会再发送其他有关该块的失效操作。如果一个缓存块只有唯一副本，则拥有该唯一副本的核心通常被称为该缓存块的拥有者。

在发送失效操作时，拥有者缓存块的状态由共享改为非共享(或改为独占)。如果另一个处理器稍后请求这一缓存块，必须再次将状态改为共享。由于监听缓存也能看到所有缺失，所以它知道另一处理器什么时候请求了独占缓存块，应当将状态改为共享。每个总线事务都必须检查缓存地址标记，这些标记可能会干扰处理器缓存访问。减少这种干扰的一种方法就是复制这些标记，并将监听访问引导至这些重复标记。

另一种方法是在共享的L3缓存使用一个目录，这个目录指示给定块是否被共享，哪些核心可能拥有它的副本。利用目录信息，可以仅将失效操作发送给拥有该缓存块副本的缓存。这就要求L3必须总是拥有L1或L2中所有数据项的副本，这一属性被称为包含。

示例协议

监听一致性协议通常是通过在每个核心中整合有限状态控制器来实施的。这个控制器回应由核心中的处理器和由总线(或其他广播介质)发出的请求，改变所选缓存块的状态，并使用总线访问数据或使其失效。从逻辑上来说，可以看作每个块有一个相关联的独立控制器；也就是说，对不同块的监听操作或缓存请求可以独立进行。在实际实施中，单个控制器允许交错执行以不同块为目标的多个操作。(也就是说，即使仅允许同时执行一个缓存访问或一个总线访问，也可以在一个操作尚未完成之前启动另一个操作。)另外别忘了，尽管我们在以下介绍中以总线为例，但在实现监听协议时可以使用任意互连网络，只要其能够向所有一致性控制器及其相关专用缓存进行广播即可。

我们考虑的简单协议有三种状态：无效、共享和已修改。共享状态表明专用缓存中的块可能被共享，已修改状态表明已经在专用缓存中更新了这个块;注意，已修改状态隐含表明这个块是独占的。表5-3给出了由一个核心生成的请求(在表的上半部分)和来自总线的请求(在表的下半部分)。这一协议是针对写回缓存的,但可以很轻松地将其改为针对直写缓存：对于直写缓存,只需要将已修改状态重新解读为独占状态，并在执行写入操作时以正常方式更新缓存。这一基本协议的最常见扩展是添加一种独占状态，这一状态表明块未被修改，但仅有一个专用缓存保存了这个块。

• 第四列将缓存操怍类型操作描述为正常命中或缺失(与单处理器缓存看到的情况相同)、替换(单处理器缓存督换缺失)或一致性(保持缓存一致性所需)；正常操作或替换操作可能会根据这个块在其他缓存中的状态而产生一致性操作。对于由总线监听到的读取缺失、写入缺失或无效操作，仅当读取或写入地址与本地缓存中的块匹配，而且这个块有效时，才需要采取动作。

在将一个失效动作或写入缺失放在总线上时，任何一个核心，只要其专用缓存中拥有这个缓存块的副本，就会使这些副本失效。对于写回缓存中的写入缺失，如果这个块仅在一个专用缓存中是独占的，那么缓存也会写回这个块；否则，将从这个共享缓存或存储器中读取该数据。图5-3显示了单个专用缓存块的有限状态转换图，它采用了写入失效协议和写回缓存。为简单起见，我们将复制这个协议的三种状态，用以表示根据处理器请求进行的状态转换(左图，对应于表5-3的上半部分)，和根据总线请求进行的状态转换(右图，对应于表5-3的下半部分)。图中使用黑体字来区分总线动作，与状态转换所依赖的条件相对。每个节点的状态代表着选定专用缓存块的状态，这一状态由处理器或总线请求指定。

图5-3 专用写回缓存的写入失效、缓存一致性协议，给出了缓存中每个块的状态及状态转换。缓存状态以圆圈表示，在状态名称下面的括号中给出了本地处理器允许执行但不会产生状态转换的访问。导致状态变换的激励以常规字体标记在转换弧上，因为状态转换而生成的总线动作以黑体标记在转换弧上。激励操作应用于专用缓存的块，而不是缓存中的特定地址。因此，在对一个共享状态的块产生读取缺失时，是对这个缓存块的缺失，而不是对不同地址的缺失。图形左侧显示的状态转换是由于此缓存相关处理器的操作而发生的，右侧显示的状态转换是根据总线上的操作而发生的。当处理器请求的地址与本地缓存块的地址不匹配时，会发生独占状态或共享状态的读取缺失以及独占状态的写入缺失。这种缺失是标准缓存替换缺失。在尝试写入处于共享状态的块时，会生成失效操作。每当发生总线事务时，所有包含此总线事务指定缓存块的专用缓存都会执行右图指定的操作。此协议假定，对于在所有本地缓存中都不需要更新的数据块，存储器(或共享缓存)会在发生对该块的读取缺失时提供数据。在实际实现中，这两部分状态图是结合在一起的。实践中，关于失效协议还有许多非常细微的变化，包括引入独占的未修改状态，说明处理器和存储器是否会在缺失时提供数据。在多核芯片中，共享缓存（通常是L3，但有时是L2）充当着存储器的角色，总线就是每个核心的专用缓存与共享缓存之间的总线，再由共享缓存与存储器进行交互

这一缓存协议的所有状态在单处理器缓存中也都是需要的，分别对应于无效状态、有效(与清洁)状态、待清理状态。在写回单处理器缓存中会需要图5-3左半部分中弧线所表示的大多数状态转换，但有一个例外，那就是在对共享块进行写入命中时的失效操作。图5-3中右半部分弧线所表示的状态转换仅对一致性有用，在单处理器缓存控制器中根本不会出现。

前面曾经提到，每个缓存只有一个有限状态机，其激励或者来自所连接的处理器，或者来自总线。图5-4说明图5-3中右半部分的状态转换如何与图中左半部分的状态转换相结合，构成每个缓存块的单一状态图。

囹5-4 缓存一致性状态图，由本地处理器引起的状态转换用黑色表示，由总线行为引起的以灰色表示。和图5-3中一样，有关转换的行为以粗体显示

为了理解这一协议为何能够正常工作，可以观察一个有效缓存块，它要么在一或多个专用缓存中处于共享状态，要么就在一个缓存中处于独占状态。只要转换为独占状态（处理器写入块时需要这一转换），就需要在总线上放置失效操作或写入缺失，从而使所有本地缓存都将这个块记为失效。另外，如果其他某个本地缓存已经将这个块设为独占状态，这个本地缓存会生成写回操作，提供包含期望地址的块。最后，对于处于独立状态的块，如果总线上出现对这个块的读取缺失，拥有其独占副本的本地缓存会将其状态改变共享。

图5-4中用灰色表示的操作用来处理总线上的读取缺失与写入缺失，它们实际上就是协议的监听部分。在这个协议及大多数其他协议中，还保留着另外一个特性：任何处于共享状态的存储器块在其外层共享缓存(L2或L3，如果没有共享缓存就是指存储器)中总是最新的，这一特性简化了实施过程。事实上，专用缓存之外的层级是共享缓存还是存储器并不重要；关键在于来自核心的所有访问都要通过这一层级。

尽管这个简单的缓存协议是正确的，但它省略了许多复杂因素，这些因素大大增加了实施过程的难度。其中最重要的一点是，这个协议假定这些操作具有原子性——在完成一项操作的过程中，不会发生任何中间操作。例如，这里讨论的协议假定可以采用单个原子动作形式来检测写入缺失、获取总线和接收响应。现实并非如此。事实上，即使读取缺失也可能不具备原子性；在多核处理器的L2中检测到缺失时；这个核心必须进行协调，以访问连到共享L3的总线。

非原子性操作可能会导致协议死锁，也就是进入一种无法继续执行的状态。对于多核处理器，处理器核心之间的一致性都在芯片上实施，或者使用监听协议，或者使用简单的集中式目录协议。许多双处理器芯片，包括Intel Xeon和AMD Opteron，都支持多芯片多处理器，这些多处理器可能通过连接高速接口(分别称为Quickpath或Hypertransport)来构建。这些下一级别的互连并不只是共享总线的扩展，而是使用了一种不同方法来实现多核互连。

用多个多核芯片构建而成的多处理器将采用分布式存储器体系结构，而且需要一种机制来保持芯片间的一致性，这一机制要高于、超越于芯片内部的此种机制。在大多数情况下，会使用某种形式的目录机制。

基本一致性协议的扩展

我们刚刚介绍的一致性协议是一种简单的三状态协议，经常用这些状态的第一个字母来称呼这一协议——MSI（Modified、Shared、Invalid）协议。这一基本协议有许多扩展，在本节图形标题中提到了这些扩展。这些扩展是通过添加更多的状态和转换来创建的，这些添加内容对特定行为进行优化，可能会使性能得到改善。下面介绍两种最常见的扩展。

• MESI向基本的MSI协议中添加了“独占”（Exclusive）状态，用于表示缓存块仅驻存在一个缓存中，而且是清洁的。如果块处于独占状态，就可以对其进行写入而不会产生任何失效操作，当一个块由单个缓存读取，然后再由同一缓存写入时，可以通过这一独占状态得以优化。当然，处于独占状态的块产生读取缺失时，必须将这个块改为共享状态，以保持一致性。因为所有后续访问都会被监听，所以有可能保持这一状态的准确性。具体来说，如果另一个处理器发射一个读取缺失，则状态会由独占改为共享。添加这一状态的好处在于：在由同一核心对处于独占状态的块进行后续写入时，不需要访问总线，也不会生成失效操作，因为处理器知道这个块在这个本地缓存中是独占的；处理器只是将状态改为已修改。添加这一状态非常简单，只需要使用1个位对这个一致状态进行编码，表示为独占状态，并使用重写标志位表示这个块已被修改。流行的MESI协议就采用了这一结构，这一协议是用它所包含的4种状态命名的，即已修改（Modified）、独占（Exclusive）、共享（Shared）和无效（Invalid）。Inteli7 使用了MESI协议的一种变体，称为MESIF，它添加了一个状态（Forward），用于表示应当由哪个共享处理器对请求作出回应。这种协议设计用来提高分布式存储器组成结构的性能。
• MOESI向MESI协议中添加了“拥有”（Owned）状态，用于表示相关块由该缓存拥有，在存储器中已经过时。在MSI和MESI协议中，如果尝试共享处于“已修改”状态的块，会将其状态改为“共享”(在原共享缓存和新共享缓存中都会做此修改)，必须将这个块写回存储器中。而在MOESI协议中，会在原缓存中将这个块的状态由“已修改”改为“拥有”，不再将其写到存储器中。(新共享这个块的)其他缓存使这个块保持共享状态；只有原缓存保持“拥有”
  状态，表示主存储器副本已经过期，指定缓存成为其拥有者。这个块的拥有者必须在发生缺失时提供该块，因为存储器中没有最新内容，如果替换了这个块，则必须将其写回存储器中。AMD Opteron使用了MOESI协议。

对称共享存储器多处理器与监听协议的局限性

随着多处理器中处理器数目的增长，或随着每个处理器对存储器需求的增长，系统中的任何集中式资源都可能变成瓶颈。利用片上提供的更高带宽的连接以及共享的L3缓存(它的速度要比存储器快)，设计人员可以尝试以对称形式支持4~8个高性能核心。这种方法不太可能扩展到远远超过8个核心的情况，一旦合并了多个多核心处理器，这种方法就无效了。每个缓存的监听带宽也可能产生问题，因为每个缓存必须检查总线上的所有缺失。我们曾
经提到，复制标记是一种解决方案。

另一种方法是在最外层缓存层级放置一个目录，这一方法已经在最近的某些多核处理器中得到应用。这个目录明确指出哪个处理器的缓存拥有最外层缓存中每一项的副本。这就是Intel在i7和Xeon 7000系统中使用的方法。注意，这个目录的使用不会消除因为处理器之间的共享总线及L3造成的瓶颈，但它实现起来要远比将在5.4节研究的分布式目录机制容易。

设计者如何提高存储器带宽，以支持更多或更快的处理器呢?为了提高处理器与存储器之间的通信带宽，设计者已经采用了多根总线和互连网络，比如交叉开关或小型点对点网络。在此类设计中，可以将存储器系统(主存储器或共享缓存)配置为多个物理组，以提升有效存储器带宽，同时还保持存储器访问时间的一致性。图5-5展示了在使用单芯片多核心来实现系统时，它会是什么样子。尽管利用这种方法可以在一块芯片上实现4个以上核心的互连，但它不能很好地扩展到那些使用多核心构建模块的多芯片多处理器，因为存储器已经连接到各个多核心芯片上，不再是集中式存储器。

图5-5 一种多核心单芯片多处理器，通过分组共享缓存实现一致存储器访问，使用互连网络而不是总线

AMD Opteron表示监听协议与目录协议之间的另一个中间点。存储器被直接连接到每个多核芯片，最多可以连接4个多核心芯片。其系统为NUMA，因为本地存储器多少会更快一些。Opteron使用点对点连接实现其一致性协议，最多向其他3个芯片进行广播。因为处理器之间的链接未被共享，所以一个处理器要想知道失效操作何时完成，唯一的方法就是通过显式确认。因此，一致性协议使用广播来查找可能共享的副本，这一点与监听协议类似，但它却使用确认来确定操作，这一点与目录协议类似。由于在Opteron实现中，本地存储器仅比远程存储器快一点点，所以一些软件把Opteron多处理器看作拥有一致存储器访问。

监听缓存一致性协议可以在没有集中式总线的情况下使用，但仍然需要完成广播，以监听各个缓存，获知潜在共享缓存块的所有缺失。这种缓存一致性通信是处理器规模与速度的另一限制。由于采用较大缓存并不会影响一致性通信，所以当处理器速度很快时，肯定会超出网络的负荷，每个缓存无法响应来自所有其他缓存的监听请求。

当处理器速度以及每个处理器的核心数目增大时，更多的设计人员会选择此类协议来避免监听协议的广播限制。

实施监听缓存一致性

2011年，大多数仅支持单芯多处理器的多核处理器已经选择使用共享总线结构，连接到共享存储器或共享缓存。相反，所有支持16个或更多个核心的多核多处理器系统都使用互连网络，而不是单根总线，设计人员必须面对一项挑战：在实现监听时，没有为实现事件的串行化而简化总线。前面曾经说过，在实际实现前面介绍的监听一致性协议时，最复杂的部分在于：在最近的所有多处理器中，写入缺失与更新缺失都不是原子操作。检测写入或更新缺失、其他处理器与存储器通信、为写入缺失获取最新值、确保所有失效操作可以正常进行、更新缓存，这些步骤不能在单个时钟周期内完成。

在单个多核心芯片中，如果(在改变缓存状态之前)首先协调连向共享缓存或存储器的总线，并在完成所有操作之前保持总线不被释放，那就可以有效地使上述步骤变成原子操作。处理器怎么才能知道所有失效操作何时完成呢？在一些多核处理器中，当所有必要失效操作都已收到并在进行处理时，会使用单根信号线发出信号。收到这一信号之后，生成缺失的处理器就可以释放总线，因为它知道在执行与下一次缺失相关的任意行为之前，可以完成所有必要操作。

只要在执行这些步骤期间独占总线，处理器就能有效地将各个步骤变为原子操作。在没有总线的系统中，我们必须寻找其他某种方法，将缺失过程中的步骤变为原子操作。具体来说，必须确保两个尝试同时写入同一数据块的处理器(这种情景称为竞争)保持严格排序：首先处理一个写入操作，然后再开始执行下一个。这两次写入操作中的哪一个操作会赢得竞争并不重要，因为只会有一个获胜者，它的一致性操作将被首先完成。在监听系统中，为了确保一次竞争仅有一个获胜者，会广播所有缺失，并利用互连网络的一些基本性质。这些性质，以及重启竞争失败者缺失处理的能力，是在无总线情况下实现监听缓存一致性的关键。

还可以将监听式与目录式结合在一起，有一些设计在多核处理器内部使用监听式，在多个芯片之间使用目录式，或者反过来，在多核处理器内部使用目录式，在多个芯片之间使用监听式。

对称共享存储器多处理器的性能

在使用监听式一致性协议的多核处理器中，其性能通常由几种不同现象共同决定。具体来说，总体缓存性能由两个因素共同决定，一个是由单处理器缓存缺失造成的流量，另一个是通信传输导致的流量，它会导致失效及后续缓存缺失。改变处理器数目、缓存大小和块大小能够以不同方式来影响缺失率的这两个分量，最终得到受这两种因素共同影响的总体系统性能。

对单处理器缺失率进行3C分类，即容量（capacity）、强制（compulsory）和冲突（conflict），并深入讨论了应用特性和对缓存设计的可能改进。与此类似，因为处理器之间的通信而导致的缺失(经常被称为一致性缺失)可以分为两种独立源。

第一种来源是所谓的真共享缺失，源自通过缓存一致性机制进行的数据通信。在基于失效的协议中，处理器向共享缓存块的第一次写入操作会导致失效操作，以确保对这个块的拥有关系。此外，当另一处理器尝试修改这个缓存块中的已修改字时，要发生缺失，并传送结果块。由于这两种缺失都是因为处理器之间的数据共享而直接导致的，所以将其划分为真共享缺失。

第二种效果称为假共享缺失，它的出现是因为使用了基于失效的一致性算法，这种算法利用了数据块的有效位，每个缓存块只有一个有效位。如果因为写入块中的某个字(不是正被读取的字)而导致一个块失效(而且后续引用会导致失败），就会发生假共享。如果接收到失效操作的处理器真的正在使用要写入的字，那这个引用就是真正的共享引用，无论块大小如何都会导致缺失。但是，如果正被写入的字和读取的字不同，那就不会因为这一失效操作而传送新值，而只是导致一次额外的缓存缺失，所以它是假共享缺失。在假共享缺失中，块被共享，但缓存中的字都没有被实际共享，如果块大小是单个字，那就不会发生缺失。通过下面的例子可以理解这些共享模式。

假定x1和x2两个字位于同一缓存块中，这个块在P1和P2的缓存中均为共享状态。假定有以下一系列事件，确认每个缺失是真共享缺失，还是假共享缺失，或是命中。如果块大小为一个字节，那么所发生的所有缺失都被认定为真共享缺失。

下面是按时序进行的分类。

1. 这一事件是真共享缺失，因为x1由P2读取，需要由P2发出失效操作。
2. 这一事件是假共享缺失，因为x2是由于P1中写入x1而导致失效的，但P2并没有使用x1的值。
3. 这一事件是假共享缺失，因为包含x1的块是因为P2中的读取操作而被标记为共享状态的，但P2并没有读取x1。在P2读取之后，包含x1的缓存块将处于共享状态；需要一次写入缺失才能获取对该数据块的独占访问。在一些协议中，会将这种情况作为更新请求进行处理，它会生成总线失效，但不会传送缓存块。
4. 这一事件是假共享缺失，原因与步骤3相同。
5. 这一事件是真共享缺失，因为正在读取的值是由P2写入的。

尽管我们将会看到真假共享缺失在商业工作负载中的影响，但对于共享大量用户数据的紧耦合应用程序来说，一致性缺失的角色更重要一些。

商业工作负载

在这一节，我们将研究一个四处理器共享存储器多处理器在运行通用商业工作负载时的存储器系统特性。我们讨论的这一研究是在1998年用一个四处理器Alpha系统完成的，但对于一个多处理器在执行此类工作负载时的性能问题，这一研究仍然最全面、最深入。

这一研究中使用的工作负载包括以下3个应用程序。

1. 根据TPC-B（其存储器特性类似于它的较新版本TPC-C）建模的联机事务处理（OLTP）工作负载，并以Oracle 7.3.2 为底层数据库。
2. 基于TPC-D的决策支持系统（DSS）工作负载，（TPC-D是广泛使用的TPC-E的较早版本），这一工作负载也以Oracle 7.3.2为底层数据库。
3. Web索引搜索（AltaVista）基准测试，其基础是对AltaVista 数据库存储器映射版本（200GB）的搜索。深入优化了内层循环。因为搜索结构是静态的，所以线程之间几乎不需要同步。

表5-5显示了在用户模式、内核和空间循环中所用时间的百分比。I0的频率会同时增加内核时间和空闲时间。AltaVista 将整个搜索数据库映射到存储器中，而且经过了广泛调优，它的内核时间或空闲时间最少。

商业工作负载的性能测量

我们先来看看这些基准测试在四处理器系统中的总体处理器执行情况，这些基准测试包括大量的I/O时间，在处理器时间测试数据中忽略了这些时间。我们将6个DSS查询看作一个基准测试，报告其平均特性。这些基准测试的实际CPI变化很大，从AltaVista Web搜索的1.3到DSS工作负载的平均1.6，再到OLTP工作负载的7.0。图5-6显示了如何将执行时间分解为指令执行时间、缓存与存储器系统访问时间及其他停顿(主要是流水线资源停顿，但也
包括转换旁枧缓冲区(TLB）和分支预测错误停顿)。尽管DSS与AltaVista工作负载的性能处于合理范围内，但0LTP工作负载的性能非常差，这是由于存储器层次结构的性能过差所致。

由于OLTP工作负载对存储器系统的要求更多，而且存在大量成本高昂的L3缺失，所以我们主要研究L3缓存大小、处理器数目和块大小对OLTP基准测试的影响。图5-7显示了增大缓存大小的影响，使用两路组相联缓存，缩减大量冲突缺失。随着L3缓存的增大，执行时间会因为L3缺失的减少而缩短。令人惊讶的是，几乎所有这些改进都是在1~2MB范围内发生的，超过这一范围之后，尽管当缓存为2MB和4MB时，缓存缺失仍然是造成大幅性能损失的愿因，但几乎没有多少改进了。问题是为什么呢?

图5-6 3个程序(OLTP、DSS和AltaVista)在商业工作负载中的执行时间分解。DSS数字是6个不同查询的平均值。CPI 的变化很大，从AltaVista较低的1.3，到DSS查询的1.61，再到OLTP的7.0。“其他停顿”包括资源停顿(用21164上的重放陷阱实现)、分支预测错误、存储器屏障和TLB缺失。对于这些基准测试，因为资源而导致的流水线停顿是主要因素。这些数据结合了用户与内核访问的行为。只有OLTP的内核访问占有重要比例，内核访问的表现要优于用户访问!

图5-7 在L3缓存大小变化时，OLTP工作负载的相对性能，L3缓存设定为两路组相联，从1 MB增大到8 MB。空闲时间随缓存大小的增大而延迟，降低了一些性能增益。这一增长是因为当存储器系统停顿较少时，需要更多的服务器进程来隐藏IO延迟。可以重新调整工作负载，以提高计算/通信平衡性能，将空闲时间保持在可控范围内。PAL代码是一组以优先模式执行的专用操作系统级指令序列；TLB缺失处理程序就是这样一个例子

为了更好地理解这个问题的答案，我们需要确定造成L3缺失的因素，以及当L3缓存增长时，它们是如何变化的。图5-8给出了这些数据，显示了来自5个来源的每条指令所造成的存储器访问周期数。当L3的大小为1MB时，L3存储器访问周期的两个最大来源是指令和容量/冲突缺失，当L3较大时，这两个来源降低为次要因素。遗憾的是，强制、假共享和真共享缺失不受增大L3的影响。因此，在4 MB和8 MB时，真共享缺失占主导地位；当L3缓存大小超过2MB时，由于真共享缺失没有变化，从而限制了总体缺失率的减少。

图5-8 当缓存大小增加时，占用存储器访问周期的各项因素会发生偏移。L3 缓存被模拟为两路组相联

增大缓存大小可以消除大多数单处理器缺失，但多处理器缺失不受影响。增大处理器数目如何影响各种不同类型的缺失呢？图5-9给出了这些数据，其中假定所采用的基本配置为2 MB、两路组相联L3缓存。可以预期，真共享缺失率的增加(降低单处理器缺失不会对其有所补偿)导致每条指令的存储器访问周期增大。

我们研究的最后一个问题是：增大块大小对这一工作负载是否有所帮助(增大块大小应当能够降低指令和冷缺失率，在限度范围内，还会降低容量/冲突缺失率，并可能降低真共享缺失率)。图5-10显示了当块大小由32字节变化到256字节时，每千条指令的缺失数目。将块大小由32字节变化到256字节会影响到4个缺失率分量。

• 真共享缺失率的降低因数大于2，表示真共享模式中存在某种局域性。
• 强制缺失率显著降低，与我们的预期一致。
• 冲突/容量缺失有小幅降低(降低因数为1.26，而在增大块大小时的降低因数为8），表示当L3缓存大于2MB时所发生的单处理器缺失没有太高的空间局域性。
• 假共享缺失率接近翻番，尽管其绝对数值较小。

对指令缺失率缺乏显著影响，这一事实是令人惊讶的。如果有一个仅包含指令的缓存具备这一特性，那就可以得出结论：其空间局域性非常差。在采用混合L2缓存时，诸如指令数据冲突之类的其他影响也可能会导致较大块中产生较高的指令缓存缺失。其他研究已经表明，在大型数据库和OLTP工作负载(它们有许多小的基本块和专用代码序列)的指令流中，空间局域性较低。根据这些数据，可以将块大小为32字节的L3的缺失代价作为基准，将块大小较大的L3的缺失代价表示为前者的倍数。

图5-9当处理器数目增大时，存储器访问周期的各项导致因素因为真共享缺失的培加而增加。由于每个处理器现在必须处理更多的强制缺失，所以强制缺失会稍有增加

图5-10当L3缓存的大小增加时，每千条指令的缺失数目稳定下降，所以L3块大小至少应当为128字节。L3缓存的大小为2 MB,两路组相联

由于现代DDR SDRAM加快了块访问速度,所以这些数字看起来是可以实现的，特别是块大小为128 字节的情况。当然，我们还必须考虑增加存储器通信量以及与其他核心争用存储器的影响。后一效果可能很轻松地抵销通过提高单个处理器性能而获得的增益。

多重编程和操作系统工作负载

我们的下一项研究是包括用户行为和操作系统行为的多重编程工作负载。所使用的工作负载是Andrew基准测试编译阶段的独立副本，这一基准测试模拟了软件开发环境。其编译阶段使用8个处理器执行Unix make命令的一个并行版本。这一 工作负载在8个处理器上运行5.24秒，生成203个进程，对3个不同文件系统执行787次磁盘请求。运行此工作负载使用了128 MB存储器，没有发生分页行为。

此工作负载有3个截然不同的阶段：

• 编译基准测试，涉及大量计算行为；
• 将目标文件安装到一个库中；
• 删除目标文件。

最后一个阶段完全由I/O操作主导；只有两个进程是活动的(每个运行实例有一个进程)。在中间阶段，I/O也扮演着重要角色，处理器大多处于空闲状态。与经过仔细调优的商业工作负载相比，这个总体工作负载涉及的系统操作和IO操作要多得多。

为进行工作负载的测量，我们假定有以下存储器和I/O系统。

• 第一级指令缓存——32 KB，两路组相联，块大小为64字节，命中时间为1个时钟周期。
• 第一级数据缓存——32 KB，两路组相联，块大小为32字节，命中时间为1个时钟周期。我们改变L1数据缓存，以研究它对缓存特性的影响。
• 第二级缓存——1 MB一致缓存，两路组相联，块大小为128字节，命中时间为1个时钟周期。
• 主存储器——总线上的唯一存储器，访问时间为100个时钟周期。
• 磁盘系统——固定访问延迟为3 ms (小于正常值，以缩短空闲时间)。

表5-6显示如何针对使用上述参数的8个处理器来分解其执行时间。执行时间被分解为以下4个分量。

1. 空闲——在内核模式空闲循环中执行。
2. 用户——以用户模式执行。
3. 同步——执行或等待同步 变量。
4. 内核——在既未处于空闲状态也没有进行同步访问的操作系统中执行。

表5-6 多重编程并行“make”工作负载中执行时间的分布

• 当8个处理器中仅有1个处于活动状态时，空闲时间之所以占很大比例是因为磁盘延迟的原因。

这一多重编程工作负载的指令缓存性能损失非常明显，至少对操作系统如此。当块大小为64字节、采用两路组相联缓存时,操作系统中的指令缓存缺失率由32 KB缓存的1.7%变为256 KB缓存的0.2%。对于各种缓存大小，用户级指令缓存缺失大体为操作系统缺失率的六分之一。这一点部分解释了如下事实：尽管用户代码执行的指令数为内核的9倍，但这些指令占用的时间仅为内核所执行少量指令的4倍。

多重编程和操作系统工作负载的性能

在这一小节，我们研究多重编程工作负载在缓存大小、块大小发生变化时的缓存性能。由于内核特性与用户进程性能之间的差异，我们将这两个分量保持分离。别忘了，用户进程执行的指令是内核的8倍，所以整体缺失率部分由用户代码中的缺失率决定，后面将会看到，这一缺失率通常是内核缺失率的五分之一。

尽管用户代码执行更多的指令，但与用户进程相比，操作系统的特性可能导致更多的缓存缺失，除了代码规模较大和缺少局域性之外，还有两个原因。第一，内核在将页面分配给用户之前，会对所有页面进行初始化。第二，内核实际上是共享数据的，因此其一致性缺失率不可忽视。与之相对，用户进程只有在不同处理器上调度进程时才会导致一致性缺失，而这一部分缺失率是很小的。

图5-11给出了当数据缓存大小、块大小变化时，数据缺失率的内核及用户部分。增大数据缓存大小对用户缺失率的影响要大于对内容缺失率的影响。增大块大小对于两种缺失率都有正面影响，这是因为很大一部分缺失是因为强制和容量导致，这两者都可能通过增大块大小加以改进。由于一致性缺失相对来说更为罕见，所以增大块大小的负面影响很小。为了了解内核与用户进程的行为为什么会不同，我们可以看看内核缺失是如何表现的。

图5-11 在增大L1数据缓存大小(左图)及增大L2数据缓存块大小时(右图)，数据缺失率的用户分量及内核分量表现不同。将L1数据缓存由32KB增大到256KB(块大小为32字节)导致用户缺失率的降低大于内核缺失率：用户级缺失率的下降因数大约为3，而内核级缺失率的下降因数仅为13。当L1块大小增大时（保持L1缓存为32 KB），缺失率的用户分量及内核分量都会稳定下降。与增大缓存大小的影响相对，增大块大小会显著降低内核缺失率(当块大小由16字节变为128字节时，内核引用的下降因数仅略低于4，而用户引用则略低于3)

图5-12显示了缓存大小及块大小增大时，内核缺失的变化。这些缺失被分为三类：强制缺失、一致性缺失(由真、假共享导致)和容量/冲突缺失(包括由于操作系统与用户进程之间和多个用户进程之间的干扰所导致的缺失)。图5-12证明：对于内核引用，增大缓存大小只会降低单处理器容量/冲突缺失率。与之相对，增大块大小会导致强制缺失率的降低。当块大小增大时，一致性缺失率没有大幅增大，这意昧着假共享效率可能不是很明显，尽管此类缺失可能会抵消通过降低真共享缺失所带来的增益。

图5-12 在8个处理器上运行多重编程工作负载，当L1数据缓存大小由32 KB变化为256 KB时，内核数据缺失率分量的变化。强制缺失率分量保持不变，因为它不受缓存大小的影响。容量分量的下降因数大于2，而一致性分量几乎翻番。一致性缺失增大的原因在于：发生冲突的项目会由于容量原因而变少，所以失效操作导致发生缺失的可能性会随着缓存大小的增大而增大。可以预料，L1 数据缓存的块大小增加会大幅降低内核引用中的强制缺失率。它对容量缺失率也有显著影响，在块大小的变化范围中，这一缺失率的降低因数为2.4。增加块大小只能少量减少一致性通信流量，它在64字节时稳定下来，在变为128字节时，一致性缺失率没有变化。由于当块大小增加时一致性缺失率没有显著降低，所以因为一致性所导致的缺失率部分由大约7%增长到大，约15%

如果我们研究每次数据引用所需要的字节数，如图5-13所示，可以看到内核的通信流量比较高，会随着块大小的增加而增加。很容易就能看出其原因：当块大小由16字节变为128字节时，缺失率大约下降3.7，但每次缺失传送的字节数增大8倍，所以总缺失通信量仅提高2倍多一点。当块大小由16字节变为128字节时，用户程序的增大也会超过2倍，但它的起始水平要低得多。

对于多重编程工作负载，操作系统对存储器系统的要求要严格得多。如果工作负载中包含了更多的操作系统行为或类似于操作系统的行为，而且其特性类似于这一工作负载测量的结果，那就很难构建貝有足够功能的存储器系统。一种可能是提高性能的方法是让操作系统更多地了解缓存，可能是通过更好的编程环境，也可能通过程序员的帮助来实现。例如，操作系统会为不同系统调用发出的请求而重复利用存储器。尽管被重复利用的存储器将被完全改写，但硬件并没有意识到这一点，它会尝试保持一致性，即使缓存块不会被读取，也会坚持认为存在这一可能性。这一行为类似于在过程调用时重复利用栈位置。IBM Power系列就已经允许编译器在过程调用时指示这种行为类型，最新的AMD处理器也提供类似支持。系统是很难检测这种行为的，所以可能需要程序员提供帮助，其回报可能要大得多。

操作系统与商业工作负载对多处理器存储器系统提出了非常严酷的挑战，而且它们与科学应用程序不同，不太适合进行算法或编译器重构。随着核心数目的增加，预测此类应用程序的行为也会变得更为困难。一些模拟或仿真技术可以用大型应用程序(包括操作系统)对数百个核心进行仿真，它们对于坚持设计的分析与量化方法至关重要。

图5-13当块大小增加时，对于内核分量与用户分量，每次数据引用所需要的字节数据会增加。

分布式共享存储器和目录式一致性

我们在5.2节讨论过，监听协议在每次发生缓存缺失时都需要与所有缓存进行通信，包括对共享数据进行的写入操作。监听式机制没有任何用于跟踪缓存状态的集中式数据结构，这是它的一个基本优点（因为这样可以降低成本），但考虑到可伸缩性时，这也成了它的“阿基里斯脚跟”。例如，考虑一个由四核多核心组成的多处理器，它能够保持每个时钟周期一次数据引用的速率，时钟速率为4 GHz。

尽管这些实验中的缓存很小，但大多数通信量都是一致性通信流量，不受缓存大小的影响。尽管现代总线可以达到4 GB/s的带宽，但170 GB/s还是远远超过了任何总线式系统的能力。在最近几年中，多核处理器的发展迫使所有设计人员转向某种分布式存储器，以支持各个处理器的带宽要求。

我们可以通过分布式存储器来提高存储器带宽和互连带宽，如图5-2 所示；这样会立刻将本地存储器通信与远程存储器通信隔离开来，降低了对存储器系统和互连网络的带宽要求。除非不再需要一致性协议在每次缓存缺失时都进行广播，否则通过分布式存储器不会有太大收益。如前所述，监听式一致性协议的替代方法是目录式协议。目录中保存了每个可缓存块的状态。这个目录中的信息包括哪些缓存(或缓存集合)拥有这个块的副本，它是否需要更新，等等。在一个拥有共享最外层缓存(即L3)的多核心中，实现目录机制比较容易：只需要为每个L3块保存一个位向量，其大小等于核心的数目。这个位向量表示哪些专用缓存的L3中可能拥有一个块的副本，失效操作仅会发送给这些缓存。如果L3是包含性的，那这一方法对于单个多核心是非常有效的，在Intel i7中就是采用了这一机制。

在多核心中使用单个目录时，即使它能避免广播，这种解决方案也是不可能扩展的。这个目录必须是分布式的，但其分布方式必须能够让一致性协议知道 去哪里寻找存储器所有缓存块的目录信息。一个容易想到的解决方案是将这个目录与存储器分布在一起，使不同一致性请求可以进入不同目录，就像不同存储器请求进人不同存储器一样。分布式目录保留了如下特性：块的共享状态总是放在单个已知位置。利用这一性质，再另外维护一些信息 ，指出其他哪些节点可能缓存这个块，就可以让一致性协议避免进行广播操作。图5-14显示了在向每个节点添加目录时，分布式存储器多处理器的样子。

图5-14 向每个节点添加一个目录，以在分布式存储器多处理器中实施缓存一致性。在本例中，节点被显示为单个多核芯片，相关存储器的目录信息可能驻存在多核心处理器的内部，也可能在其外部。每个目录负责跟踪一些缓存，这些缓存共享该节点内部部分存储器的存储器地址。一致性机制可能会维护多核心节点内部的目录信息，并处理所需要的一致性操作

最简单的目录实现方法是将每个存储器块与目录中的一项相关联。在这种实现方式中，信息量与存储器块数(每个块的大小与L2或L3缓存块相同)和节点数的乘积成正比，其中一个节点就是在内部实施一致性的单个多核心处理器或一小组处理器。对于处理器少于数百个的多处理器而言(每个处理器可能是多核的），这一开销不会导致问题，因为当块大小比较合理时，目录幵销是可以忍受的。对于大型多处理器，需要一些方法来高效地扩展目录结构，不过，只有超级计算机规模的系统才需要操心这一点。

目录式缓存一致性协议：基础知识

和监听式协议一样，目录式协议也必须实现两种主要操作：处理读取缺失和处理共享、清洁缓存块的写入操作。(对于当前正被共享的块，其写入缺失的处理就是上述两种操作的组合。)为实现这些操作，目录必须跟踪每个缓存块的状态。在简单协议中，这些状态可能为下列各项之一。

• 共享：一或多个节点缓存了这个块，存储器的值是最新的(所有缓存中也是如此)。,
• 未缓存：所有节点都没有这个缓存块的副本。
• 已修改：只有一个节点有这个缓存块的副本，它已经对这个块进行了写操作，所以存储器副本已经过期。这个处理器被称为这个块的拥有者。

除了跟踪每个潜在共享存储器块的状态之外，我们还必须跟踪哪些节点拥有这个块的副本，在进行写入操作时需要使这些副本失效。最简单的方法是为每个存储器块保存一个位向量，当这个块被共享时，这个向量的每一位指明相应的原处理器芯片(它可能是一个多核心)是否拥有这个块的副本。当存储器块处于独占状态时，我们还可以使用这个位向量来跟踪块的拥有者。为了提高效率，还会跟踪各个缓存中每个缓存块的状态。

每个缓存中状态机的状态与转换都和监听缓存中使用的状态机相同，只不过在发生转换时的操作稍有不同。用于定位一个数据项独占副本并使其失效的过程有所不同，因为它们需要在发出请求的节点与目录之间进行通信，在目录与一或多个远程节点进行通信。在监听式协议中，这两个步骤通过向所有节点进行广播而结合在一起。

在查看这种协议的状态图之前，先来研究一下为了处理缺失和保持一致性而可能在处理器和目录之间传送的消息类型，这样会有所帮助。表5-7给出了节点之间发送的消息类型。本地节点是发出请求的节点。主节点（home node）就是一个地址的存储器位置及目录项所在的节点。物理地址空间是静态分布的，所以事先知道哪个节点中包含给定物理地址的存储器与目录。例如，高阶位可以提供节点编号，低阶位提供节点上存储器内的偏移。本地节点也可能是主节点。当主节点是本地节点时，由于副本可能存储于第三节点上(称为远程节点），所以必须访问该目录。

表5-7在节点之间为保证一致性而发送的可能消息，以及源节点和目标节点、消息内容(p=发出请求的节点编号，A=所请求的地址，D=数据内容)，和消息的功能

• 前3条消息是由本地节点发送到主节点的请求。第四个到第六个是当主节点需要数据来满足读取缺失或写入缺失请求时，向远程节点发送的消息。数据应答消息用于由主节点向发出请求的节点传送一个取值。在两种情况下需要对数据值执行写回操作：一种情况是，如果替换了缓存中的一个数据块，且必须写回到它的主存储器中；另一种情况是，对来自主节点的取数据消息或取数据/失效消息做应答时。只要数据块处于共享状态就执行写回操作，这祥能简化协议中的状态数目，这是因为任何脏数据块必须处于独占状态并且任何共享块总是可以在主存储器中获取。

远程节点是拥有缓存块副本的节点，这一副本可能独占（在此情况下只有一个副本），也可能共享。远程节点也可能与本地节点或主节点相同。在此类情况下，基本协议不会改变，但处理器之间的消息可能会被处理器内部的消息代替。

在这一节，我们采用存储器一致性的一种简单模型。为了在最大程度上减少这种类型的消息及协议的复杂性，我们假定这些消息的接受及处理顺序与其发送顺序相同。这一假定在实际中并不成立，可能会导致额外的复杂性。在这一节，我们利用这一假定来确保在传送新消息之前先处理节点发送的失效操作，就像在讨论监听式协议时的假设一样。和在监听情景中一样，我们省略了一些实现一致性协议所必需的细节。具体来说，要想实现写入操作的串行化，并获知某写入的失效操作已经完成，并不像广播式监听机制那样轻松，而是需要采用明确的确认方法来回应写入缺失和失效请求。

目录式协议举例

目录式协议中缓存块的基本状态与监听式协议中完全相同。目录中的状态也与我们前面展示的状态类似。因此，我们首先看一个简单的状态图，它给出了一个具体缓存块的状态转换，然后再研究与存储器中每一个块相对应的目录项的状态图。和监听情景中一样，这些状态转换图并没有给出一致性协议的所有细节；但是，实际控制器调度依赖于多处理器的大量细节(消息发送特性、缓冲结构，等等)。在这一节，我们给出了基本的协议状态图。

图5-15显示了一个具体缓存对应的协议操作。所使用的符号与上一节相同，来自节点外部的请求用灰色表示，操作用黑色表示。一个具体缓存的状态转换由读取缺失、写入缺失和状态提取请求导致；图5-15显示了这些操作。一个具体缓存也会生成这些读取缺失、写入缺失和失效消息，它们会被发送给主目录。读取缺失与写入缺失要求数值回复，这些事件在改变状态之前会等待回复。如何知道失效操作何时完成，那是另一个问题，另行处理。

图5-15 目录式系统中一个具体缓存块的状态转换图。本地处理器的请求用黑色表示，来自主目录的请求用灰色表示。这些状态与监听式系统中相同，而且事务非常类似，用显式失效与写回请求来代替向总线正式广播的写入缺失。与监听控制器中一样，我们仍然假定在尝试写入共享缓存块时将被作为缺失而进行处理；在实践中，这样的事务可以看作拥有权请求或升级请求，可以在未请求所提取缓存块的同时提交拥有权

图5-15中缓存块状态转换图的操作基本上与监听情景中一样：状态是相同的，激励也几乎相同。写入缺失操作由数据提取和失效操作替代，失效操作由目录控制器选择性地发送，而在监听机制中，写入缺失操作是在总线(或其他网络)上广播的。与监听协议一样，在写入缓存块时，它必须处于独占状态，所有共享块都必须在存储器中进行更新。在许多多核处理器中，在核心之间共享处理器缓存的最外层级，处于这一级别的硬件将在同一芯片上每个核心的专用缓存之间保持一致性，或者使用内部目录实现，或者使用监听实现。因此，只需要与最外层共享缓存进行交互，就能使用芯上多核一致性机制在大量处理器之间扩展一致性。因为这一交互是在L3层级进行的，所以处理器与一致性请求之间的争用就不会导致问题，也可以避免标签的复制。

在目录式协议中，目录实现了一致性协议的另一半。发向目录的一条消息会导致两种不同类型的操作：更新目录状态；发送附加消息以满足请求。目标中的状态表示一个块的三种标准状态；但与监听机制中不同的是，目录状态表示一个存储器块所有缓存副本的状态，而不是表示单个缓存块的相应信息。

存储器块可能未由任何节点缓存，可能缓存于多个节点中并可读（共享），也可能仅在一个节点中独占缓存并可写。除了每个块的状态之外，目录还会跟踪拥有某一缓存块副本的节点集合；我们使用名为共享器的集合来执行这一功能。在节点数少于64的多处理器中(每个节点可能表示4~8倍的处理器），这一集合通常表示为位向量。目录请求需要更新这个共享器集合，还会读取这个集合，以执行失效操作。

图5-16给出了在目录中为回应所接收消息而采取的操作。目录接收三种不同请求：读取缺失、写入缺失和数据写回。目录发送的回应消息用粗体表示，而集合“共享器”的更新用黑色表示。因为所有激励消息都来自外部，所以所有操作都以灰色表示。我们的简化协议假定一些操作是原子操作，比如请求某个值并将其发送给另一个节点。

为了理解这些目录操作，让我们逐个状态查看所接收的请求和所采取的操作。当块处于未缓存状态时，存储器中的副本就是当前值，所以对这个块的请求只能是以下两种。

• 读取缺失——从存储器向发出请求的节点发送其请求的数据，请求者成为唯一的共享节点。块的状态变为共享。
• 写入缺失——向发送请求的节点传送取值，该节点变为共享节点。这个块变为独占状态，表明缓存了唯一有效副本。共享器指明拥有者的身份。

当块处于共享状态时，存储器值是最新的，所以可能出现相同的两个请求。

• 读取缺失——从存储器向发出请求的节点发送其请求的数据，请求者被添加到共享集合中。
• 写入缺失——向请求节点发送取值。向共享者集合中的所有节点发送失效消息，共享者集合将包含发出请求的节点的身份。这个块的状态变为独占状态。

当块处于独占状态时，这个块的值保存在一个节点的缓存中，这个节点由共享者(拥有者)集合识别，所以共有3种可能的目录请求。

• 读取缺失——向拥有者发送数据提取消息，它会将拥有者缓存中这个块的状态转变为共享，拥有者将数据发送给目录，再在这里将其写到存储器中，并发给提出请求的处理器。将发出请求的节点的身份添加到共享者集合中，这个集合中仍然包含拥有者处理器的身份(因为这个处理器仍然拥有可读副本)。
• 数据写回——拥有者正在替换这个块，因此必须将其写回。这个写回操作会更新存储器副本（主目录实际上变为拥有者），这个块现在未被缓存，共享者集合为空。
• 写入缺失——这个块有一个新的拥有者。向旧拥有者发送一条消息，将其缓存中的这个块失效，并将值发送给目录，从目录中发送给提出请求的节点，这个节点现在变成新的拥有者。共享者被设定为新拥有者的身份，这个块仍然保持独占状态。

图5-16 目录的状态转移图与独立缓存的转移图具有相同的状态和结构。由于所有操作都是由外部导致的，所以均以灰色表示。粗体表示该目录回应请求所采取的操作

图5-16中的状态转换图是一种简化图，与监听式缓存的情景相同。在采用目录式协议时，以及用网络而非总线来实现监听机制时，协议需要处理非原子化存储器转换。

实际多处理器中使用的目录协议还进行了其他一些优化。具体来说，在这种协议中，在针对独占块发生读取缺失或写入缺失时，会首先将这个块发送到主节点上的目录中。再从这里将其存储到主存储器中，并发送给原来发现请求的节点。商用多处理器使用的许多协议都会将数据从拥有者节点直接转发给发出请求的节点(同时对主节点执行写回操作)。由于这些优化方法增大了死锁可能，并增加了必须处理的消息类型，所以通常会提高复杂性。

多芯片一致性和多核一致性有4种组合方式：监听/监听（AMD Opteron）、监听/目录、目录/监听和目录/目录!

同步：基础知识

同步机制通常是以用户级软件例程实现的，这些例程依赖于硬件提供的同步指令。对于较小型的多处理器或低争用解决方案，一种很关键的硬件功能是拥有不可中断的指令或指令序列，它们能以原子方式提取和改变一个值。软件同步机制就是利用这一功能实现的。这一节的重点是锁定及非锁定同步操作的实现。可以非常轻松地利用锁定和非锁定来创建互斥，并实现更复杂的同步机制。在高争用情景中，同步可能会成为性能瓶颈，因为争用会引入更多延迟，在此种多处理器中，延迟可能更大一些。

基本硬件原语

在多处理器中实施同步时所需要的关键功能就是一组能够以原子方式读取和修改存储器位置的硬件原语。没有这一功能，构建基本同步原语的成本就会过高，并随着处理器数目的增大而增大。基本硬件原语有许多替代方式，所有这些方式都能够以原子形式读取和修改一个位置，还有某种方法可以判断读取和写入是否以原子形式执行。这些硬件原语是一些基本构建模块，用于构建各种用户级别的同步操作，包括诸如锁和屏障之类的内容。我们首先来看这样一个硬件原语，说明如何用它来构建某些基本的同步操作。

一种用于构建同步操作的典型操作就是原子交换，它会将寄存器中的一个值与存储器的一个值进行交换。假定我们希望构建一个简单锁，数值0表示这个锁可以占用，数值1表示这个锁不可用。处理器尝试对这个锁进行置位，具体做法是将寄存器中的1与这个锁的相应存储器地址进行交换。如果其他某个处理器巳经申请了访问权，则这一交换指令将返回1，否则返回0。在后一种情况下，这个值也被改变为1，以防止任意进行竞争的交换指令也返回0。

例如，考虑两个处理器，每个处理器都尝试同时进行交换；只有一个处理器将会首先执行交换操作，并返回数值0，第二个处理器进行交换时将会返回1，所以不会存在竞争问题。使用交换原语来实现同步的关键是这个操作具有原子性：这一交换是不可分的，两个同时交换将由写入串行化机制进行排序。如果两个处理器尝试以这种方式对同步变量进行置位，它们不可能认为自己同时对这个变量进行了置位。

还有大量其他原子原语可用于实现同步。它们都拥有一个关键特性：它们读取和更新存储器值的方式可以让我们判断这两种操作是不是以原子形式执行的。在许多较旧的多处理器中存在一种名为测试并置位的操作，它会测试一个值，如果这个值通过测试则对其进行置位。比如，我们可以定义一个操作，它会检测0，并将其值设定为1，其使用方式与使用原子交换的方式类似。另一个原子同步原语是提取并递增：它返回存储器位置的值，并以原子方式使其递增。我们用0值来表示同步变量未被声明，可以像使用交换一样使用提取与递增。

实现单个原子存储器操作会引入一些挑战，因为它需要在单个不可中断的指令中进行存储器读取与写入操作。这一要求增加了一致性实施的复杂性，因为硬件不允许在读取与写入之间插人任何其他操作，而且不能死锁。

替代方法是利用一对指令，其中第二条指令可以返回一个值，根据这个值，可以判断这一对指令是否以原子形式执行。如果任一处理器执行的所有其他指令要么在这对指令之前执行，可么在这对指令之后执行，那就可以认为这对指令具有原子性。因此，如果一个指令对具有原子特性，那所有其他处理器都不能在这个指令对之间改变取值。

这种指令对包含一种名为链接载入或锁定载入的特殊载入指令和一种名为条件存储的特殊存储指令。这些指令是按顺序使用的：对于链接载入指令指定的存储器位置，如果其内容在对同一位置执行条件存储之前发生了改变，那条件存储就会失败。如果在两条指令之间进行了上下文切换，那么存储条件也会失败。条件存储的定义是在成功时返回1，失败时返回0。由于链接载入返回了初始值，而条件存储仅在成功时才会返回1，所以以下序列对R1内容指定的存储器位置实现了一次原子交换：

1
2
3
4
5
6

try:
        MOV     R3,R4     ; 移动交换值
        LL      R2,0(R1)  ; 链接载入
        SC      R3,0(R1)  ; 条件存储
        BEQZ    R3,try    ; 分支存储失败
        MOV     R4,R2     ; 将载入值放入 R4中

1
2
3
4
5

try:
        LL     R2,0(R1)    ; 链接载入
        DAODUI R3,R2,#1    ; 递增
        SC     R3,0(R1)    ; 条件存储
        BEQZ   R3,try      ; 条件存储失败

这些指令通常是通过在寄存器中跟踪LL指令指定的地址来实现的，这个寄存器称为链接寄存器。如果发生了中断，或者与链接寄存器中地址匹配的缓存块失效(比如，另一条SC使其失效），链接寄存器将被清除。SC指令只是核查它的地址与链接寄存器中的地址是否匹配。如果匹配，sc将会成功；否则就会失败。在再次尝试向链接载入地址进行存储之后，或者在任何异常之后，条件存储将会失败，所以在选择向两条指令之间插入的指令时必须非常小心。具体来说，只有寄存器寄存器指令才是安全的；否则，就有可能造成死锁情景，处理器永远无法完成SC。此外，链接载入和条件存储之间的指令数应当很小，以尽可能减少无关事件或竞争处理器导致条件存储频繁失败的情景。

使用一致性实现锁

在拥有原子操作之后，就可以使用多处理器的一致性机制来实施自旋锁（spin lock）一处理器持续用循环来尝试获取锁，直到成功为止。在两种情况下会用到自旋锁，一种是程序员希望短时间拥有这个锁，另一种情况是程序员希望当这个锁可用时，锁定过程的延迟较低。因为自旋锁会阻塞处理器，在循环中等待锁被释放，所以在某些情况下不适合采用。最简单的实施方法是在存储器中保存锁变量，在没有缓存一致性时将会使用这种实施方式。处理器可能使用原子操作持续尝试获得锁，测试这一交换过程是否返回了可用锁。为释放锁，处理器只需要在锁中存储数值0即可。下面的代码序列使用原子交换来锁定自旋锁，其地址在R1中：

1
2
3

        DADDUI R2, R0 ,#1
lockit: EXCH   R2, 0(R1)      ; 原子交换
        BNEZ   R2, lockit     ; 已经锁定?

要实现第一个好处（能够针对本地缓存副本进行循环，不需要在每次尝试获取锁时都生成存储器请求），需要对这个简单的自旋过程进行一点修改。上述循环中每次尝试进行交换时都需要一次写入操作。如果多个处理器尝试获取这个锁，会分别生成这一写入操作。这些写入操作大多会导致写入缺失，因为每个处理器都是尝试获取处于独占状态的锁变量。

因此，应当修改自旋锁过程，使其在自旋过程中读取这个锁的本地副本，直到看到该锁可用为止。然后它尝试通过交换操作来获取这个锁。处理器首先读取锁变量，以检测其状态。处理器不断地读取和检测，直到读取的值表明这个锁未锁定为止。这个处理器随后与所有其他正在进行“自旋等待”的处理器展开竞赛，看谁能首先锁定这个变量。所有进程都使用一条交换指令，这条指令读取旧值，并将数值1存储到锁变量中。唯一的获胜者将会看到0，而失败者将会看到由获胜者放在里面的1。

获胜的处理器在锁定之后执行代码，完成后将0存储到锁定变量中，以释放这个锁，然后再从头开始竞赛。下面的代码执行这一自旋锁：

1
2
3
4
5

lockit:     LD      R2, 0(R1)     ; 载入锁
            BNEZ    R2, lockit    ; 不可用——自旋
            DADDUI  R2, R0, #1    ; 载入锁定值
            EXCH    R2, 0(R1)     ; 交换
            BNEZ    R2, lockit    ; 如果锁不为 0，则跳转

这个例子显示了链接载入/条件存储原语的另一个好处：读取操作与写入操作是明确独立的。链接载入不一定导致任何总线通信。这一事实允许采用以下简单代码序列，它的特性与使用交换的优化版本一样（R1拥有锁的地址，LL代替了LD，SC代替了EXCH)：

1
2
3
4
5

1ockit:     LL     R2,0(R1)    ; 链接载入
            BNEZ   R2,lockit   ; 不可用——自旋
            DADDUI R2,R0,#1    ; 锁定值
            SC     R2,0(R1)    ; 存储
            BEQZ   R2,lockit   ; 如果失败则跳转

第一个分支构成了自旋循环，第二个分支化解当两个处理器同时看到锁可用时的竞赛。

*本表假定采用写入失效一致性。在开始时，P0拥有这个锁(步骤1），锁的值为1（即被锁定）；它最初为独占的，在步骤1开始之前由P0拥有。P0退出并解锁(步骤2)。P1和P2竞赛，看看谁能在交换期间看到未锁定值(步骤3至步骤5)。P2赢得竞赛，进入关键部分(步骤6与步骤7)，而P1的尝试失败，所以它开始自旋等待(步骤7和步骤8)。在实际系统中，这些事件将耗费更多时间，远多于8次时钟嘀嗒，因为获取总线和回复缺失所需要的时
间要长得多。一旦到了步骤8，这一过程就可以从P2开始重复，它最终获得独占访问，并将锁设置为0。

存储器连贯性模型：简介

缓存一致性保证了多个处理器看到的存储器内容是一致的。但它并没有回答这些存储器内容应当保持何种程度的一致性。我们问“何种程度的一致性”时，实际是在问一个处理器必须在什么时候看到另一个处理器更新过的值?由于处理器通过共享变量进行通信(用于数据值和.同步两种目的），于是这个问题便简化为：在不同处理器对不同位置执行读取和写入操作时，必须保持哪些特性?

“保持何种程度的一致性”这一问题看起来非常简单，实际上却非常复杂，我们通过一个简单例子来了解一下。下面是来自处理器P1和P2的两段代码，并排列出如下：

1
2
3
4
5

P1:     A=0         P2:     B = 0;
        ...                  ...
        A=1;                B = 1;
L1:     if (B = 0)  L2:     if (A == 0)
        ...                 ...

假定这些进程运行在不同处理器上，位置A和B最初由两个处理器进行缓存，初始值为0。如果写入操作总是立刻生效，而且马上会被其他处理器看到，那两个IF语句(标有L1和L2)不可能将其条件计算为真，因为能够到达IF语句，说明A或B中必然已经被指定了数值1。我们假定写入失效被延迟，处理器可以在这一延迟期间继续执行。 因此，P1 和P2在它们尝试读取数值之前，可能还没有(分别)看到B和A的失效。现在的问题是，是否应当允许这一行为?如果应当允许，在何种条件下允许?

存储器连贯性的最简单模型称为顺序连贯性模型。顺序连贯性要求任何程序每次执行的结果都是一样的，就像每个处理器是按顺序执行存储器访问操作的，而且不同处理器之间的访问任意交错在一起。有了顺序连贯性，就不可能再出现上述示例中的某些不明执行情况，因为必须完成赋值操作之后才能启动IF语句。

实现顺序连贯性模型的最简单方法是要求处理器推迟完成所有存储器访问，直到该访问操作所导致的全部失效均告完成为止。当然，如果推迟下一个存储器访问操作，直到前一访问操作完成为止，这种做法同样有效。别忘了，存储器连贯性涉及不同变量之间的操作：两个必须保持顺序的访问操作实际上访问的是不同的存储器位置。在我们的例子中，必须延迟对A或B的读取（A=0或B=0），直到上一次写入操作完成为止（B=1或A=1）。比如，根据顺序连贯性，我们不能简单地将写入操作放在写入缓冲区中，然后继续执行读取操作。

尽管顺序连贯性模型给出了一种简单的编程范例，但它可能会降低性能，特别是当多处理器的处理器数目很大或者互连延迟很长时尤为如此，如下例所示。

假定有一个处理器，一次写入缺失需要 50个时钟周期来确定拥有权，在确定拥有权之后发射每个失效操作需要10个时钟周期，在发射之后，失效操作的完成与确认需要80个时钟周期。假定其他4个处理器共享一个缓存块，如果处理器保持顺序连贯性，一次写入缺失会使执行写入操作的处理器停顿多长时间?假定必须明确确认失效操作之后，一致性控制器才能知道它们已经完成。假定在为写入缺失获得拥有者之后可以继续执行，不需要等待失效;该写入操作需要多长时间?

在等待失效时，每个写入操作花费的时间等于拥有时间再加上完成失效所需要的时间之和。由于失效操作可以重叠，所以只需要为最后一项操心，它是在确定拥有权之后开始的10+10+10+10=40 个时钟周期。因此，写入操作的总时间为50+40+80=170个时钟周期。与之相比，拥有时间只有50 个时钟周期。通过实现适当的写入缓冲区，甚至有可能在确定拥有权之前继续进行。

为了提供更好的性能，研究人员和架构师已经研究了两种不同路径。第一，他们开发了强大的实施方式，能够保持顺序连贯性，但使用延迟隐藏技术来降低代价。第二，他们开发了限制条件较低的存储器一致性模型，支持采用更快速的硬件。这些模型可能会影响程序员看到多处理器的方式，所以在讨论这些低限制模型之前，先来看看程序员有什么期望。

程序员的观点

尽管顺序连贯性模型有性能方面的不足，但从程序员的角度来看,它拥有简单性这一优点。挑战在于，要开发一种编程模型，既便于解释，又支持高性能实施方式。

有这样一种支持更高效实施方式的编程模型，它假定程序是同步的。如果对共享数据的所有访问都由同步操作进行排序，那就说这个程序同步的。如果满足以下条件，就说数据引用是由同步操作进行排序的：在所有可能的执行情景中，一个处理器对某一变量的写入操作与另一个处理器对这个变量的访问(或者为读取，或者为写入)之间由一对同步操作隔离开来，其中一个同步操作在写入处理器执行写入操作之后执行，另一个同步操作在第二个处理器执行访问操作之前执行。如果变量可以在未由同步操作进行排序的情况下更新，此类情景称为数据竞赛，因为操作的执行结果取决于处理器的相对速度，和硬件设计中的竞赛相似，其输出是不可预测的，由此给出另一种同步程序的名字：无数据竞赛。

给出一个简单的例子，变量由两个不同处理器读取和更新。每个处理器用锁定和解锁操作将读取和更新操作包围起来，这两种操作是为了确保更新的互斥和读取操作的连贯性。显然，每个写入操作与另一个处理器的读取操作之间现在都由一对同步操作隔离开来：一个是解锁(在写入操作之后），一个是锁定(在读取操作之前)。当然，如果两个处理器正在写入一个变量，中间没有插入读取操作，那这些写入操作之间也必须由同步操作隔离开。

人们普遍认同“大多数程序都是同步的”这一事实。这一观察结果之所以正确，主要是因为：如果这些访问是非同步的，那么到底哪个处理器赢得数据竞赛就由执行速度决定，从而会影响到程序结果，那程序的行为就可能是不可预测的。即使有了顺序连贯性，也很难理清此类程序。

程序员可能尝试通过构造自己的同步机制来确保排序，但这种做法需要很强的技巧性，可能导致充满漏洞的程序，而且在体系结构上可能不受支持，也就是说在以后各代多处理器中可能无法工作。因此，几乎所有的程序员都选择使用同步库，这些库正确无误，而且针对多处理器和同步类型进行了优化。

最后，标准同步原语的使用可以确保：即使体系结构实现了一种比顺序连贯性模型更宽松的连贯性模型，同步程序也会像硬件实施了顺序连贯性一样运行。

宽松连贯性模型：基础知识

宽松连贯性模型的关键思想是允许乱序执行读取和写入操作，但使用同步操作来实施排序，因此，同步程序的表现就像处理器具备顺序连贯性一样。 这些宽松模型是多种多样的，可以根据它们放松了哪种读取和写入顺序来进行分类。我们利用一组规则来指定顺序，其形式为X→Y，也就是说必须在完成操作X之后才能执行操作Y。顺序连贯性模型需要保持所有4种可能顺序：R→W、R→R、W→R和W→W。宽松模型的确定是看它们放松了这4种顺序中的哪一种。

1. 放松w→R顺序，将会得到一种称为完全存储排序或处理器连贯性的模型。由于这种排序保持了写入操作之间的顺序，所以许多根据顺序连贯性运行的程序也能在这一模型下运行，不用添加同步。
2. 放松W→W顺序，将会得到一种称为部分存储顺序的模型。
3. 放松R→W和R→R顺序，将会得到许多模型，包括弱排序、PowerPC连贯性模型和释放连贯性，具体取决于排序约束条件的细节和同步操作实施排序的方式。

通过放松这些排序，处理器有可能获得显著的性能提升。但是，在描述宽松连贯性模型时存在许多复杂性，包括放松不同顺序的好处与复杂性、准确定义写入完成的含义、决定处理器什么时候看到它自己写入的值。

交叉问题

由于多处理器重新定义了许多系统特性（例如，性能评估、存储器延迟和可伸缩性的重要性），所以它们引入了一些贯穿整个领域的重要设计问题，对硬件和软件都产生影响。在这一节，我们将给出一些与存储器连贯性问题有关的示例。随后研究在向多重处理中添加多线程时所能获得的性能。

编译器优化与连贯性模型

定义存储器连贯性模型的另一个原因是指定合法的编译器优化范围，可以针对共享数据来执行这些优化。在显式并行程序中，除非明确定义了同步点，而且程序被同步，否则编译器不能交换对两个不同共享数据项的读取操作和写入操作 ，因为这种转换可能会影响程序的本来语义。因此，一些相对简单的优化方式也无法实施，比如共享数据的寄存器分配，因为这种转换通常会交换读取和写入操作。在隐式并行程序中，程序必须被同步，而且同步点已知，所以不会出现这一问题。编译器能否从更宽松的连贯性模型中获得明显好处，无论是从研究的角度来看还是从实践的角度来看，这都依然是一个开放性的问题，由于缺乏统一模型，可能会妨碍编译器的部署进程。

利用推测来隐藏严格连贯性模型中的延迟

在第3章曾经看到，可以利用推测来隐藏存储器延迟。还可用来隐藏因为严格连贯性模型导致的延迟，获得宽松存储器模型的大多数好处。其关键思想是：处理器使用动态调度来重新安排存储器引用的顺序，让它们有可能乱序执行。乱序执行存储器引用可能会违犯顺序连贯性，从而影响程序的执行。利用推测处理器的延迟提交功能，可以避免这种可能性。假定一致性协议是以失效操作为基础的：如果处理器在提交存储器引用之前，收到该存储器引用的失效操作，处理器会使用推测恢复来回退计算，并利用失效地址的存储器引用重新开始。

如果处理器对存储器请求进行重新排序后，新执行顺序的结果不同于在顺序连贯性下看到的结果，处理器将会撤消此次执行。使用这一方法的关键在于：处理器只需要确保其结果与所有访问完全循序完成时是一样的，通过检测两种结果可能在什么时候出现不同，就可以做到这一点。由于很少会触发推测重启，所以这种方法很有吸引力。只有当非同步访问实际导致竞赛时，才会触发推测重启。Hill [1998]提倡将顺序连贯性或处理器连贯性与推测执行结合起来，作为一种连贯性模型。他的观点包括三个部分。第一，积极实现顺序连贯性或处理器连贯性，可以获得更宽松模型的大多数好处。第二，这种实施方式仅对推测处理器增加了非常少的实施成本。第三，这种方法允许程序员考虑使用顺序连贯性或处理器连贯性的更简单编程模型。

一个尚未解决的问题是，在优化对共享变量的存储器引用时，编译器技术会取得怎样的成功?共享数据通常是通过指针和数组索引进行访问的，这一事实再加上优化技术的现状，已经限制了此种优化技术的使用。如果这一技术进入实用状态，而且能够带来显著的性能优势，编译器编写入员可能会希望使用更宽松的编程模型。

包含性及其实现

所有多处理器都使用多级缓存层级结构来减少对全局互连的要求和缓存缺失延迟。如果缓存还提供了多级包含性(缓存层次结构的每一级都是距处理器更远一层的子集），所以我们可以使用多级结构来减少一致性通信 与处理器通信之间的争用，当监听与处理器缓存访问必须竞争缓存时，就会出现这些争用。许多具有多层缓存的多处理器都具备这种包含性，不过，最近有些多处理器采用较小的L1缓存和不同的块大小，有时会选择不实施这种包含特性。这一限制有时也称为子集特性，因为每个缓存都是它下一级缓存的子集。

乍看起来，保持多级包含特性是件很简单的事情。考虑一个两级示例：L1中的所有缺失要么在L2命中，要么在L2中产生缺失,无论是哪一种情况，缺失块都会进入L1和L2两级缓存。与此类似，任何在L2命中的失效都必然被发送给L1，如果L1中存在这个块，将会使其失效。难以理解的地方在于当L1和L2的块大小不同时会发生什么。选择不同块大小是非常合情合理的，因为L2通常要大得多，其缺失代价中的延迟分量也要长得多，因此希望使用较大的块大小。当块大小不同时，对于包含性的“ 自动”实施有什么影响呢? L2中的一个块对应于L1中的多个块，L2的一次缺失所导致的数据替换对应于多个L1块。例如，如果L2的块大小是L1的4倍，那么L2中的一次缺失将替换相当于4个L1块的内容。下面考虑一个详细示例。

假定L2的块大小为L1块的4倍。说明一次导致L1和L2产生替换的地址缺失将如何违犯包含特性。

假定L1和L2是直接映射的，L1的块大小为b个字节，L2的块大小为4b个字节。假定L1包含两个块，起始地址为x和x+b，且x mod 4b = 0,也就是说，x也是L2中一个块的起始地址；因此，L2中的单个块包含着L1块x、x+b、x+2b和x+3b。假定处理器生成一个对块y的引用，这个块对应于在两个缓存中都包含x的块，从而会产生缺失。由于L2产生缺失，所以它会提取4b个字节，并替换包含x、x+b、x+2b和x+3b的块，而L1取得b个字节，并替换包含x的块。由于L1仍然包含x+b，但L2不再包含，因此不再保持包含特性。

为了在采用多个块大小时仍然保持包含性，在较低级别完成替换时，必须上溯到层次结构的较高级别，以确保较低级别中替换的所有字在较高级别的缓存中都已失效；相联度的不同级别也会产生同类问题。Intel i7为L3应用了包含性，也就是说L3总是包含L2和L1的内容。这样就可以在L3实施一种简单的目录机制，在最大程度上降低因为监听L1和L2而对这些情景造成的干扰，目录中指出L1或L2中含有一个缓存副本。AMD Opteron与之相对，使L2包含L1的内容，但对L3没有这一限制。它们使用了监听协议，但除非存在命中情况，否则仅需要在L2进行监听，在这种情况下，会向L1发送监听。

利用多重处理和多线程的性能增益

融会贯通：多核处理器及其性能

2011年，多核心成为所有新处理器的主旋律。各种实现方式的变化很大，它们对大型多芯片多处理器的支持也同样有很多不同。这一节研究4种不同多核处理器的设计和一些性能特征。表5-10给出了4种为服务器应用设计的多核处理器。Intel Xeon的设计基础与i7相同，但它的核心更多、时钟频率稍慢(功率限制了其时钟频率)、L3缓存较大。AMD Opteron和桌面Phenom共享相同的基础核心，而SUN T2与在第3章遇到的SUN T1相关。Power7 是Power5的扩展，核心更多，缓存更大。

• 表中包含了这些处理器中核心数最多的版本；其中一些处理器还有核心数较低、时钟频率较高的版本。IBM Power7中的L3可以全部共享，也可以划分为各个核心专用的更快速专用区城。我们仅包含了这些多核心处理器的单芯片实现方式。

图5-18给出了SPECRate CPU基准测试在核心数目增加时的性能变化。随着处理器芯片数及核心数的增加，可以获得近似线性的加速比。

图5-18 当处理器芯片数增大时，三种多核处理器运行SPECRate基准测试的性能。注意，对于这个高度并行的基准测试，得到了近似线性的加速比。这两个曲线都采用对数一对数刻度，所以线性加速比表现为一条直线

图5-19给出了SPECjbb2005 基准测试的类似数据。要在开发更多ILP和仅关注TLP之间实现平衡是很复杂的，它与具体的工作负载高度相关。SPECjbb2005 工作负载能够在增加更多处理器时进行扩展，使运行时间(而非问题规模)保持恒定。在这种情况下，会有足够的并行，可以通过64个核心来实现线性加速比。

图5-19 当处理器芯片数目增加时，三种多核心处理器运行SPE1bb2005基准测试的性能。注意，对于这并行基准测试，得到了近似线性的加速比

Intel Core i7多核的性能与能耗效率

在这一节，我们利用第3章考虑过的两组基准测试来研究i7的性能，即并行Java基准测试和并行PARSEC基准测试。我们首先来看一下在没有使用SMT时多核心性能、扩展能力与单核心的对比。然后将多核心和SMT功能结合起来。

图5-20绘制了在没有使用SMT时Java和PARSEC基准测试的加速比和能量效率曲线。给出能耗效率曲线意味着我们绘制的是两核心或四核心运行消耗能量与单核心运行消耗能量的比值；因此，能耗效率越高越好，取值为1.0 时为其平衡点。在所有情景中，没有使用的核心都处于尝试睡眠模式，基本上相当于将这些核心关闭，使其功耗降至最低。在对比单核心和多核心基准测试的数据时，一定要记住，在单核心(及多核心)情景中，L3缓存和存储器接口的全部能耗成本都是物有所值的。因为这一事实，对于那些能够很好扩展的应用程序，有可能进一步改善其能耗指标。在汇总这些结果时使用了调和均值,其隐含意义见图题。

图5-20 本图给出了未采用SMT时，两核和四核处理器执行并行Java与PARSEC工作负载时的加速比。Turbo Boost功能被关闭。加速比与能耗效率数据使用调和均值汇总，其隐含含义就是在这种工作负载中，运行每个2p基准测试所花费的时间是等价的

如图5-20所示，PARSEC基准测试的加速比要优于Java 基准测试，在四核心处理器上的加速比效率为76%（即实际加速比除以处理器数目），而Java基准测试在四核心处理器上的加速比效率为67%。尽管从数据中可以很清楚地看出这一结果，但要分析存在这种差异的原因要麻烦一些。例如，很有可能是Amdahl定律降低了Java 工作负载的加速比。此外，处理器体系结构与应用程序之间的交互也可能在其中产生影响(它会影响到同步成本或通信成本等问题)。具体来说，并行化程度很高的应用程序(比如PARSEC中的程序)有时可能因为计算与通信之间的有利比值而获益，这种比值可以降低对通信成本的依赖性。

这种加速比的差异性可以转换为能耗效率的差异性。例如，相对于单核心版本，PARSEC基准测试实际上只是稍微提高了能耗效率；这一结果可能受到以下事实的显著影响：L3缓存在多核运行版本中的使用效率要高于单核情景，而两种情景中的能耗成本是相同的。因此，对于PARSEC基准测试，多核方法达到了设计人员从关注ILP的设计转向多核设计的目的，即：其性能的增长速度不低于功率的增长速率，从而使能耗效率保持不变，甚至还有所提高。在Java情景中我们看到，由于Java工作负载的加速比级别较低，所以两核和四核运行版本都没有达到能耗效率的平衡点。四核Java情景中的能耗效率相当高（0.94）。对于PARSEC或Java工作负载，以ILP为中心的处理器很可能需要更多的功率才能实现相似的加速比。因此，在提高这些应用程序的性能方面，以TLP为中心的方法当然也会优于以ILP为中心的方法。

将多核与SMT结合起来

最后，我们通过测量两组基准测试在2~4个处理器、1~2个线程(总共4个数据点、最多8个线程)情况下的结果，来研究多核与多线程的组合方式。图5-21给出了在处理器数目为2或4、使用和未使用SMT时，在Intel i7上获得的加速比和能耗效率，采用调和均值来汇总两组基准测试的结果。显然，如果在多核情景下也有足够的线程级并行，SMT是可以提高性能的。例如，在四核无SMT情景中，Java和PARSEC的加速比效率分别为67%和76%。在采用SMT、四个核心时，这些比值达到了令人惊讶的83%和97%!

图5-21 本图给出了在有、无SMT时，以两核和四核处理器执行并行Java和PARSEC工作负载的加速比。注意，以上结果是在线程数由2变为8时获得的,反映了体系结构的影响和应用程序的特征。汇总结果时采用了调和均值，如图5-20的图题所述能耗效率给出了一幅稍有不同的画面。对于PARSEC，加速比在四核SMT情景中(8个线程)基本上为线性，功率的增长要更慢一些，从而使这种情景中的能耗效率达到1.1。 Java情景要更复杂一些；两核心SMT (四线程)运行时的能耗效率峰值达到0.97，在四核心SMT（8线程）运行时下降到0.89。在部署4个以上的线程时，Java 基准测试非常有可能遭遇Amdahl定律效应。一些架构师已经观察到，多核处理器将提高性能(从而提高能耗效率)的更多责任转嫁给程序员，Java工作负载的结果显然证实了这一点。

量化设计与分析基础

处理器性能的提高从单纯依赖指令集并行（ILP）转向数据级并行（DLP）和线程级并行（TLP）。

并行度与并行体系结构的分类

在所有4个计算机类别中，多种级别的并行度现在已经成为计算机设计的推动力量，而能耗和成本则是主要约束条件。应用程序中主要有以下两种并行。

1. 数据级并行（DLP），它的出现是因为可以同时操作许多数据项。
2. 任务级并行（TLP），它的出现是因为创建了一些能够单独处理但大量采用并行方式执行的工作任务。

计算机硬件又以如下4种主要方式来开发这两种类型的应用并行。

• 指令级并行在编译器的帮助下，利用流水线之类的思想适度开发数据级并行，利用推理执行之类的思想以中等水平开发数据级并行。
• 向量体系结构和图形处理器（GPU）将单条指令并行应用于一个数据集，以开发数据级并行。
• 线程级井行在一种紧耦合硬件模型中开发数据级并行或任务级并行，这种模型允许在并行线程之间进行交互。
• 请求级并行在程序员或操作系统指定的大量去耦合任务之间开发并行。

Michael Flynn[1966]在20世纪60年代研究并行计算工作量时，提出了一种简单的分类方式，他研究了多处理器最受约束组件中的指令流及数据流的并行，并据此将所有计算机分为以下4类。

• 单指令流、单数据流（SISD）是单处理器。程序员把它看作标准的顺序计算机，但可以利用指令级并行。第3章介绍了采用ILP技术（比如超标量和推理执行）的SISD体系结构。
• 单指令流、多数据流（SIMD）同一指令由多个使用不同数据流的处理器执行。SIMD计算机开发数据级并行，对多个数据项并行执行相同操作。每个处理器都有自己的数据存储器，但只有一个指令存储器和控制处理器，用来提取和分派指令。
• 多指令流、单数据流（MISD）：目前为止，还没有这种类型的商用多处理器。
• 多指令流、多数据流（MIMD）：每个处理器都提取自己的指令，对自己的数据进行操作。它针对的是任务级并行。

计算机体系结构

指令集体系结构：计算机体系结构的近距离审视

我们在本书中用指令集体系结构（ISA）一词来指代程序员可以看到的实际指令集。ISA的作用相当于区分软件和硬件的界限。在下面对ISA的快速回顾中，将使用80x86、ARM和MIPS的例子从7个方面来介绍ISA。

（1）ISA分类。现今几乎所有的ISA都划分到通用寄存器体系结构中，在这种体系结构中，操作数或者是寄存器，或者是存储器地址。80x86有16个通用寄存器和16个通常存入浮点数据的寄存器，而MIPS则有32个通用寄存器和32个浮点寄存器（见表）。这一类别有两种主流版本，一种是寄存器-存储器ISA，比如80x86，可以在许多指令中访问存储器，另一种是载入-存储ISA，比如ARM和MIPS，它们只能用载入或存储指令来访问存储器。所有最新ISA都采用载入-存储版本。

（2）存储器寻址。几乎所有桌面计算机和服务器计算机（包括80x86、ARM和MIPS）都使用字节寻址来访问存储器操作数。有些体系结构（像ARM和MIPS）要求操作对象必须是对齐的。一个大小为s的对象，其字节地址为A，如果A mod s = 0，则对这个对象的访问是对齐的。如果操作数是对齐的，访向速度通常会快一些。

（3）寻址模式。除了指定寄存器和常量操作数之外，寻址模式还指定了一个存储器对象的地址。MIPS寻址模式为：寄存器、立即数、位移量。立即数寻址用于常数寻址，在位移量寻址模式中，将一个固定偏移量加到寄存器，得出存储器地址。

（4）操作数的类型和大小。和大多数ISA类似，80x86、ARM和MIPS支持的操作数大小为8位（ASCII字符〕、16位（Unicode字符或半个字）、32位（整数或字）、64位（双字或长整型）以及IEEE754浮点数，包括32位（单精度）和位〈双精度）。80x86还支持80位浮点（扩展双精度）。

（5）操作指令。常见的操作类别为：数据传输指令、算术逻辑指令、控制指令（下面进行讨论）和浮点指令。MIPS是一种简单的、易于实现流水化的指令集体系结构，它是2011年采用RISC体系结构的代表。表中总结了MIPS ISA。8cx86的操作指令集要丰富得多。

（6）控制流指令。几乎所有ISA，包括上述三种在内，都支持条件转移、无条件跳转、过程调用和返回。所有这三种都使用相对于PC的寻址方式，其中的分支地址由一个地址字段指定，该地址将被加到PC。这三种ISA之间有一些微小的区别。MIPS条件分支（BE、BNE等）检验寄存器中的内容，而80x86和ARM分支测试条件代码位，这些位是在执行算术/逻辑运算时顺带置位的。ARM和MIPS过程调用将返回地址放在一个寄存器中，而886调用（CALLF）将返回地址放在存储器中的一个栈内。

（7）ISA的编码。有两种基本的编码选择：固定长度和可变长度。所有ARM和MIPS指令的长度都是32位，从而简化了指令译码。图中给出了MIPS指令格式。80x86编码为可变长度，变化范围为1～18个字节。与固定长度的指令相比，可变长度的指令可以占用较少的空间，所以为80x86编译的程序通常要小于为MIPS编译的相同程序。

真正的计算机体系结构：设计满足目标和功能需求的组成和硬件

计算机的实现包括两个方面：组成和硬件。组成一词包含了计算机设计的高阶内容，比如存储器系统，存储器互连，设计内部处理器或CPU（中央处理器一一一算术、逻辑、分支和数据输送功能都在这里实现）。

由于单个微处理器上开始采用多个处理器，所以人们开始使用核心一词来称呼处理器：人们一般不说“多处理器微处理器”，而是使用“多核”。由于现今几乎所有芯片都有多个处理器，所以人们不怎么使用中央处理器（或CPU）一词了。

硬件是指一个计算机的具体实现，包括计算机的详尽逻辑设计和封装技术。同一系列的计算机通常具有相同的指令集体系结构和几乎相同的组成，但在具体硬件实现方面有所不同。

计算机设计的量化原理

充分利用并行

充分利用并行是提高性能的最重要方法之一。这里给出三个简单的例子，在后续各章会给出详细解释。

第一个例子是在系统级别开发并行。为了提高在一个典型服务器基准测试（比如SPECWeb或TPC-C）上的吞吐量性能，可以使用多个处理器和多个磁盘。随后可以在处理器和磁盘之间分散处理请求的工作负载，从而提高吞吐量。扩展内存以及处理器和磁盘数目的能力称为可扩展性。在许多磁盘之间分布数据，以实现并行读写，就可以支持数据级并行。SPECWeb还依靠请求级并行来使用大量处理器，而TPC-C使用线程级并行实现对数据库请求的更快速处理。

在单独的处理器级别，充分利用指令间的并行对于实现高性能非常关键。实现这种并行的最简单方法之一就是通过流水线。流水线背后的基本思想是将指令执行重叠起来，以缩短完成指令序列的总时间。流水线能够实现的关键是认识到并非所有执行都取决于与其直接相邻的前一条指令，所以有可能完全并行或部分并行地执行这些指令。

在具体的数字设计级别也可以开发并行。例如，组相联（Set Associative）缓存使用多组存储器，通常可以对它们进行并行查询，以查找所需项目。现代ALU（算术逻辑单元）使用先行进位，这种方法使用并行来加快求和过程，使计算时间与操作数位数之间的关系由线性关系变为对数关系。数据级并行的例子还有许多。

局域性原理

一个最重要程序特性是局域性原理：程序常常重复使用它们最近用过的数据和指令。一条广泛适用的经验规律是：一个程序90%的执行时间花费在仅10%的代码中。局域性意味着我们可以根据一个程序最近访问的指令和数据，比较准确地预测它近期会使用哪些内容。时间局域性是指最近访问过的内容很可能会在短期内被再次访问。空间局域性是指地址相互临近的项目很可能会在短时间内都被用到。

Amdahl定律

利用Amdahl定律，可以计算出通过改进计算机某一部分而能获得的性能增益。Amdahl定律表明，使用某种快速执行模式获得的性能改进受限于可使用此种快速执行方式的时间比例。

Amdabl定律定义了使用某一特定功能所获得的加速比（speedup〕。加速比的定义为：加速比=整个任务在采用该升级时的性能/整个任务在未采用该升级时的性能。或者：加速比=整个任务在未采用该升级时的执行时间/整个任务在采用该升级时的执行时间。加速比告诉我们，与原计算机相比，在经过升级的计算机上运行一个任务可以加快多少。

Amdahl定律为我们提供了一种快速方法，用来计算某一升级所得到的加速比，加速比取决于下面两个因素。

• 原计算机计算时间中可升级部分所占的比例。例如，一个程序的总执行时间为秒，如果有20秒的执行时间可进行升级，那这个比例就是20/60。我们将这个值称为升级比例，它总是小于或等于1。
• 通过升级执行模式得到的改进，也就是说在为整个程序使用这一执行模式时，任务的运行速度会提高多少倍。这个值等于原模式的执行时间除以升级模式的执行时间。如果为程序的某一部分采用升级模式后需要2秒，而在原始模式中需要5秒，则提升值为5/2。我们将这个值称为升级加速比，它总是大于1。

原计算机采用升级模式后的执行时间等于该讨机未升级部分耗用的时间加上使用升级部分耗用的时间：

1

新执行时间 = 原执行时间 × （（1-升级比例） + 升级比例/升级加速比）

总加速比是这两个执行时间之比：

1

总加速比=原执行时间/新执行时间=1/（（1-升级比例）+升级比例/升级加速比）

Amdahl定律阐述了回报递减定律：如果仅改进一部分计算的性能，在增加改进时，所获得的加速比增量会逐渐减小。

存储器层次结构设计

引言

由于快速存储器非常昂贵，所以将存储器层次结构分为几个级别——越接近处理器，容量越小、速度越快、每字节的成本也越高。其目标是提供一种存储器系统，每字节的成本几乎与最便宜的存储器级别相同，速度几乎与最快速的级别相同。在大多数（但并非全部）情况下，低层级存储器中的数据是其上一级存储器中数据的超集。这一性质称为包含性质，层次结构的最低级别必须具备这一性质，如果这一最低级别是缓存，则由主存储器组成，如果是虚拟存储器，则由磁盘存储器组成。

随着处理器性能的提高，存储器层次结构的重要性也在不断增加。图2-2是单处理器性能和主存储器访问次数的历史发展过程。处理器曲线显示了平均每秒发出存储器请求数的增加（即两次存储器引用之间延迟值的倒数），而存储器曲线显示每秒DRAM访问数的增加（即DRAM访问延迟的倒数）。在单处理器中，由于峰值存储器访问速度要快于平均速度（也就是图中绘制的速度），所以其实际情况要稍差一些。

近来，高端处理器已经转向多核，与单核相比，进一步提高了带宽需求。事实上，总峰值带宽基本上随核心个数的增大而增大。现代高端处理器每个时钟周期可以由每个核心生成两次数据存储器引用，i7有4个核心，时钟频率为3.2G，除了大约128亿次128位指令引用的峰值指令要求之外，每秒最多还可生成256亿次位数据存储器引用；总峰值带宽为409.6GB/s！

这一难以置信的高带宽是通过以下方法实现的：实现缓存的多端口和流水线；利用多级缓存，为每个核心使用独立的第一级缓存，有时也使用独立的第二级缓存；在第一级使用独立的指令与数据缓存。与其形成鲜明对比的是，DRAM主存储器的峰值带宽只有它的6%（25GB/s）。

如果在缓存中找不到某一个字，就必须从层次结构的一个较低层级（可能是另一个缓存，也可能是主存储器）中去提取这个字，并把它放在缓存中，然后才能继续。出于效率原因，会一次移动多个字，称为块（或行），这样做还有另外一个原因：由于空间局域性原理，很可能马上就会用到这些字。每个缓存块都包括一个标记，指明它与哪个存储器地址相对应。

在设计时需要作出一个非常重要的决策：哪些块（或行）可以放在缓存中。最常见的方案是组相联，其中组是指缓存中的一组块。一个块首先被映射到一个组上，然后可以将这个块放到这个组中的任意位置。要查找一个块，首先将这个块的地址映射到这个组，然后再搜索这个组（通常为并行搜索），以找到这个块。这个组是根据数据地址选择的：（块地址）MOD（缓存中的组数）。

如果组中有n个块，则缓存的布局被称为n路组相联。组相联的端点有其自己的名字。直接映射缓存每组中只有一个块（所以块总是放在同一个位置），全相联缓存只有一个组（所以块可以放在任何地方）。

要缓存只读数据是一件很容易的事情，这是因为缓存和存储器中的副本是相同的。缓存写入难一些；比如，缓存和存储器中的副本怎样才能保持一致呢？共有两种主要策略。一种是直写（write-through）缓存，它会更新缓存中的项目，并直接写入主存储器，对其进行更新。另一种是回写（write-back）缓存，仅更新缓存中的副本。在马上要替换这个块时，再将它复制回存储器。这两种写入策略都使用了一种写缓冲区，将数据放入这个缓冲区之后，马上就可以进行缓存操作，不需要等待将数据写入存储器的全部延迟时间。

为了衡量不同缓存组织方式的优劣，可以采用一个名为缺失率的指标。缺失率是指那些未能找到预期目标的缓存访问所占的比例，即未找到目标的访问数目除以总访问数目。为了深刻理解高缺失率的原因，从而更好地设计缓存，一种”3C”模式将所有这些缺失情景分为以下三个简单的类别。

• 强制（compulsory）：对一个数据块的第一次访问，这个块不可能在缓存中，所以必须将这个块调入缓存中。即使拥有无限大的缓存，也会发生强制缺失。
• 容量（Capacity）：如果缓存不能包含程序运行期间所需要的全部块，就会因为有些块被放弃，之后再被调入，从而导致容量缺失（还有强制缺失）。
• 冲突（conflict）：如果块放置策略不是全相联的，如果多个块映射到一个块的组中，对不同块的访问混杂在一起，一个块可能会被放弃，之后再被调入，从而发生冲突缺失（还有强制缺失和容量缺失）。

多线程和多核都增加了缓存的复杂性，都加大了出现容量缺失的可能性，而且还因为缓存刷新增加了第4个C——一致性（coherency）缺失，之所以进行缓存刷新是为保持多处理器中多个缓存的一致性。

要小心，缺失率可能会因为多个原因而产生误导。因此，一些设计人员喜欢测量每条指令的缺失次数，而不是每次存储器引用的缺失次数（缺失率）。这两者之间的关系如下：

1

缺失数/指令 = 缺失率×存储器访问/指令数 = 缺失率x存储器访问/指令

这两种度量指标的问题在于它们都没有考虑缺失成本的因素。一种更好的度量指标是存储器平均访问时间：

1

存储器平均访问时间 = 命中时间 + 缺失率 × 缺失代价

其中，命中时间是指在缓存中命中目标花费的时间，缺失代价是从内存中替代块的时间（即缺失成本）。多线程的使用也允许一个处理器容忍一些缺失，而不会被强制转入空闲状态。

下文给出了6种基本的缓存优化方法

1. 增大块以降低缺失率。这是降低缺失率的最简单方法，它利用了空间局域性，并增大了块的大小。使用较大的块可以减少强缺失，但也增加了缺失代价。因为较大块减少了标记数目，所以它们可以略微降低静态功率。较大块还可能增大容量缺失或冲突缺失，特别是当缓存较小时尤为如此。选择合适的块大小是一项很复杂的权衡过程，具体取决于缓存的大小和缺失代价。
2. 增大缓存以降低缺失率。要减少容量缺失，一个显而易见的方法就是增大缓存容量。其缺点包括可能会延长较大缓存存储器的命中时间，增加成本和功率。较大的缓存会同时增大静态功率和动态功率。
3. 提高相联程度以降低缺失率。显然，提高相联程度可以减少冲突缺失。较大的相联程度是以延长命中时间为代价的。

4. 采用多级缓存以降低缺失代价。是加快缓存命中速度，以跟上处理器的高速时钟频率，还是加大缓存，以缩小处理器访问和主存储器访问之间的差距，这是一个艰难的决策。在原缓存和存储器之间加入另一级缓存可以降低这一决策的难度。第一级缓存可以非常小，足以跟上快速时钟频率，而第二级（或第三级）缓存可以非大，足收集容纳许多本来要对主存储器进行的访问。为了减少第二级缓存中的缺失，需要采用更大的块、更大的容量和更高的相联程度。与一级总缓存相比，多级缓存的功率效率更高。如果用LI和L2分别指代第一级和第二季缓存，可以将平均存储器访问时间定义为：

   1	L1命中时间 + L1缺失率 × (L2命中时间 + L2缺失率 × L2缺失代价)

5. 为读取缺失指定高于写入操作的优先级，以降低缺失率。写缓冲区是实现这一优化的好地方。因为写缓冲区拥有在读取缺失时所需位置的更新值，所以写缓冲区存在隐患，即通过存储器进行先写后读的隐患。一种解决方案就是在读取缺失时检查写缓冲区的内容。如果没有冲突，如果存储器系统可用，则在写入操作之前发送读取请求会降低缺失代价。大多数处理器为读取指定的优先级要高于写入操作。这种选择对功耗几乎没有什么影响。

** 识别结果 1**

访问时间通常会随着缓存大小和相联程度的增大而增加。这些数据假定采用40nm制程、单一存储器组、块大小为64字节。由于对缓存布局所做的假定，以及在互连延迟（通常取决于正在访问的缓存块的大小）和标记检查与多工之间的复杂权衡，会得到一些有时看起来令人惊奇的结果，比如对于两路组相联的64KB缓存，其访问时间会低于直接映射。与此类似，当缓存大小增大时，八路组相联产生的结果也会导致一些不同寻常的行为。

1. 在缓存索引期间避免地址转换，以缩短命中时间。缓存必须妥善应对从处理器虚拟地址到访问存储器的物理地址之间的转换。一种常见的优化方法是使用页偏移地址（虚拟地址和物理地址中的相同部分）来索引缓存。这种虚拟索引/物理标记方法增加了某些系统复杂度以及（或者）对L1缓存大小与结构的限制，但从关键路径消除转换旁视缓冲区（TLB）访问这一优点抵得过这些缺点。

缓存性能的10种高级优化方法

上面的存储器平均访问时间公式提供了三种缓存优化度量：命中时间、缺失率和缺失代价。根据最近的发展趋势，我们向这个列表中添加了缓存带宽和功耗两个度量。根据这些度量，可以将我们研究的10种高级缓存优化方法分为以下5类。

1. 缩短命中时间。小而简单的第一级缓存和路预测。这两种技术通常还都能降低功耗。
2. 增加缓存带宽。流水化缓存、多组缓存和无阻塞缓存。这些技术对功耗具有不确定影响。
3. 降低缺失代价。关键字优化，合并写缓冲区。这两种优化方法对功率的影响很小。
4. 降低缺失率。编译器优化。显然，缩短编译时间肯定可以降低功耗。
5. 通过并行降低缺失代价或缺失率。硬件预取和编译器预取。这些优化方法通常会增加功耗，主要是因为提前取出了未用到的数据。

一般来说，在采用这些技术方法时，硬件复杂度会增加。另外，这些优化技术中有几种需要采用高级编译器技术。对其中比较简单的优化方法仅作简单介绍，而对其他技术将给出更多描述。

第一种优化：小而简单的第一级缓存，用以缩短命中时间、降低功率

提高时钟频率和降低功率的双重压力都推动了对第一级缓存大小的限制。与此类似，使用较低级别的相联度，也可以缩短命中时间、降低功率，不过这种权衡要比限制大小涉及的权衡更复杂一些。

缓存命中过程中的关键计时路径由3个步骤组成：

• 使用地址中的索引确定标记存储器的地址；
• 读取的标签值与地址进行比较；
• 如果缓存为组相联缓存，则设置多路转换器以选择正确的数据项。

直接映射的缓存可以将标记核对与数据传输重叠起来，有效缩短命中时间。此外，在采用低相联度时，由于减少了必须访问的缓存行，所以通常还可以降低功率。尽管在各代新型微处理器中，片上缓存的总数已经大幅增加，但由于大容量L1缓存带来的时钟频率影响，所以L1缓存大小最近的涨幅很小，甚至根本没有增长。选择相联度时的另一个考虑因素是消除地址别名的可能性。

在选择缓存大小和相联度时，能耗也是一个因素，在128KB或256KB缓存中，当从直接映射变到两路组相联时，高相联度的能量消耗从大于2到可以忽略。

每次读取操作的能耗随缓存大小、相联度增加而增加。八路组相联缓存的代价之所以很高，是因为并行读取8个标签及相应数据的成本造成的

在最近的设计中，有三种其他因素导致了在第一级缓存中使用较高的相联度。

• 第一，许多处理器在访问缓存时至少需要两个时钟周期，因此命中时间较长可能不会产生太过严重的影响。
• 第二，将TLB排除在关键路径之外（TLB带来的延迟可能要大于高相联度导致的延迟），几乎所有L1缓存都应当是变址寻址的。这就将缓存的大小限制为页大小与相联度的乘积，这是因为只有页内的位才能用于变址。在完成地址转换之前对缓存进行变址的问题还有其他一些解决方案，但提高相联度是最具吸引力的一种，它还有其他一些好处。
• 第三，在引入多线程之后，冲突缺失会增加，从而使提高相联度更具吸引力。

第二种优化：采用路预测以缩短命中时间

这是另外一种可以减少冲突缺失，同时又能保持直接映射缓存命中速度的方法。在路预测技术中，缓存中另外保存了一些位，用于预测下一次缓存访问组中的路或块。这种预测意味着尽早设定多工选择器，以选择所需要的块，在与缓存数据读取并行的时钟周期内，只执行一次标签比较。如果缺失，则会在下一个时钟周期中查看其他块，以找出匹配项。

在一个缓存的每个块中都添加块预测位。根据这些位选定要在下一次缓存访问中优先尝试琊些块。如果顸测正确，则存访问延迟就等于这一快速命中时间。如果预测错误，则尝试其他块，改变路预测器，延迟会增加一个时钟周期。模拟表明，对于一个两路组相联缓存，组预测准确度超过90%；对于四路组相联缓存，超过80%，对I-缓存的准确度优于对D-缓存的准确度。

还有一种扩展形式的路预测，它使用路预测位来判断实际访问的缓存块，可以用来降低功耗（路预测位基本上就是附加地址位〕；这种方法也可称为路选择，当路预测正确时，它可以节省功率，但在路预测错误时则会显著增加时间，这是因为需要重复进行访问，而不仅是重复标记匹配与选择过程。这种优化方法只有在低功率处理器中才可能有意义。

第三种优化：实现缓存访问的流水化，以提高缓存带宽

这种方法就是实现缓存访问的流水化，使第一级缓存命中的实际延迟可以分散到多个时钟周期，从而缩短时钟周期时间、提高带宽，但会减缓命中速度。这一变化增加了流水线的段数，增加了预测错误分支的代价，延长了从发出载入指令到使用数据之间的时钟周期数，但的确更便于采用高相联度的缓存。

第四种优化：采用无阻塞缓存，以提高缓存带宽

对于允许乱序执行的流水化计算机，其处理器不必因为一次数据缓存缺失而停顿。例如，在等待数据缓存返回缺失数据时，处理器可以继续从指令缓存中提取指令。无阻塞缓存（或称为自由查询缓存）允许数据缓存在一次缺失期间继续提供缓存命中，进一步加强了这种方案的潜在优势。这种“缺失时仍然命中”优化方法在缺失期间非常有用，它不会在此期间忽略处理器的请求，从而降低了实际缺失代价。还有一种精巧而复杂的选项：如果能够重叠多个缺失，那缓存就能进一步降低实际缺失代价，这种选项被称为“多次缺失时仍然命中”或者“缺失时缺失”优化方法。只有当存储器系统可以为多次缺失供服务时，第二种选项才有好处，大多数高性能处理器通常都支持这两种优化方法。

对非阻塞缓存进行性能评估时，真正的难度在于一次缓存缺失不一定会使处理器停顿。在这种情况下，很难判断一次缺失造成的影响，因此也就难以计算存储器平均访问时间。实际缺失代价并不等于这些缺失时间之和，而是处理器的非重叠停顿时间。非阻塞缓存的优势评估非常复杂，因为它取决于存在多次缺失时的缺失代价、存储器引用模式以及处理器在有未处理缺失时能够执行多少条指令。

通常，对于一个能够在L2缓存中命中的L1数据缓存缺失，乱序处理器能够隐藏其大部分缺失代价，但不能隐藏更低层次缓存缺失的大部分代价。而在决定支持多少个未处理缺失时，需要考虑多种因素，如下所述。

• 缺失流中的时间与空间局域性，它决定了一次缺失是否会触发对低级缓存或对存储器的新访问操作。
• 对访问请求作出回应的存储器或缓存的带宽。
• 为了允许在最低级别的缓存中出现更多的未处理缺失（在这一级别的缺失时间是最长的），需要在较高级别上支持至少数目相等的缺失，这是因为这些缺失必须在最高级别缓存上启动。
• 存储器系统的延迟。

第五种优化：采用多种缓存以提高缓

我们可以将缓存划分为几个相互独立、支持同时访问的缓存组，而不是将它们看作一个整体。分组方式最初用于提高主存储器的性能，现在也用于DRAM芯片和缓存中。Arm Cortex-A8在其L2缓存中支持1至4个缓存组；Intel Core i7的L1中有4个组（每个时钟周期内可以支持2次存储器访问），L2有8个组。

显然，当访问请求很自然地分布在缓存组之间时，分组方式的效果最佳，所以将地址映射到缓存组的方式影响着存储器系统的行为。一种简单有效的映射方式是将缓存块地址按顺序分散在这些缓存组中，这种方式称为顺序交错。例如，如果有4个缓存组，0号缓存组中的所有缓存块地址对4求模后余0，1号缓存组中的所有缓存块地址对4求模后余1，以此类推。图中显示了这种交错方式。采用分组方式还可以降低缓存和DRAM中的功耗。

图2使用块寻址的四路交错缓存组。假定每个块64个字节，这些地址需要分别乘以64才能实现字节寻址

第六种优化：关键字优先和提前重启动以降低缺失代价

这一技术的事实基础是人们观测到处理器在某一时刻通常仅需要缓存块的一个字。这一策略显得“不够耐心”：无须等待完成整个块的载入过程，一旦载入被请求字之后，立即将其发出，然后就重启处理器。下面是两个待定策略。

• 关键字优先：首先从存储器中请求缺失的字，在其到达缓存之后立即发给处理器；使处理器能够在载入块中其他字时继续执行。
• 提前重启动：以正常顺序提取字，但只要块中的被请求字到达缓存，就立即将其发送给处理器，让处理器继续执行。

通常，只有在采用大型缓存块的设计中，这些技术才有用武之地，如果缓存块很小，它们带来的好处是很低的。注意，在载入某个块中的其余内容时，缓存通常可以继续满足对其他块的访问请求。

不过，根据空间局域性原理，下一次引用很可能就会指向这个块的其余内容。和非阻塞缓存一样，其缺失代价的计算也不是非常容易。在采用关键字优先策略时，如果存在第二次请求，实际缺失代价等于从本次引用开始到第二部分内容到达之前的非重叠时间。关键字优先策略和提前重启动策略的好处取决于块的大小以及在尚未获取某部分内容时又出现另一次访问的机率。

第七种优化：合并写缓冲区以降低缺失代价

因为所有存储内容都必须发送到层次结构的下一层级，所以直写缓存依赖于写缓冲区。即使是写回缓存，在替代一个块时也会使用一个简单的缓冲区。如果写缓冲区为空，则数据和整个地址被写到缓冲区中，从处理器的角度来看，写入操作已经完成；在写缓冲区准备将字写到存储器时，处理器继续自己的工作。如果缓冲区中包含其他经过修改的块，则检查它们的地址，看看新数据的地址是否与写缓冲区中有效项目的地址匹配。如果匹配，则将新数据与这个项目合并在一起。这种优化方法称为写合并。如果缓冲区已满，而且没有匹配地址，则缓存（和处理器）必须等待，直到缓冲区中拥有空白项目为止。由于多字写入的速度通常快于每次只写入一个字的写入操作，所以这种优化方法可以更高效地使用存储器。

这种优化方式还会减少因为写缓冲区已满而导致的停顿。图中显示了一个写缓冲区在采用和不采用写合并时的情况。假定这个写缓冲区中有四项，每一项有4个位的字。在采用这一优化方法时，图中的4个字可以完全合并，放在写缓冲区的一个项目中，而在不采用这一优化方法时，对写缓冲区的连续地址执行4次存储操作，将整个缓冲区填满，每个项目中保存一个字。

注意，输入/出设备寄存器经常被映射到物理地址空间。由于IO寄存器是分享的，不能像存储器中的字数组那样操作，所以这些IO地址不能允许写合并。例如，它们可能要求为每个IO寄存器提供一个地址和一个数据字，而不能只提供一个地址进行多字写入。为了现这些副作用，通常由缓存将这些页面进行标记，表明其需要采用非合并直写方式。

图中为了说明写合并过程。上面的写缓冲区未采用该技术，下面的写缓冲区采用了这一技术。在进行合并时，4次写入内容被合并到一个缓冲区项目中；而未进行合并时，4次写入操作就填满了整个缓冲区，每个项目的四分之三被浪费。这个缓冲区有四个项目，每一项保存4个纠位字。每个项目的地址位于左侧，有效位（v）指明这个项目的下面8个连续字节是否被占用（未采用写合并时，图中上半部分右侧的字只会用于同时写多个字的指令。）

第八种优化：采用编译器优化以降低缺失率

前面介绍的技术都需要改变硬件。下面这种技术可以在不做任何硬件改变的情况下降低缺失率。

这种神奇的降低效果来自软件优化。处理器与主存储器之间的性能差距越拉越大，己经促使编译器编写入员深人研究存储器的层次结构，以了解能否通过编译时间优化来提高性能。同样，研究内容包括两个方面：指令缺失性能改进和数据缺失性能改进。下面给出的优化技术在很多现代编译器中均有应用。

循环交换

一些程序中存在嵌套循环，它们会以非连续顺序访问存储器中的数据。只要交换一下这些循环的嵌套顺序，就可能使程序代码按照数据的存储顺序来访问它们。如果缓存中无法容纳这些数组这一技术可以通过提高空间局域性来减少缺失；通过重新排序，可以使缓存块中的数据在被替换之前，得到最大限度的充分利用。

例如，设x是一个大小为5000*100的两维数据，其分配方式使得x[i,j]和x[i,j+1]相邻（由于这个数组是按行进行排列的，所以我们说这种顺序是以行为主的），以下两段代码说明可以怎样来优化访问过程：

1
2
3
4
5
6
7
8
9

/* 优化之前 */
for(j=0; j< 100; j=j+1)
    for(i=0; i<5000; i++)
        x[i][j] = 2 * x[i][j];

/* 优化之后 */
for(i=0; i<5000; i++)
    for(j=0; j< 100; j=j+1)
        x[i][j] = 2 * x[i][j];

原代码以100个字的步幅跳跃式浏览存储器，而修改后的版本在访问了一个缓存块中的所有字之后才进入下一个块。这一优化方法提高了缓存性能，却没有影响到所执行的指令数目。

分块

这一优化方法通过提高时间局域性来减少缺失。这一次还是要处理多个数组，有的数组是按行来访问的，有的是按列来访问的。由于在每个循环迭代中都用到了行与列，所以按行或按列来存储数组并不能解决问题（按行存储称为行主序，按列存储称为列主序）。这种正交访问方式意味着在进行循环交换之类的转换操作之后，仍然有很大的改进空间。

分块算法不是对一个数组的整行或整列进行操作，而是对其子矩阵（或称块）进行操作。其目的是在缓存中载入的数据被替换之前，在最大限度上利用它。下面这段执行矩阵乘法的示例可以帮助理解这一优化方法的动机：

1
2
3
4
5
6
7
8

/* 优化之前 */
for (i = 0; i < N; i ++)
    for (j = 0; j < N; j ++) {
        r = 0;
        for (k = 0; k < N; k ++)
            r = r + y[i][k] * z[k][j];
        x[i][j] = r;
    }

容量缺失的数目显然取决于N和缓存的大小。如果它能容纳所有这3个N×N矩阵，只要没有缓存冲突，就一切正常。如果缓存可以容纳一个N×N矩阵和包含N个元素的一行，则至少Y的第i行和数组Z可以停留在缓存中。如果缓存的容量更小，那可能对于X和Z都会发生缺失。在最差情况下，进行N^3次操作可能需要从存储器中读取2N^3 + N^2个字。

三个数组X、Y和Z的快照，其中N=6，i=1。对数组元素访问的前后时间用阴影表示。白色表示还没有被访问过，浅色表示较早的访问，深色表示最近的访问。与下图相对照，为了计算X的新元素，会重复读取Y和Z的元素。在行或列的旁边显示了用于访问这些数组的变量i，j和k。

为了确保正在访问的元素能够放在缓存中，对原代码进行了修改，改为计算一个大小为B×B的子矩阵。两个内层循环现在以大小为B的步长进行计算，而不是以X和Z的完整长度为步长。B被称为分块因子。（假定x被初始化为0。）

1
2
3
4
5
6
7
8
9
10

/* 优化之后 */
for (jj = 0; jj < N; jj += B)
for (kk = 0; kk < N; kk += B)
for (i = 0; i < N; i ++)
    for (j = kk; j < min(jj+B, N); j ++) {
        r = 0;
        for (k = kk; k < min(kk+B, N); k ++)
            r = r + y[i][k] * z[k][j];
        x[i][j] = r;
    }

图展示了使用分块方法对三个数组的访问。仅观察容量缺失，从存储器中访问的总字数为2N^3/B+N^2。这一总数的改善因素大约为B。由于Y获益于空间局域性，Z获益于时间局域性，所以分层方法综合利用了空间局域性和时间局域性。

尽管我们的目标是降低缓存缺失，但分块方法也可用于帮助寄存器分配。通过设定一个较小的分块大小，使这个块能够保存在寄存器中，可以在最大程度上降低程序中的载入与存储数量。

第九种优化：对指令和数据进行硬件预取，以降低缺失代价或缺失率

在处理器请求项目之前，预先提取它们。指令和数据都可以预先提取，既可以直接放在缓存中，也可以放在一个访问速度快于主存储器的外部缓冲区中。指令预取经常在缓存外部的硬件中完成。通常，处理器在一次缺失时提取两个块：被请求块和下一个相邻块。被请求块放在它返回时的指令缓存中，预取块被放在指令流缓冲区中。如果被请求块当前存在于指令流缓冲区中，则原缓存请求被取消，从流缓冲区中读取这个块，并发出下一条预取请求。

Intel core i7支持利用硬件预先提取到L1和L2中，最常见的预取情况是访问下一行。一些较早的Intel处理器使用更主动的硬件预取，但会导致某些应用程序的性能降低，一些高级用户会因此而关闭这一功能。图显示了在启用硬件预取时，部分SPEC2000程序的整体性能改进。注意，这一数字仅包含12个整数程序中的两个，而大多数SPEC浮点程序则都包含在内。

图在intel Pentium4上启用硬件预取之后，12个SPECInt 2000基准测试中的2个测试、14个SPECfp2000基准测试中的9个測试获得的加速比。图中仅给出从预取中获益最多的程序，对于图中未给出的15个SPEC基准测试，顸取加速比低于15%

预取操作需要利用未被充分利用的存储器带宽，但如果它干扰了迫切需要的缺失内容，反而可能会实际降低性能。在编译器的帮助下，可以减少无用预取。当预取操作正常执行时，它对功率的影响可以忽略。如果未用到预取数据或者替换了有用数据，预取操作会对功率产生非常负面的影响。

第十种优化：用编译器控制预取，以降低缺失代价或缺失率

作为硬件预取的替代方法，可以在处理器需要某一数据之前，由编译器插入请求该数据的预取指令。共有以下两种预取。

• 寄存器预取将数据值载入到一个寄存器中。
• 缓存预取仅将数据载入到缓存中，而不是寄存器中。

这两种预取都可能是故障性的，也都可能是非故障性的；也就是说，其地址可能会导致虚拟地址错误异常和保护冲突异常，也可能不会导致。利用这一术语，正常的载入指令可能被看作是“故障性寄存器预取指令”。非故障性预取只是在通常导致异常时转换为空操作，而这正是我们想要的结果。

最有效的预取对程序来说是“语义透明的”：它不会改变寄存器和存储器的内容，也不会导致虚拟存储器错误。今天的大多数处理器都提供非故障性缓存预取。本节假定非故障性缓存预取，也称为非绑定预取。

只有当处理器在预取数据时能够继续工作的情况下，预取才有意义；也就是说，缓存在等待返回预取数据时不会停顿，而是继续提供指令和数据。可以想到，这些计算机的数据缓存通常是非阻塞性的。

与硬件控制的预取操作类似，这里的目标也是将执行过程与数据预取过程重叠起来。循环是重要的预取优化目标，因为它们本身很适于进行预取优化。如果缺失代价很小，编译器只需要将循环展开一两次，在执行时调度这些预取操作。如果缺失代价很大，它会使用软件流水线或者将循环展开多次，以预先提取数据，供后续迭代使用。

不过，发出预取指令会导致指令开销，所以编译器必须非常小心地确保这些开销不会超过所得到的好处。如果程序能够将注意力放在那些可能导致缓存缺失的引用上，就可以避免不必要的预取操作，同时明显缩短存储器平均访问时间。

许多处理器支持缓存预取指令，高端处理器还经常在硬件中完成某种类型的自动预取。

缓存优化小结

表中估计了它们对复杂度的影响，其中“+”表明该技术会改进该项因素，“-”表明会损害该项因素。

存储器技术与优化

主存储器在层次结构上位于缓存的下一层级。主存储器满足缓存的需求，并充当接口，既是输入的目的地，又是输出的源头。对主存储器的性能度量同时强调延迟和带宽。传统上，主存储器延迟（它会影响缓存缺失代价）是缓存的主要考虑因素，而主存储器带宽则是微处理器和I/O的主要考虑因素。

由于多级缓存日益普及，而且采用较大的分块，使主存储器带宽对于缓存也非常重要。事实上，缓存设计人员增大块大小就是为了利用更高的存储器带宽。在过去，对主存储器的革新就是改变构成主存储器的众多DRAM芯片（比如多个存储器组）的组织方式。在使用存储器组时，通过拓宽存储器或其总线，或者同时加宽两者，可以提供更大的带宽。

但是，具有讽刺意味的是，随着单片存储器芯片容量的增加，在同样大小的存储器系统中，所需要的芯片越来越少，从而降低了存储器系统容量不变、带宽加大的可能性。为使存储器系统跟上现代处理器的带宽需求，存储器革新开始在DRAM芯片自身内部展开。

存储期延迟主要由两部分组成，访问时间和周期时间。访问时间是发出读取请求到收到所需字之间的时间，周期时间是指对存储器发出两次不相关请求之间的最短时间。

SRAM

SRAM的第一个字母表示静态。DRAM电路的动态本质要求在读取数据之后将其写回，因此在访问时间和周期时间之间存在差异，并需要进行刷新。SRAM不需要刷新，所以存在时间与周期时间非常接近。SRAM通常使用6个晶体管保存1位数据，以防止在读取信息时对其造成干扰。在待机模式中，SRAM只需要很少的功率来维持电荷。

DRAM技术

早期DRAM的容量增大时，由于封装上需要提供所有必要的地址线，所以封装成本较高。解决方案是对地址线进行复用，从而将地址管脚数砍去一半。图中给出基本的DRAM组成结构。先在行选通（RAS）期间发送一半地址。然后在列选通（CAS）期间发送另一半地址。行选通和列选通等名字源于芯片的内部结构，这些存储器的内部是一个按行和列寻址的长方形矩阵。

对DRAM的另一要求来自其第一个字母D表示的特性，即动态（dynamic）。为了在每个芯片中容纳更多的位，DRAM仅使用一个晶体管来存储一位数据。信息的读取过程会破坏该信息，所以必须进行恢复。这是DRAM周期时间一般要长于访问时间的原因之一；近来，DRAM已经引入了多个组，从而可以隐藏访问周期中的重写部分，见图。此外，为了防止在没有读写某一个位时丢失信息，必须定期“刷新”该位。幸运的是，只需对一行进行读取就可以同时刷新该行。因此，每个DRAM必须在某一特定时间窗口内访问每一行。

图为DRAM中的内部组成结构。现代DRAM是以“组”为单位进行组织的，DDR3通常有4组。每一组由一系列行构成。发送PRE（precharge）命令会打开或关闭一个组。行地址随Act（activate）命令发送，该命令会将一个行传送到缓冲区中。将行放入缓冲区后，就可以采用两种方式进行传送，一种是根据DRAM的宽度采用连续列地址传送（在DDR3中，这一宽度通常为4位、8位、16位），另一种是指定块传送方式，并给出起始地址。每个命令和块传送过程，都以一个时钟进行同步。

这一要求意味着存储器系统偶尔会有不可用时间，因为它要发出一个信号，告诉每个芯片进行刷新。刷新时间通常是对DRAM中每一行进行完整存储器访同（RAS和CAS）的时间。由于DRAM中的存储器矩阵在概念上是方形的，所以一次刷新中的步骤通常是DRAM容量的平方根。DRAM设计人员尽力将刷新时间保持在总时间的5％以下。

刷新操作是存储器延迟发生变化的另一个原因，从而也会影响缓存缺失代价的变化。

Amdahl提出一条经验规律：要保持系统的平衡，存储器容量应当随处理器的速度线性增长，所以一个运算速度为1000MIPS的处理器应当拥有1000 MB的存储器。处理器设计人员依靠DRAM来满足这一要求。过去，他们可以指望存储器容量每三年翻两番，也就是年增长率为55％。遗憾的是，DRAM现在的性能增长速度非常慢。表2-2给出了行访问时间的性能改变，它与延迟有关，每年大约为5％。CAS或数据传输时间与带宽有关，其增长速度超过上述
速度的两倍。

尽管我们前面讨论的是独立芯片，但DRAM通常是放在被称为双列直插存储模块（DIMM）的小电路板上出售的。DIMM通常包括4-16个DRAM，对于桌面系统和服务器系统，它们通常被组织为8字节宽度（+ECC）。

提高DRAM芯片内部的存储器性能

前面曾经提到，对DRAM的访问分为行访问和列访问两部分。DRAM必须在DRAM内部缓冲一行中的所有位，为列访问做好准备，一行的位数通常等于DRAM大小的平方根，比如，4Mbit DRAM的每行有2Kbit。随着DRAM容量的增大，添加了一些附加结构，也多了几种提高带宽的可能性。

第一，DRAM添加了定时信号，允许复访问行缓冲区，从而节省了行访问时间。这种缓冲区的出现非常自然，因为每个数组会为每次访问操作缓冲1024-4094位信息。最初，在每次传输时都需要发送不同的列地址，从而在每组新的列地址之后都有一定的延迟时间。

DRAM原来有一个与存储器控制器相连的异步接口，所以每次传输都需要一定的开销，以完成与控制器的同步。第二，向DRAM接口添加一个时钟信号，使重复传输不需要承担这一开销。这种优化的名字就是同步DRAM（SDRAM）。SDRAM通常还有一个可编程寄存器，用于保存请求字节数，因此可以在几个周期内为每个请求发送许多字节。通常，将DRAM置于突发模式，不需要发送任何新地址就能进行8次或更多次的16位传输；这种模式支持关键字优先传
输方式，是唯一能够达到表2-3所示峰值带宽的方法。

第三，随着存储器系统密度的增加，为了从存储器获得较宽的比特流，而又不必使存储器系统变得过大，人们拓展了DRAM的宽度。原来提供一种4位传输模式；2010年，DDR2和DDR3 DRAMS已经拥有宽达16位的总线。

第四种提高带宽的DRAM重要创新是在DRAM时钟信号的上升沿和下降沿都传输数据，从而使峰值数据传输率加倍。这种优化方法被称为双倍数据率（DDR）。

为了提供交错（interleaving）的一些优点，并帮助进行电源管理，SDRAM还引入了分组，将一块SDRAM分为2-8个可以独立运行的块（在目前的DDR3 DRAM中为8块）。在一个DRAM中创建多个组可以有效地添加另一个地址段，它现在由组号、行地址和列地址组成。在发送指定一个新组的地址时，这个组必须己经打开，会增加一些延迟。分组与行缓冲区的管理完全由现代存储器控制接口处理，这样，如果后续地址指定了一个开放组的相同行时，只需要发送列地址就能快速完成访问。

在将DDR SDRAM封装为DIMM形式时，会用DIMM峰值带宽进行标记，这种标记方法很容易引起混淆。比如，之所得到PC2100这样一个DIMM名称，是源于133MHz x 2 x 8字节=2100MB/s，为了避免这种混淆，在对芯片本身进行标记时，给出的不是其时钟频率，而是每秒比特数，因此一个133MHz的DDR芯片被称为DDR266。表2-3给出了时钟频率、每芯片每秒钟的传送数目、芯片名称、DIMM带宽和DIMM名称之间的关系。

降低SDRAM中的功耗

动态存储器芯片中的功耗由静态（或待机）功率和读写期间消耗的动态功率构成，这两者取决于工作电压。在大多数高端DDR3 SDRAM中，工作电压已经降到1.35-1.5伏，与DDR2 SDRAM相比，显著降低了功率。分组的增加也降低了功率，这是因为每次仅读取并预充电一个分组中的行。

除了这些变化之外，所有最新SDRAM都支持一种省电模式，通知DRAM忽略时钟即可进入这一模式。省电模式会禁用SDRAM，但内部自动刷新除外（如果没有自动刷新，当进入省电模式时间长于刷新时间后，将会导致存储器内容丢失）。图2-12给出了一个2Gbit DDR3 SDRAM在三种情况下的功耗。从低功率模式返回正常模式所需的确切延迟时间取决于SDRAM，但从自动刷新低功率模式返回正常状态的时间一般为200个时钟周期；在第一个命令之前复位模式寄存器可能需要延长一些时间。

DDR3 SDRAM在3种不同运行条件下的功耗：低功率（关闭）模式、典型系统模式。（在读取操作中，DRAM有30%的时间处于活动状态，在写入操作中有15％的时间处于活动状态）和完全活动模式，在这种模式下，DRAM在非预充电状态下持续读取或写入。读取和写入采用由8次传输组成的突发形式。

闪存

闪存是一种EEPROM（电可擦可编程只读存储器），它通是只读的，但可以檫除。闪存的另一个重要特性是能在没有任何供电的情况下保存其内容。

闪存在PMD中用作备份存储，其工作方式与笔记本型计算机或服务器中的磁盘相同。此外，由于大多数PMD的DRAM数量有限，所以闪存在很大程度上还要充当存储器层次结构的一级，闪存使用的体系结构与标准DRAM有很大不同，性质也有所不同。最重要的区别在于以下几方面。

1. 在改写内存之前，必须对其进行擦除，（在高密度闪存中，称为NAND闪存，大多数计算机都采用这种闪存）它的擦除过程是按块进行的，而不是单独擦除各个字节或各个字。这意味着在需要向闪存中写入数据时，必须对整个块进行处理，或者全是新数据，或者将要写入的数据与块中的其他内容合
   并在一起。
2. 闪存是静态的（也就是说，即使在没有供电的情况下，它也能保持其内容），在未进行读写时，只消耗非常低的一点功率（在待机模式下会低于一半，在完全非活动状态上可以为零）。
3. 对任何一个块来说，闪存为其提供有限数目的写入周期，通常至少为1000000个。这样，系统可以确保写入块均匀分布在整个存储器中，从而在最大程度上延长闪存系统的寿命。
4. 高密度闪存比SDRAM便宜，但比磁盘贵：闪存的价格大约是2美元/GB，SDRAM为20美元到40美GB，磁盘为0.09美元/GB。
5. 闪存的速度比SDRAM慢得多，但比磁盘快得多。从DDR SDRAM进行类似传输需要的时间大约长四分之一，而从磁盘上传输则大约慢1000倍。对于写入操作，这种区别更是大得多，SDRAM至少比闪存快10倍，也可能达到100倍，具体数值取决于环境。

提高存储器系统的可靠性

缓存和主存储器容量的增大也大幅提高了在制造过程期间和对存储器单元进行动态冲击时（主要来自宇宙射线）出现错误的概率。这些动态错误会改变存储器单元的内容，但不会改变电路，称之为软错误。所有DRAM，闪存和许多SRAM在制造时都留有备用行，这样可以容忍少量的制造缺陷，只需要通过编程方式用备用行替代缺陷行即可。除了必须在配置期间纠正的制造错误之外，还可能在运行时发生硬错误，它可能会永久改变一个或多个存储器单元的运行方式。

动态错误可以使用奇偶校验位检测，可以使用纠错码（ECC）检测和纠正。因为指令缓存是只读的，用奇偶校验位就足够了。在更大型的数据缓存和主存储器中，则使用ECC技术来检测和纠正错误。奇偶校验位只需要占用一个数据位就可以检测一系列数据位中的一个错误。由于无法使用奇偶校验位来检测多位错误，所以必须限制用奇偶校验位提供保护的位数。一个常用比值是每8个数据位使用一个奇偶校验位。如果采用ECC技术，在每64个数据位中，8位的开销成本可以检测两个错误，纠正一个错误。

保护：虚拟存储器和虚拟机

通过虚拟存储器提供保护

页式虚拟存储器（包括缓存页表项目的变换旁视缓冲区）是保护进程免受相互伤害的主要机制。

多道程序设计（multi programming，几个同时运行的程序共享一台计算机的资源）需要在各个程序之间提供保护和共享，从而产生了进程概念。在任意时刻，必须能够从一个进程切换到另一个进程。这种交换被称为进程切换或上下文切换。操作系统和体系结构联合起来就能使进程共享硬件而不会相互干扰。为此，在运行一个用户进程时，体系结构限制用户进程能够访问的资源，但要允许操作系统进程访问更多资源。体系结构至少要做到以下几点。

1. 提供至少两种模式，指出正在运行的进程是用户进程还是操作系统进程。后者有时被称为内核进程或管理进程。
2. 提供一部分处理器状态信息，用户进程可以使用但不能写入。这种状态信息包括用户/管理模式位、异常启用/禁用位和存储器保护位。之所以禁止用户写入这些状态信息，是因为如果用户可以授予自己管理权限、禁用异常或者改变存储器保护，那操作系统就不能控制用户进程了。
3. 提供处理器借以从用户模式转为管理模式及反向转换的机制。前一种转换通常通过系统调用完成，使用一种特殊指令将控制传递到管理代码空间的一个专用位置。保存系统调用时刻的程序计数器，处理器转入管理模式。返回用户模式的过程类似于一个全程返回过程，恢复到先前的用户/管理模式。
4. 提供限制存储器访问的机制，在上下文切换时不需要将一个进程切换到磁盘就能保护该进程的存储器状态。

到目前为止，最流行的机制还是添加对虚拟存储器各个页面的保护性限制。固定大小的页面（通常长4KB或8KB）通过一个页表由虚拟地址空间映射到物理地址空间。这些保护性限制就包含在每个页表项中。保护性限制可以决定一个用户进程能否读取这个页面，一个用户进程能否写这个页面以及能否从这个页面执行代码。此外，如果一个进程没有包含在页表中，那它就既不能读取也不能写入一个页面。由于只有操作系统才能更新页表，所以分页机制提供了全面的访问保护。

分页虚拟存储器意味着每次存储器访问在逻辑上都要花费至少两倍的时间，一次存储器访问用以获取物理地址，第二次访问用于获取数据。这种成本可能太过高昂了。解决方案就是依靠局域性原理，如果这些访问具有局域性，那么访问操作的地址转换也肯定具有局域性。只要将这些地址转换放在一个特殊的缓存中，存储器访问就很少再需要第二次访问操作来转换地址了。这种特殊的地址转换缓存被称为变换旁视缓冲区（TLB）。

TLB项目类似于缓存项目，其中的标记保存虚拟地址部分，数据部分保存物理页地址、保护字段、有效位，通常还有一个使用位和一个更改位（dirty bit）。操作系统在改变这些位时，改变页表中的值，然后使相应的TLB项失效。当这个项目新载入到页表中时，TLB即获得这些位的准确副本。

通过虚拟机提供保护

有一个与虚拟存储器相关而且几乎与它一样古老的概念，那就是虚拟机（VM）。它们最早是在20世纪60年代后期提出的，多年以来一直是大型机计算的重要组成部分。近来得到广泛关注，原因如下：

• 隔离与安全在现代系统中的重要性提高
• 标准操作系统的安全性和可靠性出现问题；
• 许多不相关用户（比如一个数据中心或云中的用户〕共享同一计算机，
• 处理器原始速度的飞速增大，使虚拟机的开销更容易接受。

最常见的情况是，VM支持的ISA与底层硬件相同；但也有可能支持不同的ISA，在ISA之间迁移时经常采用这种方法，这样，在能够迁移到新ISA之前，使软件能够继续在原ISA上使用。在我们重点关注的虚拟机中，所提供的ISA与其底层硬件相匹配。这种虚拟机称为（操作）系统虚拟机。它们让虚拟机用户感觉到自己拥有整个计算机，包括操作系统的副本在内。一台计算机可以运行多个虚拟机，可以支持多种不同操作系统。在传统平台上，一个操作系统“拥有”所有硬件资源，但在使用虚拟机时，多个操作系统一起共享硬件资源。

为虚拟机提供支持的软件称为虚拟机监视器(VMM)或管理程序，VMM是虚拟机技术的核心。底层硬件平台称为主机，其资源在来宾VM之间共享。VMM决定了如何将虚拟资源映射到物理资源：物理资源可以分时共享、划分，甚至可以在软件内模拟。VMM要比传统操作系统小得多。

一般来说，处理器虚拟化的成本取决于工作负载。用户级别的处理器操作密集型程序的虚拟化开销为零，这是因为很少会调用操作系统，所有程序都以原速运行。与之相对的是L/O操作密集的工作负载，它们通常也会大量涉及操作系统，执行许多系统调用（以满足I/O需求）和可能导致高虚拟化开销的特权指令。如果涉及大量I/O操作的工作负载也是IO密集型的，由于处理器经常要等待IO，所以处理器虚拟化的成本可以完全被较低的处理器利用率所隐藏。

尽管我们这里关心的是VM提供保护的功能，但VM还提供了其他两个具有重要商业价值的优点。

1. 软件管理。VM提供一种能运行整个软件栈的抽象层。一种典型部署是用一部分VM运行原有OS，大量VM运行当前稳定的OS，一小部分VM用于测试下一代OS。
2. 硬件管理。需要多个服务器的原因之一是希望每个应用程序都能在独立的计算机上与其兼容的操作系统一起运行，这种分离可以提高系统的可靠性。VM允许这些分享软件栈独立运行，却共享硬件，从而减少了服务器的数量。还有一个例子，一些VMM允许将正在运行的VM迁移到不同计算机上，既可能是为了平衡负载，也可能是为了撤出发生故障的硬件。

对虚拟机监视器的要求

一个VM监视器必须完成哪些任务？它向来宾软件提供一个软件接口，必须使不同来宾的状态相互隔离，还必须保护自己免受客户端软件的破坏（包括来宾操作系统）。定性需求包括：

• 来宾软件在VM上的运行情况应当与在原始硬件上完全相同，当然，与性能相关的行为或者因为多个VM共享固定资源所造成的局限性除外；
• 来宾软件应当不能直接修改实际系统资源的分配。

为了实现处理器的“虚拟化”，VMM必须控制几乎所有操作——特权状态的访问、地址转换、异常和中断，即使目前正在运行的来宾VM和操作系统正在临时使用它们，也不应当影响到这些控制。

例如，在计时器中断时，VMM将挂起当前正在运行的来宾VM，保存其状态、处理中断、判断接下来运行哪个来宾VM，然后载入其状态。依赖计时器中断的来宾都会有一个由VMM提供的虚拟计时器和仿真计时器。

为了进行管理，VMM的管理权限必须高于来宾，后者通常运行于用户模式；这样还能确保任何特权指令的执行都由VMM处理。系统虚拟机的基本需求几乎与上述分页虚拟存储器的要求相同。

• 至少两种处理器模式：系统模式和用户模式。
• 指令的一些特权子集只能在系统模式下使用，如果在用户模式下执行将会导致陷阱。所有系统资源都只能通过这些指令进行控制。

虚拟机（缺少）的指令集体系结构支持

如果在设计ISA期间已经为VM作了规划，那就可以比较轻松地减少VMM必须执行的指令数、缩短模拟这些指令所需要的时间。如果一种体系结构允许、直接在硬件上运行，则为其冠以可虚拟化的头衔。

由于VMM必须确保客户系统只能与虚拟资源进行交互，所以传统的来宾操作系统是作为一种用户模式程序在VMM的上层运行的。因此，如果一个来宾操作系统试图通过特权指令访问或修改与硬件相关的信息，它会向VM发出陷阱中断。VMM随后可以对相应的实际资源实进行适当修改。

因此，如果任何以用户模式执行的指令试图读写此类敏感信息陷阱，VMM可以截获它，根据来宾操作系统的需要，向其提供敏感信息的一个虚拟版本。如果缺乏此类支持，则必须采取其他措施。

虚拟机对虚拟存储器和IO的影响

由于每个VM中的每个来宾操作系统都管理其自己的页表集，所以虚拟存储器的虚拟化就成为另一项挑战。为了实现这一功能，VMM区分了实际存储器（real memory）和物理存储器，使实际存储器成为虚拟存储器与物理存储器之间的独立、中间级存储器。来宾操作系统通过它的页表将虚拟存储器映射到实际存储器，然页表将来宾的实际存储器映射到物理存储器。虚拟存储器体系结构可以通过页表指定；也可以通过TLB结构指定，许多RISC体系结构属于此类。

VMM没有再为所有存储器访问进行一级间接迂回，而是维护了一个影子页表，直接从来宾虚拟地址空间映射到硬件的物理地址空间。通过检测来宾页表的所有修改，VMM就能保证硬件在转换地址时使用的影子页表项与来宾操作系统环境的页表项一一对应，只是用正确的物理页代替了来宾表中的实际页。因此，只要来宾试图修改它的页表，或者试图访问页表指针，VMM都必须加以捕获。这一功能通常通过以下方法来实现：对来宾页表提供写保护，并捕获来宾操作系统对页表指针的所有访问尝试。前面曾经指出，如果对页表指针的访问属于特权操作，就会很自然地实现捕获。

IBM 370体系结构在20世纪70年代添加了一个由VMM管理的迂回层，解决了页表问题。来宾操作系统和以前一样保存自己的页表，所以就不再需要影子页表。在许多RISC计算机中，为了实现TLB的虚拟化，VMM管理实际TLB，并拥有每个来宾VM的TLB内容副本。为实现这一功能，所有访问TLB的功能都必须被捕获。具有进程ID标记的TLB可以将来自不同VM与VMM的项目混合在一起，所以不需要在切换VM时刷新TLB。与此同时，VMM在后台支持VM的虚拟进程ID与实际进程ID之间的映射。

体系结构中最后一个要虚拟化的部分是I/O。到目前为止，这是系统虚拟化中最困难的一部分，原因在于连接到计算机的I/O设备数目在增加，而且这些IO设备的类型也变得更加多样化。另外一个难题是在多个VM之间共享实际设备，还有一个难题是需要支持不同的设备驱动程序，在同一VM系统上支持不同来宾操作系统时尤为困难。为了仍然能够实现VM，可以为每个VM提供每种I/O设备驱动程序的一个通用版本，然后交由VMM来处理实际IO。

将虚拟设备映射到物理IO设备的方法取决于设备类型。例如，VMM通常会对物理进行分区，为来宾VM创建虚拟磁盘，而VMM会维护虚拟磁道与扇区到物理磁盘与扇区的映射。网络接口通常会在非常短的时间片内在VM之间共享，VMM的任务就是跟踪虚拟网络地址的消息，以确保来宾VM只收到发给自己的消息。

交叉问题：存储器层次结构的设计

保护和指令集体系结构

保护是由体系结构和操作系统协力完成的。但是当虚拟存储器变得更为普及时，体系结构必须修改现有指令集体系结构中一些不便使用的细节。在历史上，IBM大型机硬件和VMM通过以下3个步骤来提高虚拟机的性能：

• 降低处理器虚拟化的成本
• 降低由于虚拟化而造成的中断开销
• 将中断传送给正确的VM，而不调用VMM，以降低中断成本。

Intel和AMD芯片集的最近版本添加了一些指令，用以支持VM中的设备，在较低层级屏蔽来自每个VM的中断，将中断发送到适当的VM。

缓存数据的一致性

数据可以同时出现在存储器和缓存中。只要处理器是唯一修改或读取数据的组件。并且缓存存在于处理器和存储器之间，那处理器看到旧副本或者说过期副本的危险性就很低。后面将会看到，使用多个处理器和IO设备增大了副本不一致及读取错误副本的机会。

处理器出现缓存一致性问题的频率与IO不同。对IO来说出现多个数据副本是非常罕见的情况，而一个在多处理器上运行的程序会希望在几个存中拥有同一数据的多个副本。多处理器程序的性能取决于系统共享数据的性能。IO缓存一致性问题可以表述如下：IO发生在计算机中的什么地方？在I/O设备与缓存之间，还是在IO设备与主存储器之间？如果输入将数据放在缓存中，而且输出从缓存中读取数据，那IO和处理器会看到相同数据。这种方法的难点在于它干扰了处理器。可能会导致处理器因为等待IO而停顿。输入还可能会用某些不会马上用到的新数据来取代存中的某些信息，从而对缓存造成干扰。

在带有缓存的计算机中，IO系统的目标应当是防止出现数据过期问题，同时尽可能减少干扰。因此，许多系統喜欢直接对主有储器进行I/O操作，把主存储器当作一个I/O缓冲区。如果使用直写缓存，存储器中将拥有最新的信息副本，在榆出时不存在过期数据问题（这一好处也是处理器使用直写方式的一个原因。遗憾的是，现在通常只会在第一级数据缓存中使用直写方式，由使用写回方式的L2缓存为其提供后盾。

输入操作还需要另外做点功课。软件解决方案是保证输入缓冲区的所有数据块都没有在缓存中。可以将包含缓冲区的页标记为不可缓存，操作系統总是可以向这样一个页面中输入数据。或者，可以由操作系统在输入之前从缓存刷新缓冲区地址。硬件解决方案则是在输入时检查IO地址，查看它们是否在缓存中。如果在缓存中找到了IO地址的匹配项，则使缓存项失效，以免过期数据。所有这些方法也都能用于带有写回缓存的输出操作。

融会贯通：ARM Cortex-A8和Intel i7中的存储器层次结构

ARM Cortex-A8

Cortex-A8是一种支持ARMv7指令集体系结构的可配置核心。它是作为一种IP（知识产权）核心交付的。在嵌入式、PMD和相关市场上，IP核心是主要的技术交付形式；利用这些IP核心已经生成了数十亿个ARM和MIPS处理器。注意，IP核心不同于Intel i7中的核心和AMD Athlon多核心。一个IP核心（它本身可能是多核心）就是为与其他逻辑集成而设计的，因此，它是一个芯片的核心。这些其他逻辑包括专用处理器（比如视频编解码器）、 I/O接口和存储器接口，从而制造出一种专门针对特定应用进行优化的处理器。

整体来说，IP 核心分为两类。硬核心针对特定半导体厂家进行优化，是一些具有外部接口的黑盒（不过这些接口仍然在片上）。硬核心通常仅允许对核心外面的逻辑进行参数设定，比如L2缓存大小，不能对IP核心本身进行修改。软核心的交付形式通常采用一个标准的逻辑元件库。软核心可以针对不同的半导体厂家进行编译，也可以进行修改，不过由于当今IP核心的复杂度，很难对其进行大幅修改。一般来说，硬核心的性能较高、晶片面积较小，而软核心则允许针对不同厂家进行调整，其修改更容易。

当时钟频率高达1 GHz 时，Cortex-A8每个时钟周期可以发出两条指令。它可以支持一种两级缓存层次结构，第一级是一个缓存对（I和D），分别为16 KB或32 KB，其组织形式为四路组相联缓存，并使用路预测和随机替代。其目的是使缓存的访问延迟只有一个周期，使Cortex-A8将从载入到使用的延迟时间保持在一个周期，简化指令提取，在分支缺失导致预取了错误指令时，降低提取正确指令的代价。第二级缓存是可选的，如果存在这一级缓存，则采用八路组相联，容量可达128 KB ~ 1 MB；它的组织形式分为1-4组，允许同时从存储器进行多次传输。一个64位至128位的外部总线用来处理存储器请求。第一级缓存为虚索引、物理标记，第二级缓存为物理索引与标记；这两级缓存的块大小都是64字节。当D缓存为32 KB且页大小为4KB时，每个物理页可以映射到两个不同的缓存地址；在发生缺失时，通过硬件检测可以避免出现混淆现象。

存储器管理由TLB对处理（I和D），每个TLB与32个项目完全相关，页面大小可变（4KB、16KB、64KB、1 MB和16 MB）；TLB中的替换用轮询算法完成。TLB缺失在硬件中处理，它会遍历存储器中的一个页表结构。图2-13显示如何使用32位虚拟地址来索引TLB和缓存，假定主缓存为32 KB，次级缓存为512 KB，页面大小为16 KB。

Cortex-A8存储器层次结构的性能：Cortex-A8的存储器层次结构使用32 KB主缓存和1 MB八路组相联L2缓存来模拟，用整数Minnespec基准测试进行测试。Minnespec 是一个基准测试集，由SPEC2000基准测试组成，但其输入不一样，将运行时间缩短了几个数量级。尽管使用较小规模的输入并不会改变指令混合比例，但它的确会影响缓存行为。例如，根据mcf的测试结果（它是存储器操作最密集的SPEC2000整数基准测试），当缓存为32 KB时，Minnerspec的缺失率只有完整SPEC版本缺失率的65%。当缓存为1 MB时，这种差距为6倍。根据许多其他基准测试，这些比值都与mof的测试结果类似，但绝对缺失率要小得多。由于这一原因，不能将Minniespec基准测试与SPEC2000基准测试进行对比。不过这些数据对于研究L1和L2缺失对整体CPI的相对影响是很有用的。

图中展示了ARM Cortex-A8数据缓存和数据TLB的虚拟地址、物理地址、索引、标记和数据块。由于指令与数据层次结构是对称的，所以这里只给出其中一个。 TLB（指令或数据）与32个项目完全相关联。L1缓存是四路组相联，块大小为64个字节，容量为32 KB。L2缓存是八路组相联，块大小为64个字节，容量为1 MB。本图没有显示缓存和TLB的有效位和保护位，也没有使用可以指示L1缓存预测组的路预测位

即使仅对于L1，这些基准测试（以及作为Minniespec基础的完全SPEC2000版本）的指令缓存缺失率也非常低：大多接近于零，都低于1%。这种低缺失率的原因可能是因为SPEC程序在本质上是计算密集型的，而且四路组相联缓存消除了大多数冲突缺失。图2-14给出了数据缓存结果，这些结果中的L1和L2缺失率非常高。以DDR SDRAM为主存储器时，1 GHz Cortex-A8的L1缺失代价为11个时钟周期，L2缺失代价为60个时钟周期。通过这些缺失代价数据，图2-15给出了每次数据存取的平均代价。

2.6.2 Intel Core i7

i7支持x86-64指令集体系结构，它是80x86体系结构的64位扩展。i7 是包含四个核心的乱序执行处理器。i7中的每个核心采用一种多次发送、动态调度、16 级流水线，每个时钟周期可以执行多达4个80x86指令。i7还使用一种名为“同时多线程”的技术，每个处理器可以支持两个同时线程。2010 年，最快速i7的时钟频率为3.3GHz，指令的峰值执行速度为每秒132亿条指令，四核芯片超过每秒500万条指令。

i7可以支持多达三个存储器通道，每个通道由独立的DIMM组构成，它们能够并行传输数据。i7采用DDR3-1066（DIMM PC8500），峰值存储器带宽超过25 GB/s。i7使用48位虚拟地址和36位物理地址，物理存储器容量最大为36 GB。存储器管理用一个两级TLB处理，表2-4中对此进行了总结。

表2-5总结了i7 的三级缓存层次结构。第一级缓存为虚索引、物理标记，而L2和L3则采用物理索引。图2-16标有对存储器层次结构进行存取的步骤。首先，向揩令缓存发送程序计数器。指令缓存索引为:

1

2^索引 = 缓存大小/(块大小*组相联度) = 32K/(64*4) = 128 = 2^7

也就是7位。指令地址的页帧（36位）被发送给指令TLB。同时，来自虚拟地址的7位索引（再加上来自块偏移量的另外两位，用以选择适当的16字节，指令提取数）被发送给指令缓存。注意，对于四路相联指令缓存，缓存地址需要13位: 7位用于索引缓存，再加上64字节块的6位块偏移量，但页大小为4KB=2^12，这意味着缓存索引的一位必须来自虚拟地址。使用1位虚拟地址意味着对应块实际上可能位于缓存中的两个不同位置，这是因为对应的物理地址在这一位置既可能为0也可能为1。对指令来说，这样不会有什么问题，因为即使一条指令出现在缓存中的两个不同位置，这两个版本也必然是相同的。但如果允许对数据进行此类重复或别名设置，那在改变页映射时就必须对缓存进行检查，这一事件并非经常出现。注意，只要很简单地应用页着色就能消除出现这种混淆的可能性。如果偶数地址的虛拟页被映射到偶数地址的物理页（奇数页也一样），那么因为虚拟页号和物理页中的低阶位都是相同的，所以就不可能发生这种混淆。

为查找地址与有效页表项（PTE）之间的匹配项而访问指令TLB。除了转换地址之外，TLB还会进行检查，以了解这一访问操作所需要的PTE是否会因为非法访问而产生异常。

指令TLB缺失首先进入L2 TLB，它包含512个页大小为4KB的PTE，为四路组相联。从L2 TLB中载入L1 TLB需要两个时钟周期。如果L2 TLB缺失，则使用一种硬件算法遍历页表，并更新TLB项。在最糟糕情况下，这个页不在存储器中，操作系统从磁盘中获取该页。由于在页面错误期间可能执行数百万条指令，所以这时如果有另一进程正在等待，操作系统将转入该进程。否则，如果没有TLB异常，则继续访问指令缓存。

地址的索引字段被发送到指令缓存的所有4个组中。指令缓存标记为36-7位(索引)-6位(块偏移)=23位。将4个标记及有效位与来自指令TLB中的物理页帧进行对比。由于i7希望每个指令获取16个字节，所以使用6位块偏移量中的2位来选择适当的16个字节。因此，在向处理器发送16字节指令时使用了7+2=9位。L1缓存实现了流水化，一次命中的延迟为4个时钟周期。一次缺失将进入第二级缓存。前面曾经提到，指令缓存采用虚寻址、物理标记。因为第二级缓存是物理寻址的，所以来自TLB的物理页地址包含页偏移量，构成一个能够访问L2缓存的地址。L2索引为:

1

2^索引 = 缓存大小/(块大小*组相联度) = 256K/(64*8) = 512 = 2^9

所以长30位的块地址（36位物理地址-6位块偏移）被分为一个21位的标记和一个9位的索引。索引和标记再次被发送给统一L2缓存的所有8个组，同时对它们进行比较。如果有一个匹配且有效，则在开头的10周期延迟之后按顺序返回该块，返回速度为每个时钟周期8个字节。

如果L2缓存缺失，则访问L3缓存。对于一个四核i7（它的L3为8MB），其索引大小为：

1

2^索引 = 缓存大小/(块大小*组相联度) = 8M/(64*16) = 8192 = 2^13

这个长13位的地址被发送给L3的所有16个组。L3 标记的长度为36-(13-6)=17位，将其与来自TLB的物理地址进行对比。如果发生命中，则在初始延迟之后以每个时钟周期16字节的速度返回这个块，并将它放在L1和L3中。如果L3缺失，则启动存储器访问。

如果在L3中没有找到这个指令，片上存储器控制器必须从主存中找到这个块，i7有三个64位存储器通道，它们可以用作一个192位通道，这是因为只有一个存储器控制器，在两个通道上发送的是相同的地址；当两个通道具有相同的DIMM时，就可以进行宽通道传送。每个通道最多支持4个DDR DIMM。由于L3包含在内，所以在数据返回时，会将它们放在L3和L1中。

在发生指令缺失时，由主存储器提供这一指令的总延迟包括用于判断发生了L3缺失的约35个处理器周期，再加上关键指令的DRAM延迟。对于一个单组DDR1600 SDRAM和3.3 GHz CPU来说，在接收到前16个字节之前的DRAM延迟为大约35 ns或100个时钟周期，所以总的缺失代价为135个时钟周期。存储器控制器以每个存储器时钟周期16个字节的速度填充64字节缓存块的剩余部分，这将另外花费15 ns或45个时钟周期。

由于第二级缓存是一个写回缓存，任何缺失都会导致将旧块写回存储器中。i7 有一个10项合并写缓冲区，当缓存的下一级未用于读取时写回脏缓存行。在发生任何缺失时都会查看此写缓冲区，看看该缓存地是否在这个缓冲区中；如果在，则从缓冲区中获取缺失内容。在L1和L2缓存之间使用了一个类似缓冲区。

如果初始指令是一个载入指令，则将数据地址发送给数据缓存和数据TLB，与指令缓存访问非常类似，但有一个非常关键的区别。 第一级数据缓存为八路组相联，也就是说索引是6位(指令缓存为7位)，用于访问此缓存的地址与页偏移相同。因此，就不再需要担心数据缓存中的混淆问题。

假定这个指令是存储指令，而不是载入指令。在发出存储指令时，它会像载入指令一样进行数据缓存查询。发生缺失时，会将这个块放到写缓冲区中，这是因为L1缓存在发生写缺失时不会分配该块。在命中时，存储不会立即更新L1（或L2）缓存，而是要等到确认没有疑问时才会进行更新。在此期间，存储指令驻存在一个“载入-存储”队列中，这是处理器乱序控制机制的一个组成部分。i7还支持从层次结构的下一层级为L1和L2进行预取。在大多数情况下，预取行就是缓存中的下一个块。在仅为L1和L2预取时，就可以避免向存储器执行高成本的提取操作。

我们使用SPECCPU2006基准测试中的19个基准测试（12个整型和7个浮点）来评估i7缓存结构的性能。本节的数据由路易斯安那州大学的LuPeng教授和Ying Zhang博士生收集。

我们首先来看L1缓存。这个32 KB、4路组相联指令缓存的指令缺失率非常低，最主要的原因是因为i7的指令预取十分有效。当然，由于i7不会为单个指令单元生成单独的请求，而是预取16字节的指令数据（通常介于4~ 5个指令之间），所以如何评估这一缺失率需要一点技巧。为了简单起见，如果我们就像处理单一指令引用那样研究指令缓存缺失率，那么L1指令缓存缺失率的变化范围为0.1%-1.8%，平均略高于0.4%。这一比率与利用SPECCPU2006基准测试对指令缓存行为进行的其他研究一致，这些研究也显示指令缓存缺失率很低。

L1数据缓存更有趣，对它的评估需要更强的技巧性，原因如下所述。

• 因为L1数据缓存不进行写入分派，所以写入操作可以命中，从来不会真正缺失，之所以这么说，是因为那些没有命中的写入操作会将其数据放在写缓冲区中，而不会记录为缺失。
• 因为推测有时可能会错误，所以会有一些对L1数据缓存的引用，它们没有对应最终会完整执行的载入或存储操作。这样的缺失应当怎样处理呢?
• 最后，L1数据缓存进行自动预取。发生缺失的预取是否应当计算在内？如果要计算在内，如何计算？

为了解决这些问题，在保持数据量合理的情况下，图2-17以两种方式显示了L1的数据缓存缺失: 一种是相对于实际完成的载入指令数（通常称为“已完成”或“中途退出”），另一种是相对于从任意来源执行的L1数据缓存访问数。可以看到，在仅相对于已完成载入指令测试的缺失率要高出1.6倍（平均9.5%对5.9%）。表2-6以表格形式显示了相同数据。

由于L1数据缓存缺失率达到5%~10%，有时还会更高一些，所以L2和L3缓存的重要性应当就非常明显了。图2-18给出了L2和L3缓存相对于L1引用的缺失率。由于对存储器的一次缺失需要超过100个周期的成本，而且L2中的平均数据觖失率达4%，所以L3的重要性就不言而喻了。如果没有L3，并假定一半指令是载入或存储指令，L2缓存缺失会使CPI增加每条指令2个周期！作为对比，L3的平均数据缺失率为1%，仍然非常显眼，但只有L2缺失率的1/4，是L1缺失率的1/6。

指令级并行及其开发

指令级并行

大约1985年之后的所有处理器都使用流水线来重叠指令的执行过程，以提高性能。由于指令可以并行执行，所以指令之间可能实现的这种重叠称为指令级并行（ILP）。在本章中，我们将研究一系 列通过提高指令并行度来扩展基本流水线概念的技术。本章首先研究数据和控制冒险带来的局限性，然后再转而讨论如何提高编译器和处理器对并行的开发能力。

ILP大体有两种不同开发方法:

1. 依靠硬件来帮助动态发现和开发并行；
2. 依靠软件技术在编译时静态发现并行；

什么是指令级并行

这一章的所有技术都是开发指令间的并行。基本块（一段顺序执行代码，除入口外没有其他转入分支，除出口外没有其他转出分支）中可以利用的并行数非常有限。对于典型的MIPS程序，平均动态分支频率通常介于15%到25%之间，也就是说在一对分支之间会执行3~6条指令。由于这些指令可能相互依赖，所以在基本块中可以开发的重叠数量可能要少于基本块的平均大小。为了真正地提高性能，我们必须跨越多个基本块开发ILP。提高ILP的最简单、最常见方法是在循环的各次迭代之间开发并行。这种并行经常被称作循环级并行。

下面是一个简单的循环示例，它对两个分别有1000个元素的数组求和，完全可以并行实现：

1
2

for (i=0; i<=999; =i+1)
    x[i] = x[i] + y[i];

这个循环的每次迭代都可以与任意其他迭代重叠，当然，在每次循环迭代中进行重叠的机会不大，甚至没有这种机会。我们将研究大量将这种循环级并行转换为指令级并行的技术。这些技术的工作方式基本上都是采用编译器静态展开循环或者利用硬件动态展开循环。开发循环级并行的一种重要替代方法是使用向量处理器和图形处理器中的SIMD。SIMD指令在开发数据级并行时，并行处理少量到中等数量的数据项。而向量指令在开发数据级并行时，则通过使用并行执行单元和深流水线，并行处理许多数据项。例如，上述代码序列的简单形式在每次迭代中需要7条指令（2次载入、1次求和、1次存储、2次地址更新和1次分支），总共7000条指令，而在每条指令可以处理4个数据项的某种SIMD体系结构中，只需要四分之一的指令就能完成任务。在一些向量处理器中，这个序列可能只需要4条指令：2条指令用于从存储器中载入向量x和y, 1条指令用于对两个向量求和，还有1条指令用于将结果向量存回存储器。当然，这些指令可以是流水化的，其延迟相对较长，但可以对这些延迟进行重叠。

数据相关与冒险

要确定一个程序中可以存在多少并行以及如何开发并行，判断指令之间的相互依赖性是至关重要的。具体来说，为了开发指令级并行，我们必须判断哪些指令可以并行执行。如果两条指令是并行的，只要流水线有足够资源（因而也就不存在任何结构性冒险），就可以在一个任意深度的流水线中同时执行它们，不会导致任何停顿。如果两条指令是相关的，它们就不是并行的，尽管它们通常可以部分重叠，但必须按顺序执行。这两种情景的关键在于判断一条指令是否依赖于另一指令。

数据相关

共有3种不同类型的相关:数据相关（也称为真数据相关）、名称相关和控制相关。如果以下任一条件成立，则说指令j数据相关于指令i：

• 指令i生成的结果可能会被指令j用到；
• 指令j数据相关于指令k，指令k数据相关于指令i。

第二个条件就是说：如果两条指令之间存在第一类型的相关链，那么这两条指令也是相关的。这种相关链可以很长，贯穿整个程序。注意，单条指令内部的相关性（比如ADDD RI, R1, R1）不认为是相关。例如，考虑以下MIPS代码序列，它用寄存器F2中的一个标量来递增存储器中的一个值向量（从0(R1)开始，最后一个元素是B(R2)）。

1
2
3
4
5

Loop:   L.D F0,0(R1)     ;F0=数组元素
        ADD.D F4,F0,F2   ;加上F2中的标量
        S.D F4,0(R1)     ;存储结果
        DADDUI R1,R1,#-8 ;使指针递减8个字节
        BNE R1,R2 ,LOOP  ;R1!=R2 时跳转

1
2
3

Loop:   L.D F0,0(R1)     ;F0=数组元素
        ADD.D F4,F0,F2   ;加上F2中的标量
        S.D F4,0(R1)     ;存储结果

1
2
3

DADDIU R1,R1,#-8 ;使指针递减 8个字节
                 ;(每个DW)
BNE R1 ,R2 ,Loop ;R1!=R2 时跳转

相关是程序的一种属性。某种给定相关是否会导致检测到实际冒险，这一冒险又是否会实际导致停顿，这都属于流水线结构的性质。这一区别对于理解如何开发指令级并行至关重要。数据相关传递了三点信息：

1. 冒险的可能性
2. 计算结果必须遵循的顺序
3. 可开发并行度的上限

由于数据相关可能会限制我们能够开发的指令级并行数目，所以本章的一个重点就是如何克服这些局限性。可以采用两种不同方法来克服相关性:

• 保护相关性但避免冒险；
• 通过转换代码来消除相关性。

对代码进行调度是在不修改相关性的情况下避免冒险的主要方法，这种调度既可以由编译器完成，也可以由硬件完成。数据值既可以通过寄存器也可以通过存储器位置在指令之间传送。当数据传送在寄存器中发生时，由于指令中的寄存器名字是固定的，所以相关性的检测很简单，当然，如果存在分支干扰以及为了保持正确性而迫使编译器或硬件变得保守，那可能会变得复杂些。当数据在存储器位置之间流动时，由于两个看起来不同的地址可能引用同一位置，所以其相关性更难以检测，比如100(R4)和20(R6)可能是同一个存储器地址。

此外，载入指令或存储指令的实际地址可能会在每次执行时发生变化（所以20(R4)和20(R4)可能是不一样的），这使相关性的检测进一步复杂化。本章研究采用硬件来检测那些涉及存储器位置的数据相关，但我们将会看到，这些技术也有局限性。用于检测这些相关的编译器技术是揭示循环级别并行的关键所在。

名称相关

第二种相关称为名称相关。当两条指令使用相同的寄存器或存储器位置（称为名称），但与该名称相关的指令之间并没有数据流动时，就会发生名称相关。在指令i和指令j（按照程序顺序，指令i位于指令j之前）之间存在两种类型的名称相关。

(1)当指令j对指令i读取的寄存器或存储器位置执行写操作时就会在指令i和指令j之间发生反相关。为了确保i能读取到正确取值，必须保持原来的顺序。在前面的例子中，S.D和DADDIU之间存在关于寄存器R1的反相关。

(2)当指令i和指令j对同一个寄存器或存储器位置执行写操作时，发生输出相关。为了确保最后写入的值与指令j相对应，必须保持指令之间的排序。

由于没有在指令之间传递值，所以反相关和输出相关都是名称相关，与真数据相关相对。因为名称相关不是真正的相关，因此，如果改变这些指令中使用的名称（寄存器号或存储器位置），使这些指令不再冲突，那名称相关中涉及的指令就可以同时执行，或者重新排序。对于寄存器操作数，这一重命名操作更容易实现，这种操作称作寄存器重命名。寄存器重命名既可以由编译器静态完成，也可以由硬件动态完成。在介绍因分支导致的相关性之前，先让我们来看看相关与流水线数据冒险之间的关系。

数据冒险

只要指令间存在名称相关或数据相关，而且它们非常接近，足以使执行期间的重叠改变对相关操作数的访问顺序，那就会存在冒险。由于存在相关，必须保持程序顺序，也就是由原来的源程序决定的指令执行顺序。软、硬件技术的目的都是尽量开发并行方式，仅在程序顺序会影响程序输出时才保持程序顺序。检测和避免冒险可以确保不会打乱必要的程序顺序。根据指令中读、写访问的顺序，可以将数据冒险分为三类。根据惯例，一般按照流水线必须保持的程序顺序为这些冒险命名。考虑两条指令i和j，其中i根据程序顺序排在j的前面。可能出现的数据冒险为:

• RAW（写后读）——j试图在i写入一个源位置之前读取它，所以j会错误地获得i旧值。这一冒险是最常见的类型，与真数据相关相对应。为了确保j会收到来自i的值，必须保持程序顺序。
• WAW（写后写）——j试图在i写一个操作数之前写该操作数。这些写操作最终将以错误顺序执行，最后留在目标位置的是由i写入的值，而不是由j写入的值。这种冒险与输出相关相对应。只有允许在多个流水级进行写操作的流水线中，或者在前一指令停顿时允许后一指令继续执行的流水线中，才会存在WAW冒险。
• WAR（读后写）——j尝试在i读取一个目标位置之前写入该位置，所以i会错误地获取新值。这一冒险源于反相关（或名称相关）。在大多数静态发射流水线中（即使是较深的流水线或者浮点流水线），由于所有读取操作都较早进行，所有写操作都要晚一些，所以不会发生WAR冒险。如果有一些指令在指令流水线中提前写出结果，而其他指令在流水线的后期读取一个源位置，或者在对指令进行重新排序时，就会发生WAR冒险，在本章后面将对此进行讨论。注意，RAR（读后读）情况不是冒险。

控制相关

最后一种相关是控制相关。控制相关决定了指令i相对于分支指令的顺序，使指令i按正确程序顺序执行，而且只会在应当执行时执行。除了程序中第一基本块中的指令之外，其他所有指令都与某组分支存在控制相关，一般来说，为了保持程序顺序，必须保留这些控制相关。控制相关的最简单示例就是分支中if语句的then部分中的语句。例如，在以下代码段中:

1
2
3
4
5
6

if p1 {
    S1;
};
if p2 {
    S2;
}

一般来说，控制相关会施加下述两条约束条件。

• 如果一条指令与一个分支控制相关，那就不能把这个指令移到这个分支之前，使它的执行不再受控于这个分支。例如，不能把if语句then部分中的一条指令拿出来，移到这个if语句的前面。
• 如果一条指令与一个分支没有控制相关，那就不能把这个指令移到这个分支之后，使其执行受控于这个分支。例如，不能将if之前的一个语句移到它的then部分。

在不影响程序正确性的情况下，我们可能希望执行一些还不应当执行的指令，从而会违犯控制相关。因此，控制相关并不是一个必须保持的关键特性。有两个特性对程序正确性是至关重要的，即异常行为和数据流，通常保持数据相关与控制相关也就保护了这两种特性。保护异步行为意味着对指令执行顺序的任何改变都不能改变程序中激发异常的方式。通常会放松这一约束条件，要求改变指令的执行顺序时不得导致程序中生成任何新异常。下面的简单示例说明维护控制相关和数据相关是如何防止出现这类情景的。考虑以下代码序列:

1
2
3
4

DADDU R2, R3, R4
BEQZ  R2,L1
LW    R1 ,0(R2)
L1:

通过维护数据相关和控制相关来保护的第二个特性是数据流。数据流是指数据值在生成结果成和使用结果的指令之间进行的实际流动。分支允许一条给定指令从多个不同地方获取源数据，从而使数据流变为动态的。换种说法，由于一条指令可能会与之前的多条指令存在数据相关性，所以仅保持数据相关是不够的。一条指令的数据值究竟由之前哪条指令提供，是由程序顺序决定的。而程序顺序是通过维护控制相关来保证的。

例如，考虑以下代码段:

1
2
3
4
5

    DADDU R1,R2,R3
    BEQZ  R4,L
    DSUBU R1,R5,R6
L:  
    OR    R7,R1,R8

在执行这些指令时，还必须保持数据流：如果没有进行分支转移，那么由DSUBU计算的R1值应当由OR使用；如果进行了分支转移，由DADDU计算的R1值则应当由OR使用。通过保持分支中OR的控制相关，就能防止非法修改数据流。出于类似原因，DSUBU指令也不能移到分支之前。推测不但可以帮助解决异常问题，还能在仍然保持数据流的同时降低控制相关的影响。

有些情况下，我们可以断定违犯控制相关并不会影响异常行为或数据流。考虑以下代码序列：

1
2
3
4
5
6

    DADDU R1,R2,R3
    BEQZ  R12,skip
    DSUBU R4, R5,R6.
    DADDU R5,R4,R9
skip:
    OR R7 ,R8,R9

如果进行了分支转移，将会执行DSUBU指令，之后不再有用，但这样仍然不会影响程序结果。由于编译器在对分支结果进行猜测，所以这种类型的代码调度也是一种推测形式，通常称为软件推测；在这个例子中，编译器推测通常不会进行分支转移。

对导致控制停顿的控制冒险进行检测，可以保持控制相关。控制停顿可以通过各种软硬件技术加以消除或减少。

揭示ILP的基本编译器技术

这一节研究一些简单的编译器技术，可以用来提高处理器开发ILP的能力。这些技术对于使用静态发射或静态调度的处理器非常重要。有了这一编译器技术，稍后将会研究那些采用静态发射的处理器的设计与性能。

基本流水线调度和循环展开

为使流水线保持满载，必须找出可以在流水线中重叠的不相关指令序列，充分开发指令并行。为了避免流水线停顿，必须将相关指令与源指令的执行隔开一定的时间周期，这一间隔应当等于源指令的流水线延迟。编译器执行这种调度的能力既依赖于程序中可用ILP的数目，也依赖于流水线中功能单元的延迟。表3-2给出了在本章采用的FP单元延迟，如果偶尔采用不同延迟，会另行明确说明。假定采用一个标准的5级整数流水线，所以分支的延迟为一个时钟周期。假定这些功能单元被完全流水化或复制，所以在每个时钟周期可以发射任何一个类型的指令，不存在结构冒险。

最后一列是为了避免停顿而需要插入的时钟周期数。这些数字与我们在FP单元上看到的平均延迟类似。由于可以旁路载入指令的结果，不会使存储指令停顿，所以浮点载入指令对载入指令的延迟为0。我们还假定整数载入延迟为1，整数ALU操作延迟为0。

在这一小节，我们将研究编译器如何通过转换循环来提高可用ILP的数目。我们的讨论将就以下代码段展开，它将对一个标量和一个向量求和：

1
2

for (i = 999; i >= 0; i = i - 1)
    x[1] = x[i] + s;

注意，这个循环的每个迭代体都是相互独立的，从而可以看出这个循环是并行的。首先来看这个循环的性能，说明如何利用并行来提高一个MIPS流水线的性能（采用以上所示的延迟值）。第一步是将以上代码段转换为MIPS汇编语言。在以下代码段中，R1 最初是数组元素的最高地址，F2 包含标量值s。寄存器R2的值预先计算得出，使8(R2)成为最后一个进行运算的元素的地址。

这段简单的MIPS代码应当类似如下所示(未针对流水线进行调度):

1
2
3
4
5
6

Loop:   L.D    F0,0(R1)  ;F0=数组元素
        ADD.D  F4,F0,F2  ;加上F2中的标量
        S. D   F4,0(R1)  ;存储结果
        DADDUI RI,R1,#-8 ;使指针逐减8个字节
                         ;(每个DW)
        BNE    R1,R2,Loop;R1!=R2时跳转

首先来看看在针对MIPS的简单流水线上调度这个循环时的执行情况。

写出在进行调度与不进行调度的情况下，这个循环在MIPS上的执行过程，包括所有停顿或空闲时钟周期。调度时要考虑浮点运算产生的延迟，但忽略延迟分支。

在不进行任何调度时，循环的执行过程如下，共花费9个周期：

1
2
3
4
5
6
7
8
9
10

                       发射的时钟周期
Loop:   L. D   F0,0(RI)      1
        停顿                 2
        ADD.D  F4,F0,F2      3
        停顿
        停顿
        S,D    F4,0(R1)      6
        DADDUI R1,R1,#-8     7
        停顿                 8
        BNE    R1. ,R2,Loop  9

1
2
3
4
5
6
7

Loop:   L.D      F0,0(R1)
        DADDUI   R1,R1.#-8
        ADD.D    F4,F0,F2
        停顿
        停顿
        S.D      F4,8(R1)
        BNE      R1,R2, Loop

在上面这个例子中，每7个时钟周期完成一次循环迭代，并存回一个数组元素，但对数组元索进行的实际运算仅占用这7个时钟周期中的3个（载入、求和与存储）。其余4个时钟周期包括循环开销（DADDUI和BNE）和2次停顿。为了消除这4个时钟周期，需要使循环体中的运算指令数多于开销指令数。

要提高运算指令相对于分支和开销指令的数目，一种简单的方案是循环展开。展开就是将循环体复制多次，调整循环的终止代码。

循环展开还可用于提高调度效率。由于它消除了分支，因此可以将来自不同迭代的指令放在一起调度。在这个例子中，我们通过在循环体内创建更多的独立指令来消除数据使用停顿。如果在展开循环时只是简单地复制这些指令，最后使用的都是同一组寄存器，所以可能会妨碍对循环的有效调度。因此，我们希望为每次迭代使用不同寄存器，这就需要增加寄存器的数目。

展开以上循环，使其包含循环体的4个副本，假定R1-R2（即数组的大小）最初是32的倍数，也就是说循环迭代的数目是4的倍数。消除任何明显的冗余计算，不要重复使用任何寄存器。

合并DADDUI指令，删除在展开期间重复的非必需BNE运算，得到的结果如下。注意，现在必须对R2进行置位，使32（R2）成为后4个元素的起始地址。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Loop:   L.D      F0,0(R1)
        ADD.D    F4,F0,F2
        S.D      F4,0(R1)    ;删除DADDUI和BNE
        L.D      F6,-8(R1)
        ADD.D    F8,F6,F2
        S.D      F8,-8(R1)   ;删除DADDUI和BNE 
        L.D      F10,-16(R1) 
        ADD.D    F12,F10,F2 
        S.D      F12,-16(R1) ;删除DADDUI和BNE
        L.D      F14,-24(R1}
        ADD.D    F16,F14,F2
        S.D      F16,-24(R1)
        DADDUI   R1,R1,#-32
        BNE      R1,R2, LOOP

在实际程序中，人们通常不知道循环的上限。假定此上限为n，我们希望展开循环，制作循环体的k个副本。我们生成的是一对连续循环，而不是单个展开后的循环。第一个循环执行(n mod k)次，其主体就是原来的循环。第二个循环是由外层循环包围的展开循环，迭代(n/k)次。当n值较大时，大多数执行时间都花费在未展开的循环体上。在前面的例子中，通过展开消除了开销指令，尽管这样会显著增大代码规模，但却可以提高这一循环的性能。如果针对先前介绍的流水线来调度展开后的循环，它的执行情况又会如何呢?

针对具有表3-2 所示延迟的流水线，调度前面例子中展开后的循环，写出其执行情况。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Loop:   L.D         F0,0(R1)
        L.D         F6,-8{R1)
        L.D         F10,-16(R1}
        L.D         F14,-24{R1)
        ADD.D       F4,F0,F2
        ADD.D       F8,F6,F2
        ADD.D       F12,F10,F2
        ADD.D       F16,F14,F2
        S.D         F4,0(R1)
        S.D         F8,-8(R1)
        DADDUI      R1,R1,#-32
        S.D         F12,16(R1)  
        S.D         F16,8(R1)
        BNE         R1,R2, Loop

展开后循环的执行时间已经缩减到总共14个时钟周期，或者说每个元素需要3.5个时钟周期，而在未进行任何展开或调度之前为每个元素9个时钟周期，进行调度但未展开时为7个周期。对展开循环进行调度所获得的收益甚至还会大于对原循环进行调度的收益。之所以会这样，是因为展开后的循环暴露了更多可以进行调度的计算，从而可以将停顿时间减至最低；上述代码中就没有任何停顿。要以这种方式调度循环，必须意识到载入指令和存储指令是不相关的，可以交换位置。

循环展开与调度小结

在本章中，我们将会研究各种可以利用指令级并行的硬件与软件技术，以充分发挥处理器中各功能单元的潜力。大多数此类技术的关键在于判断何时能够改变指令顺序以及如何改变。我们的例子中进行了许多此类改变，对于人类来说，可以很容易地判断出是可以进行此类改变的。而在实践中，这一过程必须采用系统方式，由编译器或硬件来完成。为了获得最终展开后的代码，必须进行如下决策和变换。

• 确认循环迭代不相关（循环维护代码除外），判定展开循环是有用的。
• 使用不同寄存器，以避免由于不同运算使用相同寄存器而施加的非必要约束（比如，名称相关）。
• 去除多余的测试和分支指令，并调整循环终止与迭代代码。
• 观察不同迭代中的载入与存储指令互不相关，判定展开后的循环中的载入和存储指令可以交换位置。这一变换需要分析存储器地址，查明它们没有引用同一地址。
• 对代码进行调度，保留任何必要相关，以得到与原代码相同的结果。

要进行所有这些变换，最关键的要求就是要理解指令之间的相关依赖关系，而且要知道在这些给定关系下如何改变指令或调整指令的顺序。

有3种不同的效果会限制循环展开带来的好处：

1. 每次展开操作分摊的开销数目降低，
2. 代码规模限制，
3. 编译器限制。

我们首先考虑循环开销问题。如果将循环展开4次，所生成的指令并行足以使循环调度消除所有停顿周期。事实上，在14个时钟周期中，只有2个周期是循环开销：维护索引值的DADDUI和终止循环的BNE。如果将循环展开8次，这一开销将从每次原迭代的1/2周期降低到1/4。对展开的第二个限制是所生成代码规模的增长。对于较大规模的循环，如果代码规模的增长会导致指令缓存缺失率的上升，那就要特别加以关注。还有一个因素通常要比代码大小更为重要，那就是由于大量进行展开和调试而造成寄存器数量不足。因为在大段代码中进行指令调度而产生的这一副作用被称为寄存器紧缺。它的出现是因为在为了提高ILP而调试代码时，导致存活值的数目增加。在大量进行指令调度之后，可能无法将所有存活值都分配到寄存器中。尽管转换后的代码在理论上可以提高运行速度，但由于它会造成寄存器短缺，所以可能会损失部分乃至全部收益。在没有展开循环时，分支就足以限制调度的大量使用，所以寄存器紧缺几乎不会成为问题。但是，循环展开与大量调度的综合应用却可能导致这一问题。 在多发射处理器中需要公开更多可以重叠执行的独立指令序列，上述问题可能变得尤其困难。一般来说， 高级复杂转换的应用已经导致现代编译器的复杂度大幅增加，而在生成具体代码之前，很难衡量这种应用带来的潜在改进。

直行代码段可以进行有效的调度，而循环展开是一种增大直行代码段规模的简单有效方法。这种转换在各种处理器上都非常有用，从我们前面已经研究过的简单流水线，到多发射超标量，再到本章后面要研究的VLIW。

用高级分支预测降低分支成本

由于需要通过分支冒险和停顿来实施控制相关，所以分支会伤害流水线性能。循环展开是降低分支冒险的一种方法，我们还可以通过预测分支的行为方式来降低分支的性能损失。我们将研究一些简单的分支预测器，它们既可能依赖于编译时信息，也可能依赖于在隔离状态下观测到的分支动态行为。随着所用指令数目的增大，更准确的分支预测也变得越来越重要。在本节，我们将研究一些提高动态预测准确度的技术。

相关分支预测

2位预测器方案仅使用单个分支的最近行为来预测该分支的未来行为。如果我们同时还能查看其他分支的最近行为，而不是仅查看要预测的分支，那就有可能提高预测准确度。考虑eqntott基准测试中的一小段代码，这个基准测试是早期SPEC基准测试套件的一个成员，用来显示特别糟糕的分支预测行为:

1
2
3
4
5

if (aa==2)
    aa=0;
if (bb==2)
    bb=0;
if (aa !=bb){

1
2
3
4
5
6
7
8

        DADDIU    R3,R1,#-2
        BNEZ      R3,L1         ;branch b1 (aa!=2)
        DADD      R1,RO,R0      ;aa=0
L1:     DADDIU    R3,R2,#-2    
        BNEZ      R3,L2         ;branch b2 (bb!=2)
        DADD      R2,RO,RO      ;bb=0
L2:     DSUBU     R3,R1,R2      ;R3=aa-bb
        BEQZ      R3,L          ;branch b3 (aa==bb)

我们将这些分支标记为b1、b2和b3。从中可以看出很重要的一点：分支b3的行为与分支b1和b2的行为有关。显然，如果分支b1和b2都未执行转移（即其条件均为真，且aa和bb均被赋值为0），aa 和bb明显相等，所以会进行b3分支转移。如果预测器仅利用一个分支的行为来预测分支结果，那显然不会捕获到这一行为。利用其他分支行为来进行预测的分支预测器称为相关预测或两级预测器。现有相关预测器增加最近分支的行为信息，来决定如何预测一个给定分支。例如，（1,2）预测器在预测一个特定分支时，利用最近一个分支的行为从一对2位分支预测器中进行选择。在一般情况下，（m,n）预测器利用最近m个分支的行为从2^m个分支预测器中进行选择，其中每个预测器都是单个分支的n位预测器。这种相关分支预测器的吸引力在于它的预测率可以高于2位方案，而需要添加的硬件很少。

硬件的这种简易性源自一个简单的观察事实：最近m个分支的全局历史可以记录在m位移位的寄存器中，其中每一位记录是否执行了该分支转移。将分支地址的低位与m位全局历史串联在一起，就可以对分支预测缓冲区进行寻址。例如，在一个共有64项的（2,2）缓冲区中，分支的低4位地址（字地址）和2个全局位（表示最近执行的两个分支的行为）构成一个6位索引，可用来对64个计数器进行寻址。

与标准的2位方案相比，相关分支预测器的性能可以提高多少呢?为了进行公平对比，进行比较的预测器必须使用相同数目的状态位。一个(m,n)预测器的位数为:

1

2^m * n *由分支地址选中的预测项数目

没有全局历史的2位预测器就是(0,2)预测器。

在具有4K项的(0,2)分支预测器中有多少位?在具有同样位数的(2,2)预测器中有多少项?

具有4K项的预测器拥有:

1

2^0 * 2 * 4K = 8K位

1

2^2 * 2 * 由分支选中的预测项数=8K

图3-1对比了前面具有4K项的(0,2)预测器与具有1K项的(2,2)预测器的错误预测率。可以看出，这种相关预测器的性能不但优于具有相同状态位数的简单2位预测器，还经常会优于具有无限项数的2位预测器。

2位预测器的对比。第一个是4096位的非相关预测器，然后是具有无限数目的非相关2位预测器，和一个具有2位全局历史和总共1024项的2位预测器。尽管这些数据是从SPEC的较早版本获取的，但最近SPEC基准测试的数据也显示了类似的准确度差异。

竞赛预测器: 局部预测器与全局预测器的自适应联合

采用相关分支预测器主是要因为观察到：仅使用局部信息的标准2位预测器无法预测某些重要分支，而通过增加全局信息就可以提升性能。竞赛预测器更进一步，采用了多个预测器，通常是一个基于全局信息的预测器和一个基于局部信息的预测器，用选择器将它们结合起来。竞赛预测器既可以以中等规模的预测位（8K~32K位）实现更好的预测准确度，还可以更有效地利用超大量预测位。现有竞赛预测器为每个分支使用一个2位饱和预测器，根据哪种预测器（局部、全局，甚至包括两者的组合方式）在最近的预测中最为有效，从两个不同预测器中进行选择。在简单的2位预测器中，饱和计数器要在两次预测错误之后才会改变优选预测器的身份。

竞赛预测器的优势在于它能够为特定分支选择正确的预测器，这一点对于整数基准测试尤为重要。对于SPEC整数基准测试，典型竞赛预测器为其选择全局预测器的概率大约为40%，而对于SPECFP基准测试，则少于15%。除了在竞赛预测器方面走在前列的Alpha处理器之外，最近的AMD处理器，包括Opteron和Phenom，都已经采用了竞赛类型的预测器。图3-2以SPEC89为基准测试，研究三种不同预测器：一个局部2位预测器、一个相关预测器和竞赛预测器，在不同位数时的性能。和我们前面曾经看到的一样，局部预测器的预测性能改进不会超出一定的范围。相关预测器的改进非常突出，竞赛预测器的性能稍好一些。对于SPEC的最新版本，其结果是类似的，但需要采用稍大些的预测器规模才能达到渐趋一致的行为。

图3-2在总位数升高时，3种不同预测器运行SPEC89的错误预测率。这些预测器包括：一个局部2位预测器；一个相关预测器；针对图中每一点的全局和局部信息采用了结构优化；一个竞赛预测器。尽管这些数据是从SPEC的较早版本获取的，但最近SPEC基准测试的数据也显示了类似行为，当预测器规模稍大时，可能趋于一个渐近值

局部预测器包括一个两级预测器。顶级是一个局部历史表，包括1024个10位项；每个10位项对应这一项最近10个分支输出。即，如果这个分支被选中10次或更多次，那么这个局部历史表中的相应项都是1。如果这个分支被交替选中和未选中，那么历史项中则包括交替的0和1。这个10位历史信息最多可以发现和预测10个分支。局部历史表的选定项用来对一个拥有1K项的表进行索引，这个表由3位饱和计数器组成，可以提供局部预测。这种组合共使用29K位，可以提高分支预测的准确度。

Intel Core i7分支预测器

关于Core i7的分支预测器，Intel 只发布了非常有限的信息，这种预测器是以Core Duo芯片中使用的较早预测器为基础。i7 使用了一个两级预测器，它的第一级预测器较小, 设计用来满足周期约束条件：每个时钟周期预测一个分支，还有一个较大的二级预测器作为备份。每个预测器都组合了3个不同预测器：(1)简单的两位预测器；(2)全局历史预测器，类似于我们刚刚看到的预测器；(3)循环退出预测器。对于一个被检测为循环分支的分支，循环退出预测器使用计数器来预测被选中分支的确切数目（也就是循环迭代的数目）。对于每个分支，通过跟踪每种预测的准确度从3个预测器中选择最佳预测，就像一个竞赛预测器。除了这一多级主预测器之外，还有一个独立单元为间接分支预测目标地址，还使用了栈来预测返回地址。

和在其他情景中一样，推测在评估预测器方面也导致了一些难题，这是因为对一个分支的错误预测很容易导致提取和错误预测另一个分支。为了使事情变得简单一些，我们看一下错误预测数占成功完成分支数（这些分支不是推测错误导致的结果）的百分比。图3-3显示了19个SPECCPU 2006基准测试的数据。这些基准测试明显大于SPEC89或SPEC2000，其结果是：即使更精心地组合应用预测器，其错误预测率也只是稍大于图3-2中所示数据。由于分支预测错误会导致推测效率低下，所以它会导致一些无效工作，在本章后面将会了解到这一点。

图3-3 19 个SPECCPU2006基准测试错误预测数占成功完成分支数的比例，整数基准测试的平均值稍高于FP（4%对3%）。更重要的是，某些基准测试的错误率高出很多

用动态调度克服数据冒险

除非是流水线中的已有指令与要提取的指令之间存在数据相关，而且无法通过旁路或转发来隐藏这一数据相关，否则，简单的静态调度流水线就会提取一条指令并发射出去。（转发逻辑可以减少实际流水线延迟，所以某些特定的相关不会导致冒险）如果存在不能隐藏的数据相关，那些冒险检测软件会从使用该结果的指令开始，将流水线置于停顿状态。在清除这一相关之前，不会提取和发射新的指令。

本节将研究动态调度，在这种调度方式中，硬件会重新安排指令的执行顺序以减少停顿，并同时保持数据流和异常行为。动态调度有几个优点。

• 第一，它允许针对一种流水线编译的代码在不同流水线上高效执行，不需要在使用不同微体系结构时重新进行编译，并拥有多个二进制文件。
• 第二，在某些情况下，在编译代码时还不能知道相关性，利用动态调度可以处理某些此类情况；比如，这些相关可能涉及存储器引用或者与数据有关的分支，或者，它们可能源自使用动态链接或动态分发的现代编程环境。
• 第三，也可能是最重要的一个优点，它允许处理器容忍些预料之外的延迟，比如缓存缺失，它可以在等待解决缺失问题时执行其他代码。

在3.6节，我们将研究以动态调度为基础的硬件推测，这一技术还有更多性能方面的优势。我们将会看到，动态调度的好处是以硬件复杂度的显著提高为代价的。尽管动态调度的处理器不能改变数据流，但它会在存在相关性时尽力避免停顿。相反，由编译器调度的静态流水线也会尽力将停顿时间降至最低，具体方法是隔离相关指令，使它们不会导致冒险。当然，对于那些本来准备在采用动态调度流水线的处理器上运行的代码，也可以使用编译器流水线调度。

动态调度: 思想

简单流水线技术的一个主要限制是它们使用循序指令发射与执行：指令按程序顺序发射，如果一条指令停顿在流水线中，后续指令都不能继续进行。因此，如果流水线中两条相距很近的指令存在相关性，就会导致冒险和停顿。如果存在多个功能单元，这些单元也可能处于空闲状态。如果指令j依赖于长时间运行的指令i（当前正在流水线中执行），那么j之后的所有指令都必须停顿，直到i完成、j可以执行为止。例如，考虑以下代码:

1
2
3

DIV.D     F0, F2,F4
ADD.D     F10,F0,F8
SUB.D     F12,F8,F14

为了能够开始执行上面例子中的SUB.D，必须将发射过程分为两个部分：检查所有结构冒险和等待数据冒险的消失。因此，我们仍然使用循序指令发射（即，按程序顺序发射指令），但我们希望一条指令能够在其数据操作数可用时立即开始执行。这样一种流水线实际是乱序执行，也就意味着乱序完成。

乱序执行就可能导致WAR和WAW冒险，在这个五级整数流水线及其循序浮点流水线的逻辑扩展中不存在这些冒险。考虑以下MIPS浮点代码序列：

1
2
3
4

DIV.D    F0,F2,F4
ADD.D    F6,F0,F8
SUB.D    F8,F10,F14
MUL.D    F6,F10,F8

乱序完成还会使异常处理变得复杂。采用乱序完成的动态调度必须保持异常行为，使那些在严格按照程序顺序执行程序时会发生的异常仍然会实际发生，也不会发生其他异常。动态调度处理器会推迟发布相关异常的发布，一直等到处理器知道该指令就是接下来要完成的指令为止，通过这一方式来保持异常行为。

尽管异常行为必须保持，但动态调度处理器可能生成一些非精确异常。如果在发生异常时，处理器的状态与严格按照程序顺序执行指令时的状态不完全一致，那就说这一异常是非精确的。非精确异常可以因为以下两种可能性而发生。

1. 流水线在执行导致异常的指令时，可能已经完成了按照程序顺序排在这一指令之后的指令。
2. 流水线在执行导致异常的指令时，可能还没有完成按照程序顺序排在这一指令之前的指令。

非精确异常增大了在异常之后重新开始执行的难度。我们在这一节不会解决这些问题，而是讨论一种解决方案，能够在具有推测功能的处理器环境中提供精确异常。对于浮点异常，已经采用了其他解决方案。

为了能够进行乱序执行，我们将五级简单流水线的ID流水级大体分为以下两个阶段。

1. 发射：译码指令，检查结构性冒险。
2. 读操作数：直等到没有数据冒险，然后读取操作数。

指令提取阶段位于发射阶段之前，既可以把指令放到指令寄存器中，也可能放到一个待完成指令队列中；然后从寄存器或队列发射这些指令。执行阶段跟在读操作数阶段之后，这一点和五级流水线中一样。执行过程可能需要多个周期，具体数目取决于所执行的操作。

我们区分一个指令开始执行和完成执行的时刻，在这两个时刻之间，指令处于执行过程中。我们的流水线允许同时执行多条指令，没有这一功能，就会失去动态调度的主要优势。要同时执行多条执行，需要有多个功能单元、流水化功能单元，或者同时需要这两者。由于这两种功能（流水化功能单元和多个功能单元）在流水线控制方面大体相当，所以我们假定处理器拥有多个功能单元。

在动态调度流水线中，所有指令都循序经历发射阶段（循序发射）；但是，它们可能在第二阶段（读操作数阶段）停顿或者相互旁路，从而进行乱序执行状态。记分板技术允许在有足够资源和没有数据相关时乱序执行指令。这里重点介绍一种名为Tomasulo算法的更高级技术。它们之间的主要区别于Tomasulo算法通过对寄存器进行有效动态重命名来处理反相关和输出相关。

此外，还可以对Tomasulo算法进行扩展，用来处理推测，这种技术通过预测一个分支的输出、执行预测目标地址的指令、当预测错误时采取纠正措施，从而降低控制相关的影响。使用记分板可能足以支持诸如ARM A8之类的简单两发射超标量处理器，而诸如四发射Intel i7之类更具主动性的处理器则受益于乱序执行的使用。

使用Tomasulo算法进行动态调度

IBM 360/91浮点单元使用一种支持乱序执行的高级方案。这一方案由Robert Tomasulo发明，它会跟踪指令的操作数何时可用，将RAW冒险降至最低，并在硬件中引入寄存器重命名功能，将WAW和WAR冒险降至最低。在现代处理器中存在这一方案的许多变体，但跟踪指令相关以允许在操作数可用时立即执行指令、重命名寄存器以避免WAR和WAW冒险，这些核心概念仍然是它们的共同特征。

IBM的目标是从指令集出发、从为整个350计算机系列设计的编译器出发来实现高浮点性能，而不是通过采用专门为高端处理器设计的编译器来实现。360体系结构只有4个双精度浮点寄存器，它限制了编译器调度的有效性；这一事实是开发Tomasulo方法的另一个动机。此外，IBM 360/91的内存访问时间和浮点延迟都很长，Tomasulo算法就是设计用来克服这些问题的。在本节的最后，我们将会看到Tomasulo算法还支持重叠执行一个循环的多个迭代。

我们将在MIPS指令集上下文中解释这一算法，重点放在浮点单元和载入-存储单元。MIPS与360之间的主要区别是后者的体系结构中存在寄存器存储器指令。由于Tomasulo算法使用一个载入功能单元，所以添加寄存器-存储器寻址模式并不需要进行大量修改。IBM 360/91还有一点不同，它拥有的是流水化功能单元，而不是多个功能单元，但我们在描述该算法时仍然假定它有多个功能单元。它只是对功能单元进行流水化的概念扩展。

我们将会看到，如果仅在操作数可用时才执行指令，就可以避免RAW冒险，而这正是一些简单记分板方法提供的功能。WAR和WAW冒险（源于名称相关）可以通过寄存器重命名来消除。对所有目标寄存器（包括较早指令正在进行读取或写入的寄存器）进行重命名，使乱序写入不会影响到任何依赖某一操作数较早值的指令，从而消除WAR和WAW冒险。为了更好地理解寄存器重命名如何消除WAR和WAW冒险，考虑以下可能出现WAR和WAW冒险的代码序列示例：

1
2
3
4
5

DIV.D     F0,F2,F4
ADD.D     F6,F0,F8
S.D       F6,0(R1)
SUB.D     F8,F10,F14
MUL.D     F6,F10,F8

这3个名称相关都可以通过寄存器重命名来消除。为简便起见，假定存在两个临时寄存器：S和T。利用S和T，可以对这一序列进行改写，使其没有任何相关，如下所示:

1
2
3
4
5

DIV.D    F0,F2,F4
ADD.D    S,FO,F8
S.D      S, 0(R1)
SUB.D    T,F10,F14
MUL.D    F6,F10,T

在Tomasulo方案中，寄存器重命名功能由保留站提供，保留站会为等待发射的指令缓冲操作数。其基本思想是：保留站在一个操作数可用时马上提取并缓冲它，这样就不再需要从寄存器中获取该操作数。此外，等待执行的指令会指定保留站，为自己提供输入。最后，在对寄存器连续进行写入操作并且重叠执行时，只会实际使用最后一个操作更新寄存器。在发射指令时，会将待用操作数的寄存器说明符更名，改为保留站的名字，这就实现了寄存器重命名功能。

由于保留站的数目可能多于实际寄存器，所以这一技术甚至可以消除因为名称相关而导致的冒险，这类冒险是编译器所无法消除的。使用保留站，而不使用集中式寄存器堆，可以导致另外两个重要特性。

• 冒险检测和执行控制是分布式的：每个功能单元保留站中保存的信息决定了一条指令什么时候可以开始在该单元中执行。
• 结果将直接从缓冲它们的保留站中传递给功能单元，而不需要经过寄存器。这一旁路是使用公共结果总线完成的，它允许同时载入所有等待一个操作数的单元。在具有多个执行单元并且每个时钟周期发射多条指令的流水线中，将需要不止一条总线。

图3-4给出了基于Tomasulo算法的处理器的基本结构，其中包括浮点单元和载入存储单元；所有执行控制表均未显示。每个保留站保存一条已经被发射、正在功能单元等待执行的指令，如果已经计算出这一指令的操作数值，则保留这些操作数值，如果还没有计算出，则保留提供这些操作数值的保留站名称。

使用Tomasulo箅法的MIPS浮点单元的基本结构。指令由指令单元发送给指令队列，再按先入先出（FIFO）顺序从指令队列中发射出去。保留站包括运算和实际操作数，还有用于检测和解决冒险的信息。载入缓冲区有3项功能：

1. 保存有效地址的各个部分，直到计算完成；
2. 跟踪正在等待存储器的未完成载入过程；
3. 保存正在等待总线的已完成载入过程的结果。

与此类似，存储器缓冲区也有3项功能：

1. 保存有效地址的各个部分，直到计算完成；
2. 对于尚未完成、正在等待待存储数据值的存储过程，存储其目标存储器地址；
3. 保存要存储的地址和数据值，直到存储器单元可用为止。

来自FP单元或载入单元的所有结果都被放在CDB中，它会通向FP寄存器堆以及保留站和存储器缓冲区。FP加法器实现加法和减法，FP乘法器完成乘法和除法。

载入缓冲区和存储缓冲区保存来自和进入存储器的数据或地址，其行为方式基本与保留站相同，所以我们仅在必要时才区分它们。浮点寄存器通过一对总线连接到功能单元，由一根总线连接到存储缓冲区。来自功能单元和来自存储器的所有结果都通过公共数据总线发送，它会通向除载入缓冲区之外的所有地方。所有保留站都有标记字段，供流水线控制使用。

在详细描述保留站和此算法之前，让我们看看一条指令所经历的步骤。尽管每条指令现在可能需要任意数目的时钟周期，但一共只有以下3个步骤。

• 发射
  • 从指令队列的头部获取下一条指令，指令队列按FIFO顺序维护，以确保能够保持数据流的正确性。如果有一个匹配保留站为空，则将这条指令发送到这个站中，如果操作数值当前已经存在于寄存器，也一并发送到站中。如果没有空保留站，则存在结构性冒险，该指令会停顿，直到有保留站或缓冲区被释放为止。如果操作数不在寄存器中，则一直跟踪将生成这些操作数的功能单元。这一步骤将对寄存器进行重命名，消除WAR和WAW冒险。（在动态调度处理器中，这一阶段有时被称为分派。）
• 执行
  • 如果还有一个或多个操作数不可用，则在等待计算的同时监视公共数据总线。当一个操作数变为可用时，就将它放到任何一个正在等待它的保留站中。当所有操作数都可用时，则可以在相应功能单元中执行运算。通过延迟指令执行，直到操作数可用为止，可以避免RAW冒险。（一些动态调度处理器将这一步骤称为“发射”，但我们使用“执行”一词。）
  • 注意，在同一时钟周期，同一功能单元可能会有几条指令同时变为就绪状态。尽管独立功能单元可以在同一时钟周期执行不同指令，如果单个功能单元有多条指令准备就绪，那这个单元就必须从这些指令中进行选择。对于浮点保留站，可以任意作出这一选择；但是载入和存储指令可能要更复杂一些。载入和存储指令的执行过程需要两个步骤。第一步是在基址寄存器可用时计算有效地址，然后将有效地址放在载入缓冲区或存储缓冲区中。载入缓冲区中的载入指令在存储器单元可用时立即执行。存储缓冲区中的存储指令等待要存储的值，然后将其发送给存储器单元。邇过有效地址的计算，载入和存储指令保持程序顺序，稍后将会看到，这样有助于通过存储器来避免冒险。
  • 为了保持异常行为，对于任何一条指令，必须要等到根据程序顺序排在这条指令之前的所有分支全部完成之后，才能执行该指令。这一限制保证了在执行期间导致异常的指令实际上已经执行。在使用分支预测的处理器中（就和所有动态调度处理器一样），这意味着处理器在允许分支之后的指令开始执行之前，必须知道分支预测是正确的。如果处理器记录了异常的发生，但没有实际触发，则可以开始执行一条指令，在进入写结果阶段之前没有停顿。后面可以看到，推测提供了一种更灵活、更完整的异常处理方法，所以我会将推后进行这一改进，并说明推测是如何解决这一问题的。
• 写结果
  • 在计算出结果之后，将其写到CDB上，再从CDB传送给寄存器和任意等待这一结果的保留站（包括存储缓冲区）。存储指令一直缓存在存储缓冲区中，直到待存储值和存储地址可用为止，然后在有空闲存储器单元时，立即写入结果。

保留站、寄存器堆和载入存储缓冲区都采用了可以检测和消除冒险的数据结构，根据对象的不同，这些数据结构中的信息也稍有不同。这些标签实际上就是用于重命名的虛拟寄存器扩展集的名字。在这里的例子中，标签字段包含4个数位，用来表示5个保留站之一或5个载入缓冲区之一。后面将会看到，这相当于设定了10个可以指定为结果寄存器的寄存器。在拥有更多真正寄存器的处理器中，我们可能希望重命名能够提供更多的虚拟寄存器。标签字段指出哪个保留站中包含的指令将会生成作为源操作数的结果。

在指令被发射出去并开始等待源操作数之后，将使用一个保留站编号来引用该操作数，这个保留站中保存着将对寄存器进行写操作的指令。如果使用一个未用作保留站编号的值来引用该操作数（比如0），则表明该操作数已经在寄存器中准备就绪。由于保留站的数目多于实际寄存器数目，所以使用保留站编号对结果进行重命名，就可以避免WAW和WAR冒险。在Tomasulo方案中，保留站被用作扩展虚拟寄存器，而其他方法可能使用拥有更多寄存器的寄存器集，也可能使用诸如重排序缓冲区这样的结构。

在Tomasulo方案以及后面将会介绍的支持推测的方法中，结果都是在受保留站监视的总线（CDB）上广播。采用公用结果总线，再由保留站从总线中提取结果，共同实现了静态调度流水线中使用的转发和旁路机制。但在这一做法中，动态调度方案会在源与结果之间引入一个时钟周期的延迟，这是因为要等到“写结果”阶段才能让结果与其应用匹配起来。因此，在动态调度流水线中，在生成结果的指令与使用结果的指令之间至少要比生成该结果的功能单元的延迟长一个时钟周期。

一定别忘了，Tomasulo方案中的标签引用的是将会生成结果的缓冲区或单元；当一条指令发射到保留站之后，寄存器名称将会丢弃。（这是Tomasulo方案与记分板之间的一个关键区别：在记分板中，操作数保存在寄存器中，只有生成结果的指令已经完成、使用结果的指令做好执行准备之后才会读取操作数。）每个保留站有以下7个字段。

• Op——对源操作数S1和S2执行的运算。
• Qj、Qk——将生成相应源操作数的保留站；当取值为0时，表明已经可以在Vj或Vk中获得源操作数，或者不需要源操作数。
• Vj、Vk——源操作数的值。注意，对于每个操作数，V字段和Q字段中只有一个是有效的。对于载入指令，Vk字段用于保存偏移量字段。
• A——用于保存为载入或存储指令计算存储器地址的信息。在开始时，指令的立即数字段存储在这里；在计算地址之后，有效地址存储在这里。
• Busy——指明这个保留站及其相关功能单元正被占用。

寄存器堆有一个字段Qi。

• Qi——一个运算的结果应当存储在这个寄存器中，则Qi是包含此运算的保留站的编号。如果Qi的值为空（或0），则当前没有活动指令正在计算以此寄存器为目的地的结果，也就是说这个值就是寄存器的内容。

载入缓冲区和存储缓冲区各有一个字段A，一旦完成了第一个执行步骤，这个字段中就包含了有效地址的结果。在下一节，我们将首先看一些示例，说明这些机制是如何工作的，然后再详细研究具体算法。

动态调度:示例和算法

在详细研究Tomasulo算法之前，让我们看几个示例，这些示例有助于说明这种算法的工作方式。

对于以下代码序列，写出在仅完成了第一条载入指令并已将其结果写到CDB总线时的信息表:

1
2
3
4
5
6

L.D     F6,32 (R2)
L.D     F2,44(R3)
MUL.D   F0,F2,F4
SUB.D   F8,F2,F6
DIV.D   F10,F0,F6
ADD.D   F6,F8, F2

表3-3用3个表显示了其结果。Add、 Mult和Load之后附加的数字表示保留站的标签——Add1是第一加法单元计算结果的标签。此外，我们还给出了一个指令状态表。之所以列出这个表是为了帮助读者理解这一算法；它不是硬件的实际组成部分，而是由保留站来保存每个已发射运算的状态。

表3-3当所有指令都已经被发射， 但只有第一-条载入指令已经完成而且已将其结果写到CDB时的保留站与寄存器标签。

与先前的较简单方案相比，Tomasulo方案有两点优势：

1. 冒险检测逻辑的分布；
2. 消除了可能产生WAW和WAR冒险的停顿。

第一个优势源于分布式保留站和CDB的使用。如果多条指令正在等待同一个结果，而每条指令的其他操作数均已准备就绪，那么在CDB上广播这一结果就可以同时释放这些指令。如果使用集中式的寄存器堆，这些单元必须在寄存器总线可用时从寄存器中读取自己的结果。

第二个优势（消除WAW和WAR冒险）的实现是利用保留站来重命名寄存器，并在操作数可用时立即将其存储在保留站中。

例如，尽管存在涉及F6的WAR冒险，但表3-3中的代码序列发射了DIV.D和 ADD.D。这一冒险通过两种方法之一消除。第一种方法：如果为DIV. D提供操作数的指令已经完成，则Vk中会存储这个结果，使DIV.D不需要ADD.D就能执行（表中所示的就是这种情况）。另一方面，如果L.D还没有完成，则Qk将指向Load1保留站，DIV.D指令不再依赖于ADD.D。因此，在任一情况下，ADD.D都可以发射并开始执行。在用到DIV.D的结果时，都会指向保留站，使ADD.D能够完成，并将其值存储在寄存器中，不会影响到DIV.D。

稍后将会看到一个消除WAW冒险的例子。但先来看看前面的示例是如何继续执行的。在这个例子以及本章后面的例子中，假定有如下延迟值：载入指令为1个时钟周期，相加指令为2个时钟周期，乘法指令为6个时钟周期，除法指令为12个时钟周期。

对于上例中的同一代码段，给出当MUL.D做好写出结果准备时的状态表。

其结果如表3-4中的3个表格所示。注意，在复制DIV.D的操作数时ADD.D已经完成，所以克服了WAR冒险问题。注意，既然F6的载入操作被延迟，在执行对F6的加法操作时也不会触发WAW冒险。

Tomasulo 算法：细节

表3-5给出了每条指令都必须经历的检查和步骤。前面曾经提到，载入指令和存储指令在进入独立载入或存储缓冲区之前，要经过一个进行有效地址计算的功能单元。载入指令会进入第二执行步骤，以访问存储器，然后进如“写结果”阶段，将来自存储器的值写入寄存器堆以及（或者）任何正在等待的保留站。存储指令在写结果阶段完成其执行，将结果写到存储器中。注意，无论目标是寄存器还是存储器，所有写入操作都在“写结果”阶段发生。这一限制简化了Tomasulo算法，是其扩展到支持推测功能的关键。

对于发射指令，rd是目的地、rs和rt是源寄存器编号、imm是符号扩展立即数字段，r是为指令指定的保留站或缓冲区。RS 是保留站数据结构。FP 单元或载入单元返回的值称为result。RegisterStat是寄存器状态数据结构（不是寄存器堆，寄存器堆应当是Regs[]）。当发射指令，目标寄存器的Qi字段被设置为向其发射该指令的缓冲区或保留站编号。如果操作数巳经存在于寄存器中，就将它们存储在V字段中。否则，设置Q字段，指出将生成源操作数值的保留站。指令将一直在保留站中等待，直到它的两个操作数都可用为止，当Q字段中的取值为0时即表示这一状态。当指令已被发射，或者当这一指令所依赖的指令已经完成并写回结果时，这些Q字段被设置为0。当一条指令执行完毕，并且CDB可用时，它就可以进行写回操作。任何一个缓冲区、寄存器和保留站，只要其Qj或Qk值与完成该指令的保留站相同，都会由CDB更新其取值，并标记Q字段，表明已经接收到这些值。因此，CDB可以在一个时钟周期中向许多目标广播其结果，如果正在等待这一结果的指令已经有了其他操作数，那就都可以在下一个时钟周期开始执行了。载入指令要经历两个执行步骤，存储指令在写结果阶段稍有不同，它们必须在这一阶段等待要存储的值。记住，为了保持异常行为，如果按照排在程序顺序前面的分支还没有完成，就不应允许执行后面的指令。由于在发射阶段之后不再保持任何有关程序顺序的概念，因此，为了实施这一限制，在流水线中还有未完成的分支时，通常不允许任何指令离开发射步骤。

Tomasulo算法: 基于循环的示例

为了理解通过寄存器的动态重命名来消除WAW和WAR胃险的强大威力，我们需要看一个循环。考虑下面的简单序列，将一个数组的元素乘以F2中的标量：

1
2
3
4
5

Loop:   L.D      F0,0(R1)
        MUL. D   F4,F0,F2
        S.D      F4,0(R1)
        DADDIU   R1,R1,-8
        BNE      R1, R2, Loop; branches if R1 | R2

假定已经发射了该循环两个连续迭代中的所有指令，但一个浮点载入存储指令或运算也没有完成。表3-6显示了在此时刻的保留站、寄存器状态表和载入缓冲区与存储缓冲区。（整数ALU运算被忽略，假定预测选中该分支。）一旦系统达到这一状态，如果乘法运算可以在4个时钟周期内完成，则流水线中可以保持该循环的两个副本，CPI接近1.0。在达到稳定状态之前，还需要处理其他一些迭代，延迟为6个时钟周期。这需要有更多的保留站来保存正在运行的指令。在本章后面将会看到，在采用多指令发射对Tomasulo方法进行扩展时，它可以保持每个时钟周期处理一条以上指令的速度。

表3-6 还没有指令完成时，循环的两个活动迭代

乘法器保留站中的项目指出尚未完成的载入指令是操作数来源。存储保留站指出乘法运算的目标位置是待存储值的来源。

只要载入指令和存储指令访问的是不同地址，就可以放心地乱序执行它们。如果载入指令和存储指令访问相同地址，则会出现以下两种情况之一：

• 根据程序顺序，载入指令位于存储指令之前，交换它们会导致WAR冒险;
• 根据程序顺序，存储指令位于载入指令之前，交换它们会导致RAW冒险。

依此类似，交换两个访问同一地址的存储指令会导致WAW冒险。

因此，为了判断在给定时刻是否可以执行一条载入指令，处理器可以检查：根据程序顺序排在该载入指令之前的任何未完成存储指令是否与该载入指令共享相同数据存储器地址。对于存储指令也是如此，如果按照程序顺序排在它前面的载入指令或存储指令与它访问的存储器地址相同，那它必须等到所有这些指令都执行完毕之后才能开始执行。

为了检测此类冒险，处理器必须计算出与任何先前存储器运算有关的数据存储器地址。为了保证处理器拥有所有此类地址，一种简单但不一定最优的方法是按照程序顺序来执行有效地址计算。（实际只需要保持存储及其他存储器引用之间的相对顺序，也就是说，可以随意调整载入指令的顺序。）

首先来考虑载入指令的情况。如果按程序顺序执行有效地址计算，那么当一条载入指令完成有效地址计算时，就可以通过查看所有活动存储缓冲区的A字段来确定是否存在地址冲突。如果载入地址与存储缓冲区中任何活动项目的地址匹配，则在发生冲突的存储指令完成之前，不要将载入指令发送到载入缓冲区。（有些实施方式将要存储的值直接传送给载入指令，减少了因为这一RAW冒险造成的延迟。）

存储指令的工作方式类似，只是因为发生冲突的存储指令不能调整相对于载入或存储指令的顺序，所以处理器必须在载入与存储两个缓冲区中检查是否存在冲突。

如果能够准确预测分支（这是在上一节解决的问题），动态调度流水线可以提供非常高的性能。这种方法的主要缺点在于Tomasulo方案的复杂性，它需要大量硬件。具体来说，每个保留站都必须包含一个必须高速运转的相关缓冲区，还有复杂的控制逻辑。它的性能还可能受到单个CDB的限制。尽管可以增加更多CDB，但每个CDB都必须与每个保留站进行交互，必须在每个保留站为每个CDB配备相关标签匹配硬件。

在Tomasulo方案中，可以组合使用两种不同技术：对体系结构寄存器重命名，提供更大的寄存器集合；缓冲来自寄存器堆的源操作数。源操作数缓冲消除了当操作数在寄存器中可用时出现的WAR冒险。后面将会看到，通过对寄存器重命名，再结合对结果的缓存，直到对寄存器早期数据的引用全部结束，这样也有可能消除WAR冒险。在我们讨论硬件推测时将会用到这一方法。

从20世纪90年代开始在多发射处理器中采用，原因有如下几个。

1. 尽管Tomasulo算法是在缓存出现之前设计的，但缓存的出现以及其固有的不可预测的延迟，已经成为使用动态调度的主要动力之一。乱序执行可以让处理器在等待解决缓存缺失的同时继续执行指令，从而消除了全部或部分缓存缺失代价。
2. 随着处理器的发射功能变得越来越强大，设计人员越来越关注难以调度的代码（比如，大多数非数值代码）的性能，所以诸如寄存器重命名、动态调度和推测等技术变得越来越重要。
3. 无需编译器针对特定流水线结构来编译代码，Tomasulo 算法就能实现高性能。

基于硬件的推测

当我们尝试开发更多指令级并行时，控制相关的维护就会成为一项不断加重的负担。分支预测减少了由于分支导致的直接停顿，但对于每个时钟周期要执行多条指令的处理器来说，仅靠正确地预测分支可能不足以生成期望数量的指令级并行。宽发射处理器可能需要每个时钟周期执行一个分支才能维持最高性能。因此，要开发更多并行，需要我们克服控制相关的局限性。

通过预测分支的输出，然后在假定猜测正确的前提下执行程序，可以克服控制相关问题。这种机制对采用动态调度的分支预测进行了一种虽细微但很重要的扩展。具体来说，通过推测，我们提取、发射和执行指令，就好像分支预测总是正确的；而动态调度只是提取和发射这些指令。当然，我们需要一些机制来处理推测错误的情景。

基于硬件的推测结合了3种关键思想：

1. 用动态分支预测选择要执行哪些指令；
2. 利用推测，可以在解决控制相关问题之前执行指令（能够撤消错误推测序列的影响）；
3. 进行动态调度，以应对基本模块不同组合方式的调度。（与之相对，没有推测的动态调度需要先解析分支才能实际执行后期基本模块的操作，因为只能部分重叠基本模块。）

基于硬件的推测根据预测的数据值流来选择何时执行指令。这种执行程序的方法实际上是一种数据流执行：操作数一旦可用就立即执行运算。

为了扩展Tomasulo算法，使其支持推测，我们必须将指令结果的旁路（以推测方式执行指令时需要这一操作）从一条指令的实际完成操作中分离出来。进行这种分离之后，就可以允许执行一条指令，并将其结果旁路给其他指令，但不允许这条指令执行任何不能撤消的更新操作，直到确认这条指令不再具有不确定性为止。

使用旁路值类似于执行一次推测寄存器读取操作，因为在提供源寄存器值的指令不再具有不确定性之前，我们无法知道它是否提供了正确值。当一个指令不再具有不确定性时，允许它更新寄存器堆或存储器；我们将指令执行序列中的这个附加步骤称为指令提交。实现推测之后的关键思想在于允许指令乱序执行，但强制它们循序提交，以防止在指令提交之前采取任何不可挽回的动作（比如更新状态或激发异常）。因此，当我们添加推测时，需要将完成执行的过程与指令提交区分开来，这是因为指令执行完毕的时间可能远远早于它们做好提交准备的时间。在指令执行序列中添加这一提交阶段需要增加一组硬件缓冲区，用来保存已经完成执行但还没有提交的指令结果。这一硬件缓冲区称为重排序缓冲区，也可用于在可被推测的指令之间传送结果。

重排序缓冲区（ROB）像Tomasulo算法通过保留站扩展寄存器集一样，提供了附加寄存器。ROB会在一定时间内保存指令的结果，这段时间从完成该指令的相关运算算起，到该指令提交完毕为止。因此，ROB是指令的操作数来源，就像Tomasulo算法中的保留站提供操作数一样。

两者之间的关键区别在于：在Tomasulo算法中，一旦一条指令写出其结果之后，任何后续发射的指令都会在寄存器堆中找到该结果。而在采用推测时，寄存器堆要等到指令提交之后才会更新（我们非常确定该指令会被执行）；因此，ROB是在指令执行完毕到指令提交这段时间内提供操作数。ROB类似于Tomasulo 算法中的存储器缓冲区，为简单起见，我们将存储器缓冲区的功能集成到ROB中。

ROB中的每个项目都包含4个字段：指令类型、目的地字段、值字段和就绪字段。指令类型字段指定这个指令是分支（没有目的地结果）、存储指令（含有存储器地址目的地），还是寄存器操作（ALU运算或载入指令，它含有寄存器目的地）。目的地字段提供了应当向其中写入指令结果的寄存器编号（对于载入指令和ALU运算）或存储器地址（对于存储指令）。值字段用于在提交指令之前保存指令结果值。我们稍后将会看到ROB项目的一个例子。最后一个就绪字段指出指令已经完成执行，结果值准备就绪。

图3-5给出包含ROB的处理器的硬件结构。ROB包含存储缓冲区。存储指令仍然分两步执行，但第二步是由指令提交来执行的。尽管保留站的重命名功能由ROB代替，但在发射运算之后仍然需要一个空间来缓冲它们（以及操作数），直到它们开始执行为止。这一功能仍然由保留站提供。由于每条指令在提交之前都在ROB拥有一个位置，所以我们使用ROB项目编号而不是保留站编号来标记结果。这种标记方式要求必须在保留站中跟踪为一条指令分配的 ROB。

图3-5 使用 Tomasulo箅法的FP单元的基本结构，为处理推测而进行了扩展。将此图与实施Tomasulo算法的图3-4对比，主要变化是添加了ROB，去除了存储器缓冲区，后者的功能被集成到ROB中。如果拓宽CDB，以允许每个时钟周期完成多条指令，则可以将这一机制扩展为支持多发射方案

在指令执行时涉及以下4个步骤。

1. 发射——从指令队列获得一条指令。如果存在空保留站而且ROB中有空插槽，则发射该指令；如果寄存器或ROB中已经含有这些操作数，则将其发送到保留站。更新控制项，指明这些缓冲区正在使用中。为该结果分配的ROB项目编号也被发送到保留站，以便在将结果放在CDB上时，可以使用这个编号来标记结果。如果所有保留站都被占满或者ROB被占满，则指令发射过程停顿，直到这两者都有可用项目为止。
2. 执行——如果还有一个或多个操作数不可用，则在等待计算寄存器的同时监视CDB。这一步骤检查RAW冒险。当保留站中拥有这两个操作数时，执行该运算。指令在这一阶段可能占用多个时钟周期，载入操作在这一阶段仍然需要两个步骤。此时执行存储指令只是为了计算有效地址，所以在这一阶段只需要有基址寄存器可用即可。
3. 写结果——当结果可用时，将它写在CDB上（还有在发射指令时发送的ROB标签），并从CDB写到ROB并写到任何等待这一结果的保留站。将保留站标记为可用。对于存储指令需要执行一些特殊操作。如果要存储的值已经准备就绪，则将它写到ROB项目的Value字段，以备存储。如果要存储的值还不可用，CDB必须进行监视，直到该数值被广播时再更新该存储指令ROB项目的Value字段。为简单起见，我们假定这一过程在存储操作的写结果阶段进行；
4. 提交——这是完成指令的最后一个阶段，在此之后将仅留下它的结果。（一些处理器将这一提交阶段称为“完成”或“毕业”。）根据要提交的指令是预测错误的分支、存储指令，或是任意其他指令（正常提交），在提交时共有3种不同的操作序列。当一个指令到达ROB的头部而且其结果出现在缓冲区中，则进行正常提交；此时，处理器用结果更新其寄存器，并从ROB清除该指令。提交存储指令与正常提交类似，但更新的是存储器而不是结果寄存器。当预测错误的分支到达ROB的头部时，它指出推测是错误的。ROB被刷新，执行过程从该分支的后续正常指令处重新开始。如果对该分支的预测正确，则该分支完成提交。

指令一旦提交完毕，它在ROB的相应项将被收回，寄存器或存储器目的地被更新，不再需要ROB项。如果ROB填满，那么只需要停止发射指令，直到有空闲项目为止。下面，我们研究一下这一机制如何处理前面为Tomasulo算法所举的示例。

假定浮点功能单元的延迟与前面示例中相同：加法为2个时钟周期、乘法为6个时钟周期、除法为12个时钟周期。使用下面的代码段（也就是前面用于生成表3-4的代码段），写出当MUL.D做好提交准备时的状态表。

1
2
3
4
5
6

L.D        F6,32(R2)
L.D        F2,44(R3)
MUL.D      F0,F2,F4
SUB.D      F8,F2,F6
DIV.D      F10,F0,F6
ADD.D      F6,F8,F2

MUL.D位于ROB的头部，此处两个L.D指令只是为了便于理解。尽管SUB.D和ADD.D指令的结果已经可用，而且可以用作其他指令的数据源，但它们在MUL.D指令提交之前不会提交。DIV.D正在执行过程中，但由于它的延迟要比MUL.D长，所有不会独自究成。“值”列表示所保存的值；#X格式表示ROB项目X的值字段。重排序缓冲区1和2实际上已经完成，但为了提供更多信息，也一并列在表中。

上面的例子说明了采用推测的处理器与采用动态调度的处理器之间的关键区别。对比表3-7与表3-4中的内容，后者显示的是同一代码序列在采用Tomasulo算法的处理器上的执行情况。关键区别在于：在上面的例子中，MUL.D是排在最前面的未完成指令，它之后的所有指令都不允许完成。而在表3-4中，SUB.D和ADD.D指令也已经完成。

这一区别意味着具有ROB的处理器可以在维持精确中断模式的同时动态执行代码。例如，如果MUL.D指令导致一个中断，我们只需要等待它到达ROB的头部并生成该中断，刷新ROB中的任意其他未完成指令。由于指令提交是按顺序进行的，所以这样会生成一个精确异常。

而在使用Tomasulo算法的例子中，SUB.D和ADD.D指令都可以在MUL.D激发异常之前完成。结果就是寄存器F8和F6（SUB.D和ADD.D指令的目的地）可能被改写，中断可能不准确。

一些用户和架构师认为不准确的浮点异常在高性能处理器中是可接受的，因为程序可能会终止。而其他类型的异常，比如页面错误，由于程序必须在处理此类异常之后透明地恢复执行，所以很难容忍这些异常出现不准确情况。

在循序提交指令时使用ROB，除了支持推测执行之外，还可以提供准确的异常，如下例所示。

考虑前面Tomasulo算法使用的示例，表3-6显示了其执行情况:

1
2
3
4
5
6

Loop:
        L.D      F0,0(R1)
        MUL.D    F4,F0,F2
        S.D      F4,0(R1)
        DADDIU   R1,R1,#-8.
        BNE      R1,R2,Loop   ;branches if R1|R2

表3-8用两个表给出了结果。

由于在提交指令之前，寄存器值和存贮器值都没有实际写入，所以在发射分支预测错误时，处理器可以很轻松地撤销其推测操作。假定在表3-8中第一次没有选中分支BNE。当该分支之前的指令到达ROB的头部之后，直接提交即可；当分支到达缓冲区的头部时，将会清除缓冲区，处理器开始从其他路径提取指令。

在实践中，进行推测的处理器会在错误预测一个分支后尽早恢复。将预测错误的分支之后的所有ROB项目清空，使该分支之前的ROB项目继续执行，并在后续的正确分支处重新开始提取指令，从而完成恢复操作。在推测处理器中，由于错误预测的影响更大一些，所以性能对分支预测也更敏感。因此，分支处理的各个方面（预测准确度、预测错误的检测延迟、预测错误的恢复时间）都变得更为重要。

在处理异常时，要等到做好提交准备时才会识别异常。如果推测的指令产生异常，则将异常记录在ROB中。如果出现分支预测错误，而且指令还没有执行，则在清除ROB时将异常连同指令一直刷新。如果指令到达ROB的头部，我们就知道它不再具有不确定性，应当激发该异常。我们还可以在异常出现之后、所有先前指令都已处理完毕的情况下立即处理异常，但异常要比分支预测错误的处理更难一些，而且由于异常的发生概率要更低一些，所以其重要性也要低一些。

表3-9给出了一条指令的执行步骤，以及为了继续执行这些步骤和要采取的动作而必须满足的条件。我们给出了到提交时才解决预测错误分支时的情景。尽管推测似乎只是对动态调度添加了非常简单的一点儿内容，但通过对比表3-9和表3-5中Tomasulo算法的相应内容，可能看出推测大大增加了控制复杂度。此外，还要记住分支预测也要更复杂一些。

在推测处理器处理存储指令时与Tomasulo算法中有一点非常重要的不同。在Tomasulo算法中，一条存储指令可以在到达“写结果”阶段（确保已经计算出有效地址）且待存储值可用时更新存储器。在推测处理器中，只有当存储指令到达ROB的头部时才能更新存储器。这一区别可以保证当指令不再具有不确定性时才会更新存储器。

表3-9大幅简化了存储指令，在实践中不需要这一简化。表3-9需要存储指令在写结果阶段等待寄存器源操作数，它的值就是要存储的内容；随后将这个值从该存储指令的保留站的Vk字段移到该存储指令ROB项目的“值”字段。但在现实中，待存储值只需要在提交存储指令之前到达即可，可以直接将源指令放到存储指令的ROB项目中。其实现方法为：用硬件来跟踪要存储的源值什么时候在该存储指令的ROB项目中准备就绪，并在每次完成指令时搜索ROB，查看相关存储指令。

对于发射的指令，rd为目的地、rs和rt为源、r为分配的保留站、b是分配的ROB项目、h是ROB的头项目。RS是保留站数据结构。保留站返回的值被称为result。RegisterStat 是寄存器数据结构，Regs表示实际寄存器，ROB是重排序缓冲区数据结构。

这一补充并不复杂，但添加之后有两个效果：需要向ROB中添加一个字段，表3-9尽管已经采用了小字体，但仍然会变得更长!尽管表3-9进行了简化，但在本示例中，我们将允许该存储指令跳过写结果阶段，只需要在准备提交前得到要保存的值即可。和Tomasulo算法一样，我们必须避免存储器冒险。用推测可以消除存储器中的WAW和WAR冒险，这是因为存储器更新是循序进行的，当存储指令位于ROB头部时，先前不可能再有尚未完成的载入或存储指令。通过以下两点限制来解决存储器中的RAW冒险。

• 如果一条存储指令占用的活动ROB项目的“目的地”字段与一条载入指令的A字段取值匹配，则不允许该载入指令开始执行第二步骤。
• 在计算一条载入指令的有效地址时，保持相对于所有先前存储指令的程序顺序。

这两条限制条件共同保证了：对于任何一条载入指令，如果它要访问由先前存储指令写入的存储器位置，在这条存储指令写入该数据之前，该载入指令不能执行存储器访问。在发生此类RAW冒险时，一些推测处理器会直接将来自存储指令的值旁路给载入指令。另一种方法是采用值预测方式预测可能出现的冲突；我们将在3.9节考虑这一方法。尽管这里对推测执行的解释主要是针对浮点运算的，但这些技术可以很容易地扩展到整数寄存器和功能单元。事实上，推测在整数程序中可能更有用一些，因为这些程序中的代码可能更难预测一些。此外，只要允许在每个周期内发射和提交多条指令，就可以将这些技术扩展到能够在多发射处理器中工作。事实上，在这些处理器中，一些实用技术可能会在编译器的支持下在基本模块中开发足够的指令级并行，所以对这些处理器来说，推测技术可能是最有意义的。

以多发射和静态调度来开发ILP

前面几节介绍的技术可以用来消除数据与控制停顿，使用CPI到达理想值1。为了进一步提高性能，我们希望将CPI降低至小于1，但如果每个时钟周期仅发射一条指令，那CPI是不可能降低到小于1的。

多发射处理器的目标就是允许在一个时钟周期中发射多条指令。多发射处理器主要有以下3类。

1. 静态调度超标量处理器。
2. VLIW（超长指令字）处理器。
3. 动态调度超标量处理器。

两种超标量处理器每个时钟发射不同数目的指令，如果它们采用静态调度则采用循序执行，如果采用动态调度则采用乱序执行。

与之相对，VLIW处理器每个时钟周期发射固定数目的指令，这些指令可以设置为两种格式之一：一种格式是一个长指令；另一种是一个固定的指令包，指令之间具有一定的并行度，由指令显式表示出来。VLIW处理器由编译器进行静态调度。Intel和HP在创建IA-64体系结构时，它们还将这种体系结构命名为EPIC（显式并行指令计算机）。尽管静态调度超标量处理器在每个周期内发射的指令数是可变的，而不是固定的，但它们在概念上实际与VLIW更接近一些，这是因为这两种方法都依靠编译器为处理器调度代码。

由于静态调度超标量的收益会随着发射宽度的增长而逐渐减少，所以静态调度超标量主要用于发射宽度较窄的情况，通常仅有两条指令。超过这一宽度之后，大多数设计人员选择实现VLIW或动态调度超标量。由于两者的硬件要求和所需要的编译器技术是类似的，所以这一节将主要介绍VLIW。深入理解这一节的内容之后，可以很轻松地将相关道理扩展到静态调度超标量。

表3-10总结了多发射的基本方法和它们的突出特征，并给出了使用每一方法的处理器。

基本VLIW方法

VLIW使用多个独立功能单元。VLIW没有尝试向这些单元发射多条独立指令，而是将多个操作包装在一个非常长的指令中，或者要求发射包中的指令满足同样的约束条件。由于这两种方法之间没有本质性的区别，所以假定将多个操作放在一条指令中，原始VLIW方法即是如此。

由于VLIW的收益会随着最大发射率的增长而增长，所以我们主要关注宽发射处理器。实际上，对于简单的两发射处理器，超标量的开销可能是最低的。许多设计人员可能会说：四发射处理器的开销是可控的，但在本章后面将会看到，开销的增长是限制宽发射处理器的主要因素。

本章主要讨论硬件操作密集的技术，它们都采用某种超标量形式。EPIC方法扩展了早期VLIW方法的主要概念，将静态与动态方法结合在一起。

我们考虑一个VLIW处理器，在上面运行包含5种运算的指令，这5种运算是：一个整数运算（也可以是一个分支）两个浮点运算和两个存储器引用。这些指令可能拥有与每个功能单元相对应的一组字段，每个单元可能为16~24位，得到的指令长度介于80~120位之间。作为对比，Intel Itanium 1和2的每个指令包中包含6个运算（也就是说，它们允许同时发射两个3指令包）。

为使功能单元保持繁忙状态，代码序列必须具有足够的并行度，以填充可用操作插槽。这种并行是通过展开循环和调度单个更大型循环体中的代码而展现的。如果展开过程会生成直行代码，则可以使用局部调度技术，它可以对单个基本模块进行操作。如果并行的发现与开发需要在分支之间调度代码，那就必须使用可能更为复杂的全局调度算法。全局调度算法不仅在结构上更为复杂，而且由于在分支之间移动代码的成本很高，所以它们还必须进行非常复杂的优化权衡。

而现在，我们将依靠循环展开来生成一个长的直行代码序列，所以可以使用局部调度来构建VLIW指令，并集中研究这些处理器的运行情况。

假定有一个VLIW，它可以在每个时钟周期中发射两个存储器引用、两个浮点运算和整数运算或分支。写出针对这样一个处理器展开循环x[i] = x[i] + S的版本。可进行任意次展开，以消除所有停顿。忽略延迟分支。

表3-11给出了这一代码。该循环被展开后，形成循环体的7个副本，消除了所有停顿（即，全空发射周期），运行9个时钟周期。这一代码的运行速度为9个周期生成7个结果，也就是每个结果需要1.29个周期，与3.2节使用非展开调度代码的两发射超标量相比，速度差不多是它的两倍。

在假定没有分支延迟的情况下，这一代码需要9个周期；通常，分支延迟也需要进行调度。其发射速率为9个时钟周期发射23个运算，或者说每个周期2.5个运算。其效率为大约60%（也就是包含操作的可用插槽比例）。为了实现这一发射速率，需要更多寄存器，远远超过MIPS通常在处理这一循环时使用的寄存器数目。上面的VLIW代码序列需要至少8个浮点寄存器，而在基本MIPS处理器上，同一代码序列可以仅使用2个浮点寄存器，在使用未展开调度时，也只需要使用5个。

原始VLIW模块中既存在一些技术问题，也存在一些逻辑问题，从而降低了其效率。技术问题包括代码大小的增大和锁步（clockstep）操作的局限性。有两个不同因素共同造成VLIW代码大小的增大。

• 第一，要在直行代码段中生成足够操作，需要大量展开循环（如前面的示例所示），从而增大了代码大小。
• 第二，只要指令未被填满，那些没有用到的功能单元就会在指令编码时变为多余的位。为了应对这种代码大小的增长，有时会使用智能编码。比如，一条指令中可能只有一个很大的立即数字段供所有功能单元使用。另一种技术是在主存储器中压缩指令，然后在到达缓存或进行译码时再展开它们。

早期的VLIW是锁步工作的，根本就没有冒险检测硬件。在这种结构中，由于所有功能单元都必须保持同步，所以任意功能单元流水线中的停顿都必然导致整个处理器停顿。尽管一个编译器也许能够调度起决定作用的功能单元，以防止停顿，但要想预测哪些数据访问会遭遇缓存停顿，并对它们进行调度，那是非常困难的。因此，应当对缓存进行分块，并能导致所有功能单元停顿。由于发射速度和内存引用数目都变得很大，所以这一同步限制变得不可接受。在最近的处理器中，这些功能单元以更独立的方式工作，在发射时利用编译器来避免冒险，而在发射指令之后，可以通过硬件检测来进行非同步执行。

二进制代码兼容性也是VLIW的主要逻辑问题。在严格的VLIW方法中，代码序列既利用指令集定义，又要利用具体的流水线结构，包括功能单元及其延迟。因此，当功能单元数目和单元延迟不同时，就需要不同的代码版本。与超标量设计相比，由于这一要求而更难以在先后实施版本之间或者具有不同发射带宽的实施方式之间移植代码。当然，要想通过新的超标量设计而提高性能，可能需要重新编译。不过，能够运行旧版本二进制文件是超标量方法的一个实际优势。EPIC方法解决了早期VLIW设计中遇到的许多问题，包括扩展到更积极主动的软件推测与方法，在保证二进制兼容性的前提下克服硬件依赖的局限性。

所有多发射处理器都要面对的重要挑战是尝试开发大量ILP。这种并行是通过展开浮点程序中的简单循环而实现的，而原来的循环很可能可以在向量处理器上高效地运行。对于这类应用程序，目前还不清楚多发射处理器是否优于向量处理器；其成本是类似的，向量处理器的速度可能与多发射处理器相同，或者还会更快一些。多发射处理器相对于向量处理器的潜在优势在于它们能够从结构化程度较低的代码中提取某些并行，以及能够很轻松地缓存所有形式的数据。因为这些原因，多发射方法已经成为利用指令级并行的主要方法，而向量主要作为这些处理器的扩展。

以动态调度、多发射和推测来开发ILP

到目前为止，我们已经看到了动态调度、多发射和推测等各种机制是如何单独工作的。本节，我们将这三种技术结合在一起， 得到一种非常类似于现代微处理器的微体系结构。为简单起见，我们只考虑每个时钟周期发射两条指令的发射速率，但其概念与每个时钟周期发射三条或更多条指令的现代处理器没有什么不同。

假定我们希望扩展Tomasulo算法，以支持具有分离整数、载入存储和浮点单元（包括浮点乘和浮点）加的多发射超标量流水线，每个单元都可以在每个时钟周期启动一个操作。我们不希望向保留站乱序发射指令，这样可能会违犯程序语义。为了获得动态调度的全部好处，允许流水线在一个时钟周期内发射两条指令的任意组合，通过调度硬件向整数和浮点单元实际分配运算。由于整数指令和浮点指令的交互非常关键，所以还会扩展Tomasulo方案，以处理整数和浮点功能单元与寄存器，还能整合推测执行功能。如图3-6，其基本组织结构类似于每个时钟周期发射一条指令、具有推测功能的处理器的组织结构，不过必须改进其发射和完成逻辑，以允许每个时钟周期处理多条指令。

在动态调度处理器中（无论有无推测功能），每个时钟周期发射多条指令都非常复杂，原因很简单，这些指令之间可能存在相关性。因此，必须为这些并行指令更新控制表；否则，这些控制表中可能会出现错误，或者会丢失相关性。

在动态调度处理器中，已经采用两种方法在每个时钟周期内发射多条指令，这两种方法都基于这样一个事实：要在每个时钟周期中发射多条指令，其关键在于保留站的分配和流水线控制表的更新。一种方法是在一个时钟周期的一半时间内运行这一步骤，从而可以在一个时钟周期内运行2条指令；遗憾的是，很难将这一方法扩展为每个时钟周期处理4条指令。

第二种方法是构建必要的逻辑，一次处理两条或更多条指令，包括指令之间可能存在的相关性。可以在每个时钟周期发射四条或更多条指令的现代超标量处理器可能采用这两种方法：都采用流水线方式并拓宽了发射逻辑。一个重要的事实是：仅靠流水线无法解决这一问题。使指令发射占用多个时钟周期时，由于每个时钟周期都会发射新指令，所以必须能够分配保留站，并更新流水线表，使下一个时钟周期进行的相关指令发射能够利用更新后的信息。

在动态调度超标量中，这一发射步骤是最基本的瓶颈之一。为了说明这一过程的复杂性，表3-12给出了一种情景下的发射逻辑：在发射载入命令之后执行一个相关浮点运算。这个逻辑的基础是表3-9，但它仅代表一种情景。在现代超标量中，对于所有可以在同一时钟周期内发射的相关指令的可能组合，都必须加以考虑。这种组合数与一个周期内可发射指令数的平方成正比，所以在尝试突破每时钟周期执行4条指令的速度时，发射步骤可能会成为一个瓶颈。

对于发射指令，rd1和rd2是目的地，rs1、rs2和rt2是源（载入指令仅有一个源），r1和r2是分配的保留站，b1和b2是指定的ROB项目。RS是保留站数据结构。RegisterStat是寄存器数据结构，Regs表示实际寄存器，ROB是重排序缓冲区数据结构。注意，这一逻辑的正常运行需要指定重排序缓冲区项目，还有，别忘了所有这些更新是在单个时钟周期内并行完成的，不是顺序执行！

我们可以推广表3-12的细节，以描述在动态调度超标量中更新发射逻辑和保留表的基本策略，可以在一个时钟周期内发射多达n条指令，如下所示。

1. 为可能在下一个发射包中发射的每条指令指定保留站和重排序缓冲区。这一指定过程可以在知道指令类型之前完成，只需要使用n个可用重排序缓冲区项依次为发射包中的指令预先分配重排序缓冲区项目，并确保有足够的保留站可用于发射整个包（无论包中包含多少指令）即可。通过限制一个给定类别的指令数目（比如，一个浮点运算、一个整数运算、一个载入指令、一个存储指令），就可以预告分配必要的保留站。如果没有足够的保留站可用，比如，当程序中接下来的几条指令都是同一种指令类型时），则将这个包分解，仅根据原始程序顺序，发射其中一部分指令。包中的其余指令可以放在下一个发射包中。
2. 分析发射包中指令之间的所有相关。
3. 如果包中的一条指令依赖于包中的先前指令，则使用指定的重排序缓冲区编号来更新相关指令的保留表。否则，使用已有保留表和重排序缓冲区信息更新所发射指令的保留表项。当然，由于所有这些都要在一个时钟周期中并行完成，所以使上述操作变得非常复杂。

在流水线的后端，必须能够在一个时钟周期内完成和提交多条指令。由于可以在同一时钟周期中实际提交的多条指令必须已经解决了相关性问题，所以这些步骤要比发射问题稍容易一些。从性能的角度来看,我们可以用一个示例来说明这些概念是如何结合在一起的。

考虑以下循环在两发射处理器上的执行情况，它会使整数数组的所有元素递增，一次没有推测，一次进行推测:

1
2
3
4
5

Loop:   LD      R2,0(R1)      ; R2=array element
        DADDIU  R2,R2,#1      ; increment R2 
        SD      R2,0(R1)      ; store result
        DADDIU  R1,R1,#8      ; increment poi nter
        BNE     R2,R3, LOOP   ;branch if not last element

表3-13和表3-14给出了一个两发射动态调度处理器在有、无推测情况下的性能。在本例中，分支是一个关键的性能限制因素，推测会很有帮助。推测处理器中的第三分支在时间周期13中执行，而在非推测流水线中是在时钟周期19中执行。由于非推测流水线上的完成速率很快就会落在发射速率的后面，所以在再发射几个迭代之后，非推测流水线将会停顿。如果允许载入指令在决定分支之前完成有效地址计算，就可以提高非推测处理器的性能，但除非允许推测存储器访问，否则这一改进只会在每次迭代中获得一个时钟周期。

注意，跟在BNE后面的LD不能提前开始执行，因为它必须等待分支结果的判断。这种类型的程序（带有不能提前解决的数据相关分支）展示了推测的威力。将用于地址计算、ALU运算和分支条件求值的功能单元分离开来，就可以在同一周期中执行多条指令。表3-14显示的是这个例子带有推测功能
的版本。

这个例子清楚地表明，推测方法在存在数据相关分支时可以带来一些好处，而在没有这种分支时会限制性能。但是，这种好处依赖于分支预测的准确性。错误预测不会提高性能，事实上，它通常会有损于性能，而且后面将会看到，它会极大地降低能耗效率。

用于指令传送和推测的高级技术

在高性能流水线中，特别是在多发射流水线中，仅仅很好地预测分支还不够；实际上还得能够提高带宽的指令流。在最近的多发射处理器中，所谓高带宽发射流意味着每个时钟周期要提交4~8条指令。我们首先研究提高指令提交带宽的方法，然后再转而研究在实现高级推测技术中的一组关键问题，包括寄存器重命名的应用与重排序缓冲区、推测的积极性和一种称为值预测的技术，它尝试预测计算的结果，可以进一步增强ILP。

提高指令提取带宽

多发射处理器需要每个时钟周期提取的平均指令数目至少等于平均吞吐量。当然，提取这些指令需要有足够宽的路径能够连向指令缓存，但最重要的部分还是分支的处理。在本节，我们将研究两种处理分支的方法，然后讨论现在处理器如何将指令预测和预取功能结合在一起。

分支目标缓冲区

为了减少这个简单的五级流水线以及更深流水线的分支代价，必须知道尚未译码的指令是不是分支，如果是分支，则需要知道下一个程序计数器(PC)应当是什么。如果这条指令是一个分支，而且知道下一个PC应当是什么，那就可以将分支代价降为零。分支预测缓存中存储着一条分支之后下一条指令的预测地址，这一缓存被称为分支目标缓冲区或分支目标缓存。图3-7给出了一个分支目标缓冲区。

图3-7分支目标缓冲区。将所提取指令的PC与第一列中存储的一组指令地址进行匹配，这组地址代表的是已知分支的地址。如果PC与其中一项匹配，则所提取的指令为被选中的分支，第二个字段——预测的PC包含了对该分支之后下一个PC的预测值。会立即在该地址处开始提取指令。第三个字段是可选字段，可用于附加的预测状态位

由于分支目标缓冲区中预测下一条指令地址，并在对该指令译码之前把它发送出去，所以必须知道所提取的指令是否被预测为一条选中分支指令。如果所提供指令的PC与预测缓冲区中的一个地址匹配，则将相应的预测PC用作下一个PC。这种分支目标缓冲区的硬件基本上与缓存硬件相同。

如果在分支目标缓冲区中找到一个匹配项，则立即在所预测的PC处开始提取指令。注意，与分支预测目标不同的是，由于在知道一条指令是否为分支之前就要将预测到的PC发送出去，所以预测项必须与这一指令匹配。如果处理器没有查看这一项是否与这个PC匹配，那么就会为不是分支的指令发送错误的PC，导致性能恶化。我们只需要在分支目标缓冲区中存储预测选中的分支，这是因为未被选中的分支应当直接提取下一条顺序指令，就好像它不是分支指令一样。

图3-8显示了在为简单的五级流水线使用分支目标缓冲区时的步骤。从这个图中可以看出，如果在缓冲区中找到了分支预测项，而且预测正确，那就没有分支延迟。否则，至少存在两个时钟周期的代价。我们在重写缓冲区项目时通常会暂停指令提取，所以要处理错误预测与缺失是一个不小的难题。因此，我们希望快速完成这一过程，将代价降至最低。为了评估一个分支目标缓冲区的工作情况，必须首先判断所有可能情景中的代价。表3-15给出了一个简单五级流水线的相关信息。

如果一切都预测正确，而且在目标缓存中找到该分支，那就没有分支代价。如果分支预测错误，那代价就等于使用正常信息更新缓冲区的一个时钟周期(在此期间不能提取指令)，在需要时，还有一个时钟周期用于重新开始为该分支提取下一个正确指令。如果这个分支没有找到，或未被选中，那代价就是两个周期，在此期间会更新缓冲区。

假定各个错误预测的代价周期如表3-15所示，判断一个分支目标缓冲区的总体分支代价。关于预测准确率和命中率作以下假设:

• 预测准确率为90%（对于缓冲区中的指令）；
• 缓冲区中的命中率为90%（对于预测选中的分支）。

通过研究两个事件的概率来计算代价，一个事件是预测分支将被选中但最后未被选中，另一个事件是分支被选中，但未在缓冲区中找到。这两个事件的代价都是两个周期。

概率（分支在缓冲区中，但未被选中）= 缓冲区命中率 x 错误预测比例 = 90% x 10% = 0.09

概率（分支不在缓冲区中，但被实际选中）= 10%

分支代价=(0.09 + 0.10) x 2.

分支代价=0.38

这一代价略低于延迟分支的分支代价，大约为每个分支0.5个时钟周期。记住，当流水线长度增加从而导致分支延迟增加时，通过动态分支预测得到的性能改善也会随之增加；此外，使用更准确的预测器也会获得更大的性能优势。现代高性能处理器的分支错误预测代价大约为15个时钟周期量级，显然，准确预测是非常关键的！

分支目标缓冲区的一种变体是存储一个或多个目标指令，用于作为预测目标地址的补充或替代。这一变体有两个潜在好处。第一，它允许分支目标缓冲区访问花费的时间长于连续两次指令提取之间的时间，从而可能允许采用更大型的分支目标缓冲区。第二，通过缓存实际目标指令可以让我们执行一种称为分支折合（branch folding）的优化方法。分支折合可用于实现0时钟周期的无条件分支，有时可以实现0时钟周期的条件分支。

考虑一个分支目标缓冲区，它缓冲来自预测路径的指令，可以用无条件分支的地址来访问。无条件分支的唯一作用就是改变PC。因此，当分支目标缓冲区发出命中信号并指出该分支是无条件分支时，流水线只需要将分支目标缓冲区中的指令代替从缓存中的返回的指令（它是一个无条件分支）。如果处理器在每个周期发射多条指令，那么缓冲区需要提供多条指令，以获得最大好处。在一些情况下，有可能消除条件分支的成本。

返回地址预测器

当我们试图提高推测的机会和准确性时，就面临着预测间接跳转的挑战，也就是说跳转到那些在运行时变化的目标地址。尽管高级语言程序会为间接过程调用、选择或case语句、FORTRAN计算的goto语句等生成此类跳转，但大多数间接跳转都源于过程的返回操作。对于诸如C++和Java之类的面向对象的语言，过程返回操作甚至还要频繁。因此，将重点放在过程返回操作上似乎是恰当的。

尽管过程返回操作可以用分支目标缓冲区预测，但如果从多个地方调用这个进程，而且来自一个地方的多个调用在时间方面比较分散，那这种预测方法的准确性会很低。例如，在SPECCPU9S中，一个主动分支预测器对于此类返回分支所能达到的准确率不足60%。为了解决这一问题，一些设计使用了一个小型的返回地址缓冲区，它的工作方式相当于一个栈。这种结构缓存最近的返回地址：在调用时将返回地址压入栈中，在返回时弹出一个地址。如果缓存足够大（也就是与最大调用深度相等），它就能准确地预测过程返回操作。图3-9给出了这样的返回缓冲区在进行许多SPEC CPU95基准测试时的性能，缓冲区的元素数目为0~16个。Intel Core处理器和AMD Phenom处理器都有返回地址
预测器。

作为栈运行的返回地址缓冲区在进行大量SPEC CPU95基准测试时的预测准确率。这一准确率是正确预测返回地址所占的比例。若缓冲区中有0项，意味着使用标准分支预测。由于调用深度通常不是很大(当然也有一些例外），所以中等大小的缓冲区就可以取得很好的效果。使用一种改进机制来防止缓存返回地址出现错误

集成指令提取单元

为了满足多发射处理器的要求，近来的许多设计人员选择实现一个集成指令提取单元，作为独立的自主单元，为流水线的其余部分提供指令。实际上，这是因为他们意识到：由于多发射的复杂性，不能再将取指过程视为简单的单一流水级。最近的设计已经开始使用集成了多种功能的集成指令提取单元，包括以下这些功能。

1. 集成分支预测——分支预测器变为指令提取单元的组成部分，它持续预测分支，以驱动提取流水线。
2. 指令预取——为了在每个时钟周期内提交多条指令，指令提取单元可能需要提前提取指令。这一单元自主管理指令的预取，把它与分支预测结合在一起。
3. 指令存储器访问与缓存——在每个时钟周期提取多条指令时会遇到不同的复杂性，包括：提取多条指令可能需要访问多个缓存行，这是一个难题。指令提取单元封装了这一复杂性，尝试使用预取来隐藏跨缓存模块的成本。指令提取单元还可以提供缓存功能，大体充当一个按需单元，用于根据需要向发射级提供相应数量的指令。

几乎所有高端处理器现在都使用了一个独立的指令提取单元，通过一个包含未完成指令的缓冲区与流水线的其余部分连接在一起。

推测：实现问题与扩展

本节，我们将研究涉及推测设计权衡的4个问题，首先从寄存器重命名开始，这一方法经常被用来替代重排序缓冲区。然后讨论控制流推测的一-个重要扩展: 一种被称为值推测的思想。

推测支持：寄存器重命名与重排序缓冲区

ROB（重排序缓冲区）的一种替代方法是明确使用更大的物理寄存器集，并与寄存器重命名方法结合。这一方法以Tomasulo算法中使用的重命名为基础，并对其进行了扩展。在Tomasulo算法中，在执行过程的任意时刻，体系结构可见的寄存器(R0，…，R31和F0，…, F31）都包含在寄存器集和保留站的某一组合中。在添加了推测功能之后，寄存器值还会临时保存在ROB中。在任一情况下，如果处理器在一段时间内没有发射新指令，所有现有指令都会提交，寄存器值将出现在寄存器堆中，寄存器堆直接与在体系结构中可见的寄存器相对应。

在寄存器重命名方法中，使用物理寄存器的一个扩展集来保存体系结构可见寄存器和临时值。因此，扩展后的寄存器取代了ROB和保留站的大多数功能；只需要一个队列来确保循序完成指令。在指令发射期间，一种重命名过程会将体系结构寄存器的名称映射到扩展寄存器集中的物理寄存器编号，为目的地分配一个新的未使用寄存器。WAR和WAR冒险通过目标寄存器的重命名来避免，在指令提交之前，保存指令目的地的物理寄存器不会成为体系结构寄存器，所以也解决了推测恢复问题。重命名映射是一种简单的数据结构，它提供当前与某个指定体系结构寄存器相对应的寄存器的物理寄存器编号，在Tomasulo算法中，这一功能由寄存器状态表完成。在提交指令时，重命名表被永久更新，用于指示一个物理寄存器与实际体系结构寄存器相对应，从而有效地完成对处理器状态的更新。尽管在采用寄存器重命名时并不需要ROB，但硬件仍然必须在一个类似于队列的结构中跟踪信息，并严格按照顺序来更新重命名表。

与ROB方法相比，重命名方法的一个优点是简化了指令提交过程，它只需要两个简单操作：

• 记录体系结构寄存器编号与物理寄存器编号之间的映射不再是推测结果；
• 释放所有用于保存体系结构寄存器“旧”值的物理寄存器。在采用保留站的设计中，当使用一个保留站的指令完成执行后，该保留站会被释放，与一个ROB项目对应的指令提交之后，该ROB项目也被释放。

在采用寄存器重命名时，撤消寄存器分配的工作要更复杂一些，这是因为在释放物理寄存器之前，必须知道它不再与体系结构寄存器相对应，而且对该物理寄存器的所有使用都已完成。物理寄存器与体系结构寄存器相对应，直到该体系结构寄存器被改写为止，此时将使重命名表指向其他位置。也就是说，如果没有重命名项指向一个特定的物理寄存器，那它就不再对应于体系结构寄存器。但是，对该物理寄存器的使用可能仍未结束。处理器可以通过查看功能单元队列中所有指令的源寄存器说明符。如果一个给定物理寄存器没有显示为源寄存器，而且它也没有被指定为体系结构寄存器，那就可以收回该寄存器，重新进行分配。

或者，处理器也可以一直等待，直到对同一体系结构寄存器执行写入操作的另一指令提交为止。此时，对旧值的使用可能都已经完成了。尽管这种方法对物理寄存器的绑定时间可能要稍长于必要时间，但它的实现非常容易，在最近的超标量中得到了应用。

读者可能会问到的一个问题是: 如果寄存器一直都在变化， 那要如何知道哪些寄存器是体系结构寄存器呢？在程序运行的大多数时间内，这是无所谓的。当然，在某些情况下，另一个进程（比如操作系统）必须知道特定的体系寄存器的内容到底在什么位置。为了理解如何提供这一功能，假定处理器在一段时间内没有发射指令。流水线中的所有指令最终都会提交，体系结构可见寄存器与物理寄存器之间的映射变得稳定。这时，物理寄存器的子集包含体系结构可见寄存器，任何未与体系结构寄存器关联的物理寄存器的都不再需要。从而可以很轻松地将体系结构寄存器移到物理寄存器的一个固定子集中，从而可以将这些值发送给另一进程。

寄存器重命名和重排序缓冲区都继续在高端处理器中使用，这些高端处理器现在能够同时运行40或50条指令（包括在缓存中等待的载入指令和存储指令）。无论是使用重命名还是重排序缓冲区，动态调度超标量的关键复杂性瓶颈仍然在于所发射的指令包中包含相关性的情景。具体来说，在发射一个发射包中的相关指令时，必须使用它们所依赖指令的指定虚拟寄存器。在采用寄存器重命名发射指令时，所部署的策略可以类似于采用重排序缓冲区进行多发射时使用的策略，如下所示。

1. 发射逻辑预先为整个发射包保留足够的物理寄存器（比如，当每个指令最多有一个寄存器结果时，为四指令包预留4个寄存器）。
2. 发射逻辑判断包中存在什么样的相关。如果包中不存在相关，则使用寄存器重命名结构来判断哪个物理寄存器保存着（或将会保存）指令所依赖的结果。如果包中指令都不依赖于先前发射包中的结果，寄存器重命名表中将拥有正确的寄存器编号。
3. 如果一条指令依赖于在该发射包中排在前列的某条指令，那么将使用在其中存放结果的预留物理寄存器来为发射指令更新信息。

注意，就像在重排序缓冲区中一样，发射逻辑必须在一个周期内判断包内相关性，并更新重命名表，而且和前面一样，当每个时钟处理大量指令时，这种做法的复杂度就会成为发射宽度中的一个主要限制。

推测的代价

推测的重要优势之一是能够尽早发现那些本来会使流水线停顿的事件，比如缓存缺失。但是，这种潜在优势也带来一个潜在的重大不利条件。推测不是免费的，它需要时间和能量，错误预测的恢复过程还会进一步降低性能。此外，为了从推测中获益，需要支持更高的指令执行速率，为此，处理器必须拥有更多的资源，而这些资源又会占用硅面积、消耗功率。最后，如果推测导致异常事件的发生，比如缓存缺失或转变旁视缓冲区（TLB）缺失，而没有推测时本来不会发生这种事件，那推测造成重大性能损失的可能性就会增大。

为了在最大程度上保持优势、减少不利因素，大多数具有推测的流水线都仅允许以推测模式处理低成本的异常事件（比如，第一级缓存缺失）。如果发生成本高昂的异常事件，比如第二级缓存缺失或TLB缺失，处理器将会一直等待，等引发该事件的指令不再具有推测性时再来处理这一事件。尽管这样会使一些程序的性能稍有降低，但对于其他一些程序，尤其是会频繁出现此类事件且分支预测效果不佳的程序，可以避免性能大幅降低。

在20世纪90年代，推测的潜在不利因素还不是特别明显。随着处理器的发展，推测的实际成本变得越来越明显，宽发射和推测的局限性也变得更为突出。

多分支预测

在本章已经研究过的示例中，在必须推测一个分支之前， 已经有可能解决另一个分支。有三种情景可以通过同时推测多个分支获益：

• 分支出现频率非常高；
• 分支高度汇集；
• 功能单元中的延迟很长。

在前两种情况下，要实现高性能可能意味着对多个分支进行推测，每个时钟周期甚至可能处理一条以上的指令。数据库程序和其他结构化程度较低的整数计算经常呈现这些特性，使多个分支的预测变得非常重要。同样，功能单元中的延迟很长时，也会增加对多个分支进行推测的重要性，用于避免因为流水线延迟过长而造成的停顿。

对多个分支进行推测会使推测恢复过程变得稍微复杂,但在其他方面比较简单。到2011年，还没有处理器能够将推测与每个时钟周期内处理多条分支完全结合在一起， 从性能与复杂性、功率的对比来看，这样做的成本可能有些过高了。

推测与能耗效率的挑战

推测对能耗效率有什么影响呢?乍看起来，有人可能会说推测的使用总是降低能耗效率，因为只要推测错误，就会以下面两种方式消耗更多的性能。

1. 对某些指令进行了推测，但却不需要它们的结果，这些指令会为处理器生成多余工作，浪费能量。
2. 撤销推测，恢复处理器的状态，以便在适当的地址处继续执行，这些操作都会多消耗一部分能量，在没有推测时是不需要消耗这部分能量的。

当然，推测的确会增大功率消耗，如果我们能够控制推测，那就有可能对成本进行测量（至少可以测量动态功率成本）。但是，如果推测过程缩短的执行时间多于它增加的平均功耗，那消耗的总能量仍然可能减少。

因此，为了了解推测对能耗效率的影响，我们需要研究推测生成非必要任务的频繁程度。如果会执行非常大量的非必要指令，那推测就不大可能大幅缩短运行时间！图3-10给出了由于错误预测而执行的指令比例。可以看到，在科技代码中，这一比例很小，而在整数代码中则很高（平均为大约30%）。因此，对于整数应用程序来说，推测的能耗效率不会很高。设计人员可以避免推测，尝试减少错误预测，或者考虑采用新方法，比如仅对那些已经知道可预测性很强的分支进行推测。

值预测

一种提高程序中可用ILP数目的技术是值预测。值预测尝试预测一条指令可能生成的值。显然，由于大多数指令在每次执行时都生成一个不同值（至少是一组取值中的一个不同值），所以值预测的成功率可能非常有限。但是，也有一些特定的指令，可以很轻松地预测它们的结果值，比如从常数池中进行载入的载入指令，或者载入一个不经常变化的取值。此外，如果一条指令只是从一组很少的取值中选择一个，那就有可能结合其他程序行为来预测结果值。

如果值预测能够显著提高可用ILP的数量，那它就是有用的。当某个值被用作一串相关运算的源数据时（比如一个载入操作），这种可能性就很大。因为值预测是用来提高推测能力的，而且错误预测会有不利的性能影响，所以预测的准确性非常关键。

有一种比较简单的与值预测相关的较早思想已经得到了应用，那就是地址别名预测。地址别名预测是一种非常简单的技术，用来预测两个存储指令或者一个载入指令与一个存储指令是否引用同一存储器地址。如果这样两条指令没有引用同一地址，那就可以放心地交换它们的顺序。否则，就必须等待，直到知道这些指令访问的存储器地址为止。因为我们不需要实际预测地址值，只需要知道这些值是否冲突即可，所以这种预测更稳定，也更简单。

ILP 局限性的研究

在20世纪60年代出现第一批流水化处理时，就开始通过开发ILP来提高性能。这一节的数据还为我们提供了一种方法，用来验证本章所讨论思想的价值，这些思想包括存储器消歧、寄存器重命名和推测。

硬件模型

为了了解ILP可能有哪些局限性，我们首先需要定义一种理想处理器。在理想处理器中，去除了对ILP的所有约束条件。在这样一个处理器中， 对ILP仅有的一些限制是由通过寄存器或存储器的实际数据流带来的。对理想或完美处理器作出以下假设。

1. 无限寄存器重命名——有无限个虚拟寄存器可供使用，因此避免了所有WAW和WAR冒险，可以有无数条指令同时执行。
2. 完美分支预测——分支预测非常完美。所有条件分支都被准确预测。
3. 完美跳转预测——所有跳转（包括用于返回和计算跳转的跳转寄存器）都被完美预测。与完美分支预测相结合，这相当于拥有了一种处理器，它可以进行完美预测，并拥有一个极大的可执行指令缓冲区。
4. 完美存储器地址别名分析——所有存储器地址都已确切知道，如果载入指令与存储指令的地址不同，可以将载入指令移到存储指令之前。注意，这就实现了完美的地址别名分析。
5. 完美缓存——所有存储器访问都占用一个时钟周期。在实践中，超标量处理器通常会使用大量ILP，隐藏了缓存缺失，使这些结果变得非常乐观。

假设（2）与假设（3）消除了所有控制相关。而假设（1）和假设（4）消除了除真数据相关之外的所有数据相关。这4条假设结合在起来，就意味着：对于程序执行中的任何一条指令，在它所依赖的先前指令执行完毕之后，可以将该指令调度到紧随其后的时钟周期上。根据这些假设，甚至有可能将程序中最后一条动态执行的指令调度到最前面的时钟周期上！因此，这一组假设同时包含了控制推测与地址推测，在实现时把它们当作是完美的。

我们首先研究一个可以同时发射无数条指令的处理器，能够提前看到运算过程中的任意指令。在我们研究的所有处理器型号中，对于一个时钟周期能够执行哪些类型的指令没有限制。在可以发射无限条指令时，这意味着在一个时钟周期中可能有无数条载入指令或存储指令。此外，所有功能单元的延迟都假定为一个时钟周期，所以任何相关指令序列都可以在连续周期上发射。如果延迟长于一个周期，尽管不会降低任意时刻正在执行的指令数目，但可能会降低每个周期发射的指令数目。（任意时刻正在执行的指令通常被称为是在in flight。）

为了测量可用并行，可以使用标准MIPS优化编译器来编译和优化一组程序。对这些程序交付运行，生成一个指令与数据引用踪迹。然后尽早调度踪迹中的所有指令，仅受数据相关的限制。由于使用了踪迹，所以很容易实现完美分支预测和完美别名分析。利用这些机制，可以大大提前对这些指令的调度，在没有数据相关的大量指令之间进行移动，由于可以完美预测分支，所以这些指令也包括分支指令在内。

图3-11显示了6个SPEC92基准测试的平均可用并行度数目。本节中，始终以平均指令发射率为指标来测试并行。注意，所有指令的延迟为一个时钟周期；延迟较长时会减少每个时钟的平均指令数。这些基准测试中有3个（fppp、doduc和tomcatv）是浮点操作密集的基准测试，另外3个为整数程序。浮点基准测试中有两个（fppp和tomcatv）有大量并行，可供向量计算机或多处理器开发（不过，由于已经对代码进行了一些人工转换，所以fpppp 中的结构十分杂乱）。doduc程序拥有大量并行，但这些并行不会在简单的并行循环中出现，这一点与fpppp和omcatv中不同。程序li是-个拥有许多短相关的LISP解释程序。

图3-11 一个完美处理器中运行6个SPEC92基准测试时的可用ILP。前3个程序是整数程序，后3个是浮点程序。浮点程序中循环数量很多，有大量循环级并行

可实现处理器上ILP的局限性

本节中，我们将研究一些处理器的性能，具体来说，我们将假定以下固定属性。

1. 每个时钟周期最多发射64条指令、没有发射限制，或者是2011年最宽处理器总发射宽度的10倍以上。后面将会讨论，超大发射宽度对时钟频率、逻辑复杂度和功率产生的实际影响可能才是对ILP开发的最重要限制。
2. 一个竞赛预测器，拥有1000项和一个16项返回预测器。这个预测器可以与2011年的最佳预测器相媲美；这个预测器不是主要瓶颈。
3. 对于动态完成的存储器引用能够完全消除歧义——这项要求是比较高的，但当窗口较小时（因此，发射速度和载入存储缓冲区也较小），或者通过地址别名预测，还是有可能做到的。
4. 具有64个附加整数寄存器和64个浮点寄存器的寄存器重命名，这一数目要略小于2011年的最强劲处理器。

图3-12给出了这一配置在窗口大小变化时的结果。这一配置比任何已有实现方式都要复杂和昂贵，特别是在指令发射数方面，它要比2011年任意处理器上的最大可用发射数大10倍以上。不过，它对未来实施方式所能生成的内容给出了一个非常有用的范围。由于另一个原因，这些图形中的数据可能是非常乐观的。在64条指令中没有发射限制：它们可能都是存储器引用。在不远的将来，甚至没有人会在处理器中设计这一功能。遗憾的是，用合理的发射限制来界定处理器的性能是十分困难的，这不仅是因为存在各种各样的可能性，而且发射限制的存在需要用准确的指令调度器来评估并行，在研究具有大量发射指令的处理器时，其成本会非常昂贵。

另外还请记住，在解读这些结果时，没有考虑缓存缺失和长于1个时钟周期的延迟，这两个因素都可能产生严重影响!

图3-12：对于各种整数与浮点程序，每个时钟周期发射64个任意指令时，可用并行数随窗口大小的变化情况。尽管重命名寄存器的数目少于窗口大小，但所有操作的延迟为一个时钟周期 、重命名寄存器的数目等于发射宽度，这一事实使处理器能够在整个窗口中开发并行。在实际实现中，必须平衡窗口大小和重命名寄存器的数目，以防止这些因素中的某一个过度限制发射速率

图3-12中最令人吃惊的观测结果是:考虑到以下所列的实际处理器约束条件，窗口大小对整数程序的影响不像对浮点程序那么严重。这一结果指向了这两种程序之间的关键区别。两个浮点程序中能够利用循环级并行，这意味着可以开发的ILP数目较高，而对于整数程序，其他因素（比如分支预测、寄存器重命名、并行较少，等等）都是重要的限制情况。从万维网和云计算于20世纪90年代中期开始爆发式发展以来，人们增加了对整数性能的重视，所以这一观察结果非常关键。事实上，在过去10年里，大多数市场增长（事务处理、Web 服务器等）都依赖于整数性能，而不是浮点性能。

由于在实际硬件设计中，提高指令速率具有一定的难度，所以设计人员面临着一项挑战：决定如何更好地利用集成电路上有限的可用资源。是采用具有更大缓存和更高时钟速率的较简单处理器，还是将重点放在具有较慢时钟和较小缓存的指今级并行上，这是最重要的设计权衡之一。下面的例子演示了这些挑战。

考虑以下3种假设的非典型处理器，我们将在上面运行SPEC gcc基准测试。

1. 一个简单的MIPS双发射静态流水线，其时钟速率为4 GHz，所实现的流水线CPI为0.8。这一-处理器的缓存系统每条指令发生0.005次缺失。
2. 一个双发射MIPS处理器的深度流水线版本，缓存稍小一些，时钟速率为5 GHz。处理器的流水线CPI为1.0，缓存较小，平均每条指令生成0.0055次缺失。
3. 一个推测超标量处理器，具有一个64项窗口。它能实现的发射率为这一窗口大小理想发射率的一半。这一处理器的缓存最小，每条指令产生0.01次缺失，但通过动态调度可以隐藏每次缺失25%的缺失代价。这个处理器的时钟为2.5 GHz。

假定主存储器时间（这一时间决定了缺失代价）为50ns。判断这3种处理器的相对性能。

首先，我们使用缺失代价和缺失率信息计算每一种配置中缓存缺失对CPI的影响。计算公式如下:

缓存CPI=每条指令的缺失数x缺失代价

我们需要为每个系统计算缺失代价:

缺失代价=存储器访问时间/时钟周期

这3种处理器的时钟周期时间分别为250 ps、200 ps和400 ps。因此，缺失代价是:

缺失代价1 = 50ns / 250ps = 200周期

缺失代价2 = 50ns / 250ps = 250周期

缺失代价3 = 0.75x50ns / 400ps = 94周期

为每一缓存应用此公式:

缓存CPI1=0.005 x 200=1.0

缓存CPI2=0.0055 x 250=1.4

缓存CPI3=0.01 x 94=0.94

除了处理器3之外，我们知道了其他处理器的流水线CPI影响；它的流水线CPI给出如下:

流水线CPI3 = 1 / 发射速率 = 1 / (9x0.5) = 1 / 4.5 = 0.22

现在可以通过添加流水线和缓存CPI因素来求出每个处理器的CPI:

• CPI1=0.8+1.0=1.8
• CPI2=1.0+1.4=2.4
• CPI3=0.22+0.94=1.16

由于这是同一体系结构，所以可以对比指令执行速度以确定相对性能:

指令执行速度=CR/CPI

指令执行速度1=4000MHz/1.8=2222 MIPS

指令执行速度2=5000MHz/2.4=2083 MIPS

指令执行速度3=2500MHz/1.16=2155 MIPS

在这个例子中，简单的双发射静态超标量看起来是最好的。在实践中，性能取决于CPI和时钟频率两项假设。

超越本研究的局限

和所有极限研究一样，即使在完美推测处理器中也会存在的局限性；在一或多种现实模型中存在的局限性。当然，第一类中的所有局限性也适用于第二类。适用于完美模型的最重要局限性包括以下几个。

（1）访问存储器的WAW和WAR冒险——这一研究通过寄存器重命名消除了WAW和WAR冒险，但却没有消除存储器使用中的冒险。尽管乍看起来，此类情况很少会出现（特别是WAW冒险），但它们的确会因为栈帧分配而出现。某种被调用过程重复利用栈中上一过程使用的存储器位置，这样可能会导致WAW和WAR冒险，造成不必要的限制。

（2）不必要的相关——在有无数个寄存器时，就可以消除真寄存器数据相关之外的所有其他数据相关。但是，由于递归或代码生成约定而造成的相关仍然会引入一些不必要的真数据相关。其中一个例子就是在一个简单的 for 循环中对于控制变量的相关。由于控制变量在每次循环迭代时都会递增，所以循环中包含至少一个相关。Wall 的研究中包含了数量有限的一些此类优化，但更积极地应用这些优化方式有可能增加ILP的数目。此外，特定的代码生成约定也会引入一些不必要的相关，特别是在使用返回地址窗口和栈指针寄存器时（它会在调用/返回序列中递增和递减）。Wall消除了返回地址寄存器的影响，但在链接约定中使用规模指针可能会导致“不必要的”相关。

（3）克服数据流限制——如果值预测的精度很高，那就可能克服数据流限制。显然，完美的数据值预测可以得到高效的无限并行，因为每个指令的每个值都可能提前预测得出。

对于不够完美的处理器，已经提出了几种可以发现更多ILP的思想。其中一个例子是沿多条路径进行推测。通过在多条路径上进行推测，可以降低错误恢复的成本、发现更多的并行。由于所需硬件资源呈指数增长，所以只有对有限个分支评估这一方案才有意义。

交叉问题：ILP方法与存储器问题

硬件推测 与软件推测

下面列出这些硬件密集的推测方法的一些权衡与局限性。

• 为了能够大范围进行推测，必须能够消除存储器引用的歧义。对于包含指针的整数程序，很难在编译时实现这一功能。在基于硬件的方案中，存储器地址的动态运行时消歧是使用前面介绍的Tomasulo算法的技术完成的。这一消歧功能可以在运行时把载入指令移到存储指令之后。对推测存储器引用的支持可以帮助克服编译器的保守性，但如果使用这些方法时不够仔细，那恢复机制的开销可能会大于它们所能带来的收益。
• 当控制流不可预测时，当基于硬件的分支预测优于在编译时完成的软件分支预测时，基于硬件的推测效果较佳。这些特性对于许多整数程序都是成立的。例如，一个好的静态预测器，对4个主要整数SPEC92程序的错误预测率大约为16%，而硬件预测器的错误预测率低于10%。因为当预测不正确时，推测错误的指令可能会拖慢计算速度，所以这一差别非常明显。因为这一差别而导致了一个结果：即使是静态调度的处理器中通常也会包含动态分支预测器。
• 即使对于被推测的指令，基于硬件的推测也能保持完全精确的异常模型。最近的基于软件的方法也添加了这一特殊支持，同样可以做到这一点。
• 基于硬件的推测不需要补充或记录代码，而那些雄心勃勃的软件推测机制则需要这一条件。
• 基于编译器的方法能够深人了解代码序列，从中获益，从而在代码调度方面要优于纯硬件驱动的方法。
• 对于一种体系结构的不同实现方式，采用动态调度的硬件推测不需要采用不同代码序列就能实现好的性能。尽管这一收益很难量化，但从长期来看，这一收益可能是最重要的。有意思的是，它曾经是设计IBM 360/91的动机之一。另一方面，最近的显式并行体系结构(比如IA-64)已经增加一定的灵活性，可以减少代码序列中固有的硬件相关。

在硬件中支持推测的主要缺点是需要更多、更复杂的硬件资源。必须针对两个方面对这一硬件成本进行评估，一是与软件方法中编译器的复杂性相对比，一是与依赖此类编译器的处理器简化程度相对比。

一些设计人员已经尝试将动态方法和基于编译器的方法结合起来，以期达到两种方法的最佳效果。这种组合方式可以产生一些有趣但不够明确的交互。例如，如果将条件移动与寄存器重命名结合起来，就会出现一种微妙的副作用。由于之前已经在指令流水线中更改了目标寄存器的名称，所以一个被撤消的条件移动操作仍然会向目标寄存器中复制一个值。这种微妙的交互使设计与验证过程都变得非常复杂，还可能会降低性能。

迄今为止，在采用软件方法支持ILP和推测的计算机中，Intel Itanium处理器是最强大的。它没有像设计人员所希望的那样提供硬件支持,对于通用、非科学代码尤为如此。意识到3.10节讨论的困难之后，设计人员开发ILP的热情已经减退，因此，在大多数体系结构最终采用的硬件方案中，发射速率为每个时钟周期发射3~4条指令。

推测执行与存储器系统

在一个支持推测执行或条件指令的处理器中，自然可能生成一些在没有 推测执行时就不会用到的无效地址。如果激发了保护异常，那这不仅是一种错误行为，而且推测执行的收益还可能会被错误异常的开销抵消。因此，存储器系统必须识别推测执行的指令和条件执行的指令,并抑制相应的异常。

此类指令可能会导致缓存因缺失而停顿，这些不必要的停顿仍然可能超过推测带来的收益，出于和前面类似的原因，我们不能允许这种现象的发生。因此，这些处理器必须与非阻塞缓存相匹配。

在实际中，由于L2缺失的代价非常大，所以编译器通常都仅对L1缺失进行推测。

多线程:开发线程级并行提高单处理器吞吐量

多线程是一个真正的交叉主题，它同流水线与超标量相关、与图形处理器相关，还与多处理器有关。利用多线程来隐藏流水线和存储器延迟，从而提高单处理器的吞吐量。

尽管使用ILP来提高性能具有很大的优势：它对编程人员是适度透明的，但我们已经看到，在某些应用程序中，ILP可能受到很大的限制或者难以开发。具体来说，当指令发射率处于合理范围时，那些到达存储器或片外缓存的缓存缺失不太可能通过可用ILP来隐藏。当然，当处理器停顿下来等待缓存缺失时，功能单元的利用率会激剧下降。由于人们在试图通过更多的ILP来应对很长的存储器停顿时，效果非常有限。

多线程技术支持多个线程以重叠方式共享单个处理器的功能单元。而与之相对的是，开发线程级并行(TLP)的更一般方法是使用多处理器，它同时并行运行多个独立线程。但是，多线程不会像多处理器那样复制整个处理器。而是在一组线程之间共享处理器核心的大多数功能，仅复制私有状态，比如寄存器和程序计数器。

要复制一个处理器核心中每个线程的状态，就要为每个线程创建独立的寄存器堆、独立的PC和独立的页表。存储器本身可以通过虚拟存储器机制共享，这些机制已经支持多重编程了。此外，硬件必须支持对不同线程进行较快速的修改；具体来说，线程切换的效率应当远远高于进程切换，后者通常需要数百个到数千个处理器周期。当然，为使多线程硬件实现性能改进，一个程序中必须包含能够以并发形式执行的多个线程（有时说这种应用程序是多线程的）。这些线程既可由编译器识别（通常是来自具有并行结构的语言），也可能由程序员识别。实现多线程的硬件方法主要有3种。细粒度多线程每个时钟周期在线程之间进行一次切换，使多个线程的指令执行过程交织在一起。这种交织通常是以轮询方式完成的，当时发生停顿的所有进程都会被跳过。在细粒度多线程情况下，当一个线程停顿时，哪怕这停顿只有几个周期，也可以执行其他线程中的指令，所以这种多线程的一个重要好处是它能够隐藏因为长、短停顿而导致的吞吐量损失。细粒度多线程的一个主要不足是它会减缓个体线程的执行速度，因为一个做好执行准备、没有停顿的线程可能会被其他线程的执行延迟。它用单个进程的性能损失（这里所说的性能是以延迟来衡量的）来换取多线程吞吐量的一致性。

粗粒度多线程的设计目的就是用来作为细粒度的替代选项。粗粒度多线程仅在发生成本较高的停顿时才切换线程，比如第2级或第3级缓存缺失时。通过这一变化， 只有当一个线程遇到成本高昂的停顿时才会发射其他线程的指令，这样就不再严格要求线程切换操作必须是无成本的，同时也大大降低了减缓任一线程执行速度的可能性。不过，粗粒度多线程也有一个严重不足：克服吞吐量损失的能力非常有限，特别是由于较短停顿导致的损失。这一局限性源于粗粒度多线程的流水线启动成本。由于采用粗粒度多线程的CPU仅发现来自单个线程的指令，所以当流水线发生停顿时，在新线程开始执行之前会出现“气泡”。由于这一启动开销，粗粒度多线程更多是用来应对那些成本超高的停顿，当发生此类停顿时，重新填充流水线的时间与停顿时间相比可以忽略不计。已经有几个研究项目对粗粒度多线程进行了探索，但现在的主流处理器中都还没有使用这一技术。

最常见的多线程实施方式称为同时多线程（SMT）。同时多线程是细粒度多线程的一种变体，它是在多发射、动态调度处理器的顶层实现细粒度多线程时自然出现的。和其他形式的多线程一样，SMT利用线程级并行来隐藏处理器中的长延迟事件，从而提高功能单元的利用率。SMT的关键在于认识到通过寄存器重命名和动态调度可以执行来自独立线程的多个指令，而不用考虑这些指令之间的相关性；这些相关性留给动态调度功能来处理。

图3-13从概念上给出了处理器在以下不同配置中开发超标量源的能力差异:

• 不支持多线程的超标量;
• 支持粗粒度多线程的超标量;
• 支持细粒度多线程的超标量;
• 支持同时多线程的超标量。

图3-13 4种不同方法在应用一个超标量处理器功能单元执行槽的表现状况。水平维度表示每个时钟周期中的指令执行能力。垂直维度代表时间周期序列。空白框（白色）表示该时钟周期的相应执行槽未被使用。灰色和黑色的阴影框对应多线程处理器中的4个不同线程。黑色框表示在不支持多线程的超标量中被占用的发射槽。SunT1和T2（akaNiagara）处理器是细粒度多线程处理器，而Intel Core i7 和IBM Power7 处理器使用SMT。T2有8个线程、Power7有4个、Intel i7有2个。在所有现有SMT中，每次只发射一个线程中的指令。SMT的区别在于：在后面决定执行哪条指令时不需要考虑相互之间的影响，可以在同-一个时钟周期执行来自几个不同指令的操作

在不支持多线程的超标量中，由于缺乏ILP（包括用于隐藏存储器延迟的ILP），所以发射槽的使用非常有限。由于L2和L3缓存缺失的长度原因，处理器在大多数时间内可能保持空闲。

在粗粒度多线程超标量中，通过切换到另一个利用处理器资源的线程来部分隐藏长时间的停顿。这一切换减少了完全空闲的时钟周期数。但是，在粗粒度多线程处理器中，仅当存在停顿时才会进行线程切换。由于新线程有一个启动时间，所以仍然可能存在一些完全空闲的周期。

在细粒度情况中，线程的交织可以消除全空槽。此外，由于每个时钟周期都会改变发射线程，所以可以隐藏较长延迟的操作。由于指令发射和执行联系在一起，所以线程所能发射的指令数目仅限于准备就绪的指令。当发射宽度较窄时，没有什么问题（某个时钟周期要么被占用，要么不被占用），这就是细粒度多线程在单发射处理器中能够完美运行的原因，SMT没有什么意义。事实上，在SunT2中，每个时钟周期会有两次发射，但它们来自不同线程。这样就不再需要实施复杂的动态调度方法，而是依靠更多线程来隐藏延迟。

如果在多发射动态调度处理器的顶层实现细粒度线程，所得到的结果就是SMT。在所有现有SMT实现方式中，尽管来自不同线程的指令可以在同一时钟周期内开始执行，但所有发射都来自一个线程，使用动态调度硬件来决定哪些指令已经准备就绪。尽管图3-13极大地简化了这些处理器的实际操作，但它仍然能够说明在发射宽度较宽的动态调度处理器中，一般多线程和SMT的潜在性能优势。

同时多线程的出现是因为深刻地认识到：动态调度处理器已经拥有支持这一方案所需要的大量硬件方案，包括大量虚拟寄存器。通过为每个线程添加专用的重命名表、保持独立的PC、支持提交来自多个不同线程的指令，也可以在乱序处理器上实现多线程。

细粒度多线程在Sun T1上的效果

在这一节，我们利用Sun T1处理器来研究多线程隐藏延迟的能力。T1 是Sun公司在2005年发布的-种细粒度多线程多核微处理器。人们之所以特别关注T1，是因为它几乎将全部重心都放在开发线程级并行（TLP）上，而不是用于开发指令级并行（ILP）。T1 不再强调对ILP的调度（就在此前不久，刚刚发布了更积极的ILP处理器），回归一种简单的流水线策略，着力开发TLP，使用多核和多线程技术来提高吞吐量。

每个T1处理器包含8个处理器核心，每个核心支持4个线程。每个处理器核心包括一个简单的六级、单发射流水线。T1使用细粒度多线程（但不是SMT），每个时钟周期切换到一个新的线程，在调度过程中，会跳过那些因为流水线延迟或缓存缺失而处于等待状态的空闲线程。只有在所有4个线程全部空闲或停顿时，处理器才会空闲。载入指令和分支指令都会导致一个长度为3个时钟周期的延迟，这一延迟只能由其他线程来隐藏。由于浮点性能不是T1的重点，所以它只提供了一组浮点功能单元，由所有8个核心共享。表3-16总结了T1处理器的各个特性。

T1多线程单核性能

T1把自己的重点放在TLP上，既在各个核心上实施了多线程，又在单个晶片上使用了多个简单核心。在这一节，我们将研究T1通过细粒度多线程提升单核心性能的效果。为了研究T1的性能，我们使用3种面向服务器的基准测试: TPC-C、SPECJBB （SPEC Java业务基准测试）和SPECWeb99。由于多个线程会增大单个处理器对存储器的需求，所以可能会使存储器系统过载，从而降低多线程的潜在收益。图3-14是TPC-C基准测试中，在每个核心执行1个线程和每个核心执行4个线程时缺失率及所观测到的缺失延迟的相对增长情况。由于存储器系统的争用增加，缺失率和缺失延迟都会增大。缺失延迟的增幅较小，表示存储器系统仍然有未用空间。

图3-14在TPC-C基准测试中，每个核心执行1个线程和每个核心执行4个线程时缺失率与缺失延迟的相对增长情况。这些延迟是指在一次缺失之后返回所请求数据的实际时间。在4线程情况中，其他线程的执行可能会隐藏这一延迟的大部分时间通过研究一个一般线程的行为，可以了解线程之间进行交互以及它们使核心保持繁忙状态的能力。图3-15给出了3种时钟周期所占的百分比：一种是有线程正在执行，一种是有线程准备就绪，但尚未执行，还有一种是线程没有准备就绪。注意，没有准备就绪并不意昧着拥有该线程的核心处于停顿状态，只有当所有4个线程都未准备就绪时，该核心才会停顿。

囹3-15 一般线程的状态细分。“正在执行”是指该线程在该时钟周期内发射了一条指令。“就绪但未被选中”是指它可以发射指令，但另一线程已被选中；“未就绪”是指该线程正在等待一个事件（例如，一次流水线延迟或缓存缺失）的完成线程未准备就绪可能是因为缓存缺失、流水线延迟（由于一些延迟较长的指令导致，比如分支、载入、浮点或整数乘/除）以及各种影响较小的因素。图3-16显示了这些不同原因的发生频率。在50% ~ 70%的时间里，线程未准备就绪是由缓存原因造成的，L1 指令缺失、L1数据缺失和L2缺失造成的影响大致相同。在SPECJBB中，由于流水线造成的潜在延迟（称为“流水
线延迟”）是最严重的，可能是由于它的分支频率较高所致。

图3-16 线程的未就绪原因细分。“其他”类别的原因是变化的。在TPC-C 中，存储器缓冲区满是最主要的因素；在SPEC-JBB中，原子指令是最主要的因素；而在SPECWeb99中，这两个因素都有影响

表3-17显示了每个线程的CPI和每个核心的CPI。由于T1是一种细粒度多线程处理器，每个核心有4个线程，当有足够的并行时，每个线程的理想有效CPI为4，这意味着每个线程占用每4个时钟周期中的1个周期。每个核心的理想CPI为1。2005年，在积极采用ILP的核心上运行这些基准测试的IPC就已经可以达到T1核心上观测到的类似数据。但是，与2005年更积极的ILP核心相比，T1核心的大小非常合适，这就是为什么T1拥有8个核心，而同一时期的其他处理器只提供了2~4个核心。因此，在2005年发布SunT1处理器时，它在处理TLP密集、存储器性能需求较高的的整数应用程序和事务处理工作负载时，具有最佳性能。

同时多线程在超标量处理器上的效果

一个关键问题是：通过实施SMT可以使性能提高多少？在2000 ~ 2001年研究这一问题时，研究人员认为动态超标量会在接下来的5年里大幅改进，每个时钟周期可以支持6~8次发射，处理器会支持推测动态调度、许多并行载入和存储操作、大容量主缓存、4~8种上下文，可以同时发射和完成来自不同上下文的指令。到目前为止，还没有处理器能够接近这一水平。因此，那些认为多编程工作负载可以使性能提高2 ~ 3倍的模拟研究结果是不现实的。实际中，现有的SMT实现只能提供2~4个带有取值的上下文，只能发射来自一个上下文的指令，每个时钟周期最多发射4条指令。其结果就是：由SMT获得的收益是非常有限的。

例如，在Pentium 4 Extreme中（在HP-Compaq服务器中实现）使用SMT时，运行SPECintRate基准测试时可以使性能提高1.01，运行SPECfpRate基准测试时可以使性能提高1.07。

我们可以使用一组多线程应用程序来研究在单个i7核心中使用SMT时获得的性能与能耗收益。我们使用的基准测试包括一组并行科学应用程序和一组来自DaCapo和SPEC Java 套件的多线程Java程序，在表3-18中对其进行了总结。Intel i7支持拥有两个线程的SMT.图3-17给出了SMT分别为关闭与开启状态时，在i7的-个核心上运行这些基准测试的性能比与能耗效率比。（我们绘制了能耗效率比曲线，能耗效率是能耗的倒数，所以和加速比一样，这个比值越大越好。）

尽管这两个Java基准测试的性能增益较小，但其加速比的调和均值为1.28。在采用多线程时，两个基准测试（pjbb2005和tradebeans）的并行非常有限。之所以包含这些基准测试是因为它们是典型的多线程基准测试，可以在一个指望提高性能的SMT处理器上运行，它们提升效果非常有限。PARSEC 基准测试的加速比要比全套Java基准测试好一些（调和均值为1.31）。如果省略tradebeans和pjbb2005， Java 工作负载的实际加速比（1.39）要比PARSEC基准测试好得多。

融会贯通: Intel Core i7和ARM Cortex-A8

本节，我们研究两种多发射处理器的设计：一种是ARM Cortex- A8核心，它是iPad中AppleA9处理器、Motorola Droid和iPhone 3GS、4中处理器的基础，另一种是Intel Core i7，一种高端、动态调度、推测处理器，主要为高端桌面应用程序和服务器应用程序设计。我们首先从较简单的处理器开始。

ARM Cortex-A8

A8是一种双发射、静态调度超标量处理器，具有动态发射检测功能，允许处理器在每个时钟周期内发射一条或两条指令。图3-18显示了13级流水线的基本流水线结构。A8使用一种动态分支预测器，具有一个512项2路组相联分支目标缓冲区和一个4K项全局历史缓冲区，由分支历史和当前PC进行索引。当出现分支目标缓冲区缺失时，则在全局历史缓冲区中进行预测，然后用预测值计算分支地址。此外，还维护一个8项返回栈，用于跟踪返回地址。一次错误预测会导致13个时钟周期的代价，用于刷新流水线。图3-19显示了指令译码流水线。利用循序发射机制，每个时钟周期最多可以发射两条指令。可以使用一种简单的记分板结构来跟踪何时能够发射一条指令。通过发射逻辑可以处理一对相关指令，当然，除非它们的发射方式能使转发路径消除两者之间的相关，否则会在记分板上对它们进行序列化。

图3-19 A8的5级指令译码。在第一级中，使用取指单元生成的PC（或者来自分支目标缓冲区，或者来自PC递增器）从缓存中提取大小为8字节的块。最多对两条指令进行译码，并将它们放在译码队列中；如果两条指令都不是分支，则将PC递增，为下一次取指做准备。一旦进入译码队列，则由记分板逻辑决定何时可以发射这些指令。在发射时，读取寄存器操作数；回想在简单的记分板中，操作数总是来自寄存器。寄存器操作数和操作码被发送到流水线的指令执行部分

图3-20显示了A8处理器的执行流水线。指令1或指令2可以进入这个载入存储流水线。在这些流水线之间支持完全旁路。ARM Cortex-A8流水线使用简单的双发射靜态调度超标量，可以在较低功率下实现相当高的时钟频率。与之相对，i7 使用一种相当积极的4发射动态调度推理流水线结构。

A8流水线的性能

由于A8采用双发射结构，所以它的理想CPI为0.5。可能会因为以下3种来源而产生流水线停顿。

（1）功能冒险，如果被选择同时发射的两个相邻指令使用同一功能流水线，就会出现功能冒险。由于A8是静态调度的，所以避免此类冲突是编译器的任务。如果不能避免此类冲突，A8在这个时钟周期内最多只能发射一条指令。

（2）数据冒险，在流水线的早期进行侦测，可能使两条指令停顿（如果第一条指令不能发射，第二条总是会被停顿），也可能是一对指令中的第二条指令停顿。编译器负责尽可能防止此类停顿。

（3）控制冒险，仅在分支预测错误时发生。

除了流水线停顿之外，L1和L2缺失都会导致停顿。

图3-21是影响Minnespec基准测试实际CPI的各项因素的估计值，我们在第2章曾经见过这些基准测试。可以看到，这一CPI的主要影响因素是流水线延迟，而不是存储器停顿。出现这一结果的部分原因是Minnespec的缓存印记要小于全套SPEC或其他大型程序。流水线停顿会造成性能大幅下降，深刻认识到这一点，可能对于决定将ARM Cortex-A9设计为动态调度超标量处理器起到了重要作用。A9和A8相似，每个时钟最多发射两条指令，但它使用了动态调度和推测。在一个时钟周期内可以开发执行多达4条未完成指令（2个ALU、1个载入存储或浮点/多媒体指令、1个分支指令）。A9使用一种功能更为强劲的分支预测器、指令缓存预取和非阻塞L1数据缓存。图3-22表明，在使用相同时钟频率和几乎相同的缓存配置时，A9的平均性能是A8的1.28倍。

图3-21对 ARM A8.上CPI各组成分量的估计值表明：流水线停顿是增大基本CPI的主要因素。eon值得专门一提，它完成基于整数的图形计算（光线跟踪），而且缓存缺失很少。由于大量使用乘法，计算非常密集，所以单个乘法流水线可能会成为主要瓶颈。这一估计值是利用L1和L2缺失率与代价来计算每个指令中因为L1和L2生成的停顿而获得的。从具体模拟器测得的CPI中减去这些估计值即可获得流水线停顿。流水线停顿包含所有这3种冒险再加上一些次要影响，比如路预测错误等

图3-22在时钟频率均为 1 GHz、L1 与L2缓存大小相同时，A9与A8的性能比表明: A9大约快1.28倍。两者都使用32KB主缓存和1MB次级缓存，A8采用8路组相关，A9使用16路组相联。A8处理器缓存中的块大小为64字节，A9为32字节。在图3-21的图题中曾经提及， eon 大量使用了整数乘法，动态调度与快速乘法流水线的组合使用显著提高了A9的性能。由于A9的L1块较小，所以twoif的缓存表现不佳，可能是由于这一因素， twoif 的速度略有减缓

Intel Core i7

i7采用非常积极的乱序推测微体系结构，具有较深的流水线，目的是通过综合应用多发射与高时钟速率来提高指令吞吐量。图3-23显示了i7流水线的整体结构。我们在研究流水线时，按照如下步骤，首先从指令提取开始，接下来是指令提交。

图3-23 Intel Core i7流水线结构，一同给出了存储器系统组件。总流水线深度为14级，分支错误预测成本为17个时钟周期。共有48个载入缓冲区和32个存储缓冲区。6个独立功能单元可以在同一时钟周期分别开始执行准备就绪的微操作

（1）指令提取——处理器使用一个多级分支目标缓冲区，在速度与预测准确度之间达到一种平衡。还有一个返回地址栈，用于加速函数返回。错误预测会损失大约15个时钟周期。利用预测地址，指令提取单元从指令缓存中提取16个字节。

（2）16个字节被放在预译码指令缓冲区中——在这一步，会执行一个名为微指令融合的进程。微指令融合接收指令组合（比如先对比后分支），然后将它们融合为一个操作。这个预译码过程还将16个字节分解为单独的x86指令。由于x86指令的长度可能是1 ~ 17字节中的任何一种长度，所以这一预译码非常重要，预译码器必须查看许多字节才能知道指令长度。然后将单独的x86指令（包括一些整合指令）放到包含18项的指令队列中。

（3）微指令译码——各个x86指令被转换为微指令。微指令是一些类似于MIPS的简单指令，可以直接由流水线执行；这种方法将x86指令集转换为更容易实现流水化的简单操作，1997 年在Pentium Pro中引入，一直使用至今。3个译码器处理可以直接转换为一个微指令的x86指令。对于那些语义更为复杂的x86指令，有-一个微码引擎可供用于生成微指令序列；它可以在每个时钟周期中生成多达4条微指令，并一直持续下去，直到生成必要的微指令序列为止。按照x86指令的顺序，将这些微指令放在一个包含28项的微指令缓冲区中。

（4）微指令缓冲区执行循环流检测和微融合——如果存在一个包含循环的小指令序列（长度少于28条指令，或不足256个字节），循环流检测器会找到这个循环，直接从缓冲区中发射微指令，不再需要启动指令提取与指令译码级。微整合则合并指令对，比如载入ALU运算和ALU运算/存储，并将它们发射到单个保留站（在保留站仍然可以独立发射这些指令），从而提高了缓冲区的利用率。在对Intel Core体系结构的一项研究中（这种结构也合并了微整合和宏融合），Bird等人[2007]发现微整合几乎对性能没有什么影响，而宏融合则对整数性能有一定的下面影响，对浮点性能也几乎没有什么影响。

（5）执行基本指令发射——在寄存器表中查看寄存器位置，对寄存器重命名、分配重排序缓冲区项，从寄存器或重排序缓冲区中提取任意结果，然后向保留站发送微指令。

（6）i7使用一个包括36项的集中保留站，供6个功能单元共享。每个时钟周期最多可以向这些功能单元分发6个微指令。

（7）微指令由各个功能单元执行，然后将结果发送给任何正在等待的保留站以及寄存器退回单元，一旦知道指令不再具有推测之后，将在这里更新寄存器状态。重排序缓冲区中与该指令相对应的数目被标记为完成。

（8）当重排序缓冲区头部的一条或多条指令被标记为完成之后，则执行寄存器退回单元中的未完成写入操作，并将这些指令从重排序缓冲区中删除。

i7的性能

在前面几节中，我们研究了i7分支预测器的性能和SMT的性能。在这本节，我们将研究单线程流水线性能。由于积极推测与非阻塞缓存的存在，所以很难准确描述理想性能与实际性能之间的差距。我们将会看到，因为指令不能发射而导致的停顿很少。例如，只有大约3%的载入指令是因为没有可用保留站而导致的。大多数损失不是来自分支错误预测就是来自缓存缺失。分支预测错误的成本为15个时钟周期，而L1缺失的成本大约为10个时钟周期; L2 缺失的成本比L1缺失的3倍略多一些，而L3缺失的成本大约是L1缺失成本的13倍（130~135个时钟周期）!尽管在发生L3缺失和某些L2缺失时，处理器会尝试寻找一些替代指令来执行，但有些缓冲区会在缺失完成之前填满，从而导致处理器停止发射指令。

为了研究错误预测和错误推测的成本，图3-24给出了未退回工作（即它们的结果未被取消）相对于所有微指令分发指令所占的比例（根据分发到流水线中的微指令数目来测量）。比如，对sjeng来说，由于在所分发的微指令中，有25%从来未被退回，所以浪费了25%的工作。注意，在某些情况下，被浪费的工作与图3-3所示的分支错误预测率吻合，而在几种实例中，比如mcf中，被浪费的工作似乎要高于错误预测率。从存储器行为的角度也许能够解释这些情况。当数据缓存缺失率非常高时，只要有足够的保留站可供停顿存储器引用使用，mcf就将在错误的推测期间分发许多指令。在检测到分支预测错误时，与这些指令相对应的微指令将被刷新，但当推测存储器引用试图完成时，可能会产生缓存争用。对处理器来说，在启动缓存请求之后，没有一种简单方法可以使其停止。

图3-24通过计算所有已分发微指令中未退回微指令所占的比值，绘制了“被浪费工作”的数量。例如，sjeng的比值为25%，也就是说在已分发、执行的微指令中有25%被抛弃。

图3-25显示了19 个SPECCPU2006基准测试的总CPI。整数基准测试的CPI为1.06，方差很大（标准偏差为0.67）。MCF和OMNETPP是两个主要例外，它们的CPI都大于2.0，而其他基准测试都接近或小于1.0（gcc是第二高，为1.23）。这种偏差是由于分支预测准确度和缓存缺失率方面的差别造成的。对于整数基准测试，L2缺失率是CPI的最佳预测值，L3缺失率（非常小）几乎没有什么影响。

图3-25 19个SPECCPU2006的CPI表明，尽管行为表现有很大不同，但浮点与整数基准测试的平均CPI都是0.83。整数基准测试的CPI值变化范围为0.44 ~ 2.66，标准偏差为0.77，而浮点基准测试的变化范围为0.62 ~ 1.38，标准偏差为0.25。

浮点基准测试的性能较高:平均CPI较低（0.89）标准偏差较低（0.25）。对于浮点基准测试来说，L1和L2对于确定CPI是同等重要的，而L3则扮演着小而重要的角色。尽管i7的动态调度和非阻塞功能可以隐藏一些缺失延迟，但缓存存储器表现仍然是重要因素。这进一步强化了多线程作为另一种方法来隐藏存储器延迟的作用。

谬论与易犯错误

这里介绍的几点谬论主要集中在根据单一测量值（比如时钟频率或CPI）来预测性能、能耗效率以及进行推断的难度。我们还将表明：对于不同基准测试，不同体系结构方法可能会有截然不同的表现。

谬论：CPI较低的处理器总是要更快一些。

谬论：时钟频率较快的处理器总是要更快一些。

要点在于：性能是由CPI与时钟频率的乘积决定的。在通过实现CPU的深度流水化获得高时钟频率后，还必须保持较低的CPI， 才能全面体现快速时钟频率的优势。同理，一个时钟频率很高、CPI 很低的简单处理器也可能更慢一些 。

在前面讨论的谬论中已经看到，在为不同环境设计的处理器中，即使它们采用相同的ISA，也可能在性能与能耗效率方面有很大不同。事实上，即使是同一公司为高端应用程序设计的同一处理器系列，在性能方面也会有很大差异。表3-20显示的是Intel公司对x86体系结构两种不同实现方式的整数与浮点性能，还有一个是Itanium体系结构，也是Intel出品。

图3-26 一组单线程基准测试的相对性能与功耗效率表明，i7 920比Atom 230快10倍以上，而功率系数平均只有它的二分之一。柱形条中显示的性能是i7与Atom的比值，即执行时间（i7）/执行时间（Atom）。能耗以曲线显示，为能耗（Atom）/能耗（i7）。i7在能耗效率方法从来都没有打羸Atom，不过在4个基准测试方面的性能基本相当，其中有3个是浮点。SPEC基准测试是使用标准Intel编译器在打开优化的情况下编译的，Java 基准测试使用Sun （Oracle） Hostpot Java VM。i7. 上只有一个核心是活动的，其余核心处于深度节能模式。i7上使用了Turbo Boost，这一功能可以提高其性能优势，但相对的能耗效率会略有降低

Pentium 4是Intel公司生成的最积极的流水线处理器。它使用深度超过20级的流水线，有7个功能单元，还有缓存微指令，而不是x86指令。在这种积极的实施方式中，它的性能相对较差一些，这清楚地表明它在开发更多ILP方面的努力失败了（很容易就会同时有50条指令正在执行）。Pentium 的功耗与i7相似，不过它的晶体管数较少，主存储器大约是i7的一半，包括仅有2 MB的次级缓存，没有第三级缓存。

Intel Itanium是一种 VLIW风格的体系结构，尽管调度超标量相比，它的复杂度可能增加，但它的时钟频率从来都不能与主流x86处理器相提并论（尽管它的总CPI与i7类似）。在研究这些结果时，读者应当明白它们不同的实现技术，对于同等流水线的处理器来说，i7 在晶体管速度上具有优势，从而在时间频率方面也占据上风。不过，性能方面的巨大变化（Pentium和i7之间相差3倍以上）还是令人吃惊的。

谬论：有时越大、越被动就越好。

在2000年前期，人们大多把注意力都放在构建更积极的处理器，用于开发ILP，其中就包括Pentium 4体系结构（它在一个微处理器中使用了当时最深的流水线）和Intel Itanium （它每个时钟周期的峰值发射率是当时最高的）。后来人们很快发现在开发ILP时，主要限制因素是存储器系统造成的。尽管推测乱序流水线可以很好地隐藏第一级缺失中10~ 15个时钟周期的大部分缺失代价，但它们在隐藏第二级缺失代价方面几乎是无能为力的，由于涉及主存储器访问，所以第二级缺失代价可能达到50 ~ 100个时钟周期。

结果就是，尽管使用了数目庞大的晶体管和极为高级、聪明的技术，但这些设计从来未能接近峰值指令吞吐量。下一 节将讨论这一两难选择，并从更积极的ILP方案转向多核技术，但过去还出现了另外一个变化，放大了这一缺陷。设计人员不再尝试用ILP来隐藏更多的存储器延迟，而是直接利用晶体管来创建更大的缓存。Itanium 2和i7使用三级缓存，而Pentium 4使用了两级缓存，三级缓存为9MB和8MB，而Pentium 4的二级缓存为2 MB.不用说，构建更多的缓存要比设计20多级的Pentium 4流水线容易得多。

结语: 前路何方

在2000年初，人们对开发指令级并行的关注达到顶峰。Intel 当时要发布Itanium，它是一种高发射率的静态调度处理器，依靠一种类似于VLIW的方法，支持强劲的编译器。采用动态调度推测执行的MIPS、Alpha和IBM处理器正处于其第二代，已经变得更宽、更快。那一年还发布了Pentium 4，它采用推测调度，具有7个功能单元和1个深度超过20级的流水线，然而它的发展前景浮现出一些乌云。

诸如3.10节介绍的研究表明，要想进一步推动ILP是极为困难的，大约三到五年前的第一代推测处理器已经实现了峰值指令吞吐量，而持续指令执行速度的增长要慢得多。接下来的五年真相大白。人们发现Itanium是一个很好的浮点处理器，但在整数处理方面表现泛泛。Intel 仍在生成这一产品，但它的用户不是很多，时钟频率要落后于主流Intel处理器，微软不再支持其指令集。Intel Pentium 4实现了很好的性能，但在性能/瓦特（也就是能量利用）方面的效率很低，这种处理器的复杂程度也使它很难通过提高发射率来进一步提高性能。 这条通过开发ILP来进一步提高处理 器性能的20年之路已经走到尽头。人们普遍认为Pentium 4已经超越了回报递减点，积极、复杂的Netburst微体系结构被放弃。

到2005年， Intel和所有其他主要处理器制造商都调整了自己的方法，将重点放在多核心上。往往通过线程级并行而不是指令级并行来实现更高的性能，高效运用处理器的责任从硬件转移到软件和程序员身上。从流水线和指令级并行的早期发展以来（大约是25年之前），这是处理器体系结构的最重大变化。在同一时间，设计人员开始探索利用更多数据级并行来作为提高性能的另一方法。 SIMD扩展使桌面和服务器微处理器能够适当地提高图形功能及类似功能的性能。更重要的是，GPU追求更积极地使用SIMD，用大量数据级并行来实现应用程序的极大性能优势。对于科学应用程序，这些方法可以有效地替代在多核心中开发的更具一般性但效率较低的线程级并行。

许多研究人员预测ILP的应用会大幅减少，预计未来会是双发射超标量和更多核心的天下。但是，略高的发射率以及使用推测动态调度来处理意外事件（比如一级缓存缺失）的优势，使适度ILP成为多核心设计的主要构造模块。SMT的添加及其有效性（无论是在性能方面还是在能耗效率方面）都进一步巩固了适度发射、乱序、推测方法的地位。事实上，即使是在嵌入市场领域，最新的处理器（例如ARM Cortex-A9）已经引入了动态调度、推测和更宽的发射速率。

未来处理器几乎不会尝试大幅提高发射宽度。因为从硅利用率和功率效率的角度来看，它的效率太低了。在过去10年里， Power处理器对ILP的支持已经有了一定的改进，但所增加的大部分晶体管（从Power 4到Power7增加了差不多7倍）用来提高每个晶片的缓存和核心数目。甚至对SMT支持扩展的重视也多于ILP吞吐量的增加：从Power4到Power7的ILP结构由5发射变为6发射，从8个功能单元变为12 个（但最初的2个载入存储单元没有变化），而SMT支持从零变为4个线程/处理器。显然，即使是2011年最高级的ILP处理器（Power7），其重点也超越了指令级并行。

第一章：STL概论和版本简介

STL六大组件

1. 容器：各种数据结构，如：vector、list、deque、set、map、主要用来存放数据。
2. 算法：各种常见算法，如：sort、search、copy、erase
3. 迭代器：扮演算法和容器中的中介。迭代器是一种将operator*、operator->、operator++、operator--等指针相关操作予以重载的class template。所有的容器均有自己独特的迭代器，实现对容器内数据的访问
4. 仿函数：行为类似函数，可作为算法的某种策略。仿函数是一种重载了operator()的class或class template。一般指针函数可视为狭义的仿函数。
5. 配接器（adapters）: 修饰容器、仿函数、迭代器接口。例如STL提供的queue和stack，虽然看似容器，但是只能算一种容器配接器，因为它们的底部完全借助deque，所有操作都由底层的deque供应。
6. 配置器（allocators）：负责空间配置和管理，配置器是一个实现了动态空间配置、空间管理、空间释放的class template.

各组件间的关系

由于STL已成为C++标准程序库的大脉系，因此：目前所有的C++编译器一定支持有一份STL。STL并非以二进制代码面貌出现，而是以源代码面貌供应。某些STL版本同时存在具扩展名和无扩展名的两份文件，例如Visual C++的版本同时具备<vectorr.h>和<vector>。某些STL版本只存在具扩展名的头文件，例如C++ Builder的RaugeWave版本只有<vector.h>。某些STL版本不仅有一线装配，还有二线装配，例如GNU C++的SGI版本不但有一线的<vector.h>和<vector>，还有二线的<stl_vector.h>。

Container通过Allocator取得数据储存空间，Algorithm通过Iterator存取Container内容，Functor可以协助Algorithm完成不同的策略变化，Adapter可以修饰或套接Functor。

SGI STL头文件分布

• C++标准规范下的C头文件：cstdio，csyflib，cstring，…
• C++标准程序库中不属于STL范畴者：stream，string，…
• STL标准头文件(无扩展名)：vector，deque，list，map，…
• C++标准定案前，HP所规范的STL头文件：vector.h，deque.h，list.h，…
• SGI STL内部文件(STL真正实现与此)：stl_vector.h，stl_deque.h，stl_algo.h，…

不同的编译器对C++语言的支持程度不尽相同。作为一个希望具备广泛移植能力的程序库，SGI STL准备了一个环境组态文件<stl_config.h>，其中定义了许多常量，标示某些组态的成立与否，所有STL头文件都会直接或间接包含这个组态文件，并以条件式写法，让预处理器根据各个常量决定取舍哪一段程序代码，例如：

<stl_config.h>文件起始处有一份常量定义说明，针对各家不同的编译器及可能的版本给予常量设定。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246

// Filename:    stl_config.h  
/* 
 * Copyright (c) 1996-1997 
 * Silicon Graphics Computer Systems, Inc. 
 * 
 * Permission to use, copy, modify, distribute and sell this software 
 * and its documentation for any purpose is hereby granted without fee, 
 * provided that the above copyright notice appear in all copies and 
 * that both that copyright notice and this permission notice appear 
 * in supporting documentation.  Silicon Graphics makes no 
 * representations about the suitability of this software for any 
 * purpose.  It is provided "as is" without express or implied warranty. 
 */  
  
/* NOTE: This is an internal header file, included by other STL headers. 
 *   You should not attempt to use it directly. 
 */  
  
#ifndef __STL_CONFIG_H  
#define __STL_CONFIG_H  
  
//  本配置文件功能表:  
//  (1)  如果不编译器没有定义bool, true, false则定义  
//  (2)  如果编译器不支持drand48()函数则定义__STL_NO_DRAND48  
//       注: drand48产生双精度的伪随机数, 因为采用了48bit计算, 故名drand48  
//  (3)  如果编译器不支持static members of template classes(模板类静态成员),  
//       则定义__STL_STATIC_TEMPLATE_MEMBER_BUG  
//  (4)  如果编译器不支持'typename'关键字, 则将'typename'定义为空(null macro)  
//  (5)  如果编译器支持partial specialization of class templates(模板类偏特化),  
//       则定义__STL_CLASS_PARTIAL_SPECIALIZATION  
//       参考文献: http://msdn.microsoft.com/en-us/library/9w7t3kf1(v=VS.71).aspx  
//  (6)  如果编译器支持partial ordering of function templates(模板函数特化优先级),  
//       则定义__STL_FUNCTION_TMPL_PARTIAL_ORDER  
//       参考资料: http://msdn.microsoft.com/zh-cn/library/zaycz069.aspx  
//  (7)  如果编译器支持calling a function template by providing its template  
//       arguments explicitly(显式指定调用模板函数的模板参数)  
//       则定义__STL_EXPLICIT_FUNCTION_TMPL_ARGS  
//  (8)  如果编译器支持template members of classes(类模板成员),  
//       则定义__STL_MEMBER_TEMPLATES  
//  (9)  如果编译器不支持'explicit'关键字, 则将'explicit'定义为空(null macro)  
//  (10) 如果编译器不能根据前一个模板参数设定后面的默认模板参数,  
//       则定义__STL_LIMITED_DEFAULT_TEMPLATES  
//  (11) 如果编译器处理模板函数的non-type模板参数类型推断有困难,  
//       则定义__STL_NON_TYPE_TMPL_PARAM_BUG  
//  (12) 如果编译器不支持迭代器使用'->'操作符,  
//       则定义__SGI_STL_NO_ARROW_OPERATOR  
//  (13) 如果编译器(在当前编译模式下)支持异常,  
//       则定义__STL_USE_EXCEPTIONS  
//  (14) 如果我们将STL放进命名空间中,  
//       则定义__STL_USE_NAMESPACES  
//  (15) 如果本STL在SGI的编译器上编译, 并且用户没有选择pthreads或者no threads,  
//       则默认使用__STL_SGI_THREADS  
//       注: POSIX thread 简称为pthread, Posix线程是一个POSIX标准线程.  
//  (16) 如果本STL在Win32平台的编译器上使用多线程模式编译,  
//       则定义__STL_WIN32THREADS  
//  (17) 适当的定义命名空间相关的宏(__STD, __STL_BEGIN_NAMESPACE, 等)  
//  (18) 适当的定义异常相关的宏(__STL_TRY, __STL_UNWIND, 等)  
//  (19) 根据是否定义__STL_ASSERTIONS, 将__stl_assert定义为断言或者空(null macro)  
  
#ifdef _PTHREADS  
#   define __STL_PTHREADS  
#endif  
  
// 如果编译器不提供本STL需要的一些功能,则定义__STL_NEED_XXX  
# if defined(__sgi) && !defined(__GNUC__)  
#   if !defined(_BOOL)  
#     define __STL_NEED_BOOL  
#   endif  
#   if !defined(_TYPENAME_IS_KEYWORD)  
#     define __STL_NEED_TYPENAME  
#   endif  
#   ifdef _PARTIAL_SPECIALIZATION_OF_CLASS_TEMPLATES  
#     define __STL_CLASS_PARTIAL_SPECIALIZATION  
#   endif  
#   ifdef _MEMBER_TEMPLATES  
#     define __STL_MEMBER_TEMPLATES  
#   endif  
#   if !defined(_EXPLICIT_IS_KEYWORD)  
#     define __STL_NEED_EXPLICIT  
#   endif  
#   ifdef __EXCEPTIONS  
#     define __STL_USE_EXCEPTIONS  
#   endif  
#   if (_COMPILER_VERSION >= 721) && defined(_NAMESPACES)  
#     define __STL_USE_NAMESPACES  
#   endif  
#   if !defined(_NOTHREADS) && !defined(__STL_PTHREADS)  
#     define __STL_SGI_THREADS  
#   endif  
# endif  
  
# ifdef __GNUC__  
#   include <_G_config.h>  
#   if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8)  
#     define __STL_STATIC_TEMPLATE_MEMBER_BUG  
#     define __STL_NEED_TYPENAME  
#     define __STL_NEED_EXPLICIT  
#   else  
#     define __STL_CLASS_PARTIAL_SPECIALIZATION  
#     define __STL_FUNCTION_TMPL_PARTIAL_ORDER  
#     define __STL_EXPLICIT_FUNCTION_TMPL_ARGS  
#     define __STL_MEMBER_TEMPLATES  
#   endif  
    /* glibc pre 2.0 is very buggy. We have to disable thread for it. 
       It should be upgraded to glibc 2.0 or later. */  
#   if !defined(_NOTHREADS) && __GLIBC__ >= 2 && defined(_G_USING_THUNKS)  
#     define __STL_PTHREADS  
#   endif  
#   ifdef __EXCEPTIONS  
#     define __STL_USE_EXCEPTIONS  
#   endif  
# endif  
  
// Sun C++ compiler  
# if defined(__SUNPRO_CC)  
#   define __STL_NEED_BOOL  
#   define __STL_NEED_TYPENAME  
#   define __STL_NEED_EXPLICIT  
#   define __STL_USE_EXCEPTIONS  
# endif  
  
# if defined(__COMO__)  
#   define __STL_MEMBER_TEMPLATES  
#   define __STL_CLASS_PARTIAL_SPECIALIZATION  
#   define __STL_USE_EXCEPTIONS  
#   define __STL_USE_NAMESPACES  
# endif  
  
// _MSC_VER 定义微软编译器的版本  
// MS VC++ 10.0 _MSC_VER = 1600  
// MS VC++ 9.0 _MSC_VER = 1500  
// MS VC++ 8.0 _MSC_VER = 1400  
// MS VC++ 7.1 _MSC_VER = 1310  
// MS VC++ 7.0 _MSC_VER = 1300  
// MS VC++ 6.0 _MSC_VER = 1200  
// MS VC++ 5.0 _MSC_VER = 1100  
# if defined(_MSC_VER)  
#   if _MSC_VER > 1000  
#     include <yvals.h>  
#   else  
#     define __STL_NEED_BOOL  
#   endif  
#   define __STL_NO_DRAND48  
#   define __STL_NEED_TYPENAME  
#   if _MSC_VER < 1100  
#     define __STL_NEED_EXPLICIT  
#   endif  
#   define __STL_NON_TYPE_TMPL_PARAM_BUG  
#   define __SGI_STL_NO_ARROW_OPERATOR  
#   ifdef _CPPUNWIND  
#     define __STL_USE_EXCEPTIONS  
#   endif  
#   ifdef _MT  
#     define __STL_WIN32THREADS  
#   endif  
# endif  
  
# if defined(__BORLANDC__)  
#   define __STL_NO_DRAND48  
#   define __STL_NEED_TYPENAME  
#   define __STL_LIMITED_DEFAULT_TEMPLATES  
#   define __SGI_STL_NO_ARROW_OPERATOR  
#   define __STL_NON_TYPE_TMPL_PARAM_BUG  
#   ifdef _CPPUNWIND  
#     define __STL_USE_EXCEPTIONS  
#   endif  
#   ifdef __MT__  
#     define __STL_WIN32THREADS  
#   endif  
# endif  
  
  
# if defined(__STL_NEED_BOOL)  
    typedef int bool;  
#   define true 1  
#   define false 0  
# endif  
  
# ifdef __STL_NEED_TYPENAME  
#   define typename  
# endif  
  
# ifdef __STL_NEED_EXPLICIT  
#   define explicit  
# endif  
  
# ifdef __STL_EXPLICIT_FUNCTION_TMPL_ARGS  
#   define __STL_NULL_TMPL_ARGS <>  
# else  
#   define __STL_NULL_TMPL_ARGS  
# endif  
  
# ifdef __STL_CLASS_PARTIAL_SPECIALIZATION  
#   define __STL_TEMPLATE_NULL template<>  
# else  
#   define __STL_TEMPLATE_NULL  
# endif  
  
// __STL_NO_NAMESPACES is a hook so that users can disable namespaces  
// without having to edit library headers.  
# if defined(__STL_USE_NAMESPACES) && !defined(__STL_NO_NAMESPACES)  
#   define __STD std  
#   define __STL_BEGIN_NAMESPACE namespace std {  
#   define __STL_END_NAMESPACE }  
#   define __STL_USE_NAMESPACE_FOR_RELOPS  
#   define __STL_BEGIN_RELOPS_NAMESPACE namespace std {  
#   define __STL_END_RELOPS_NAMESPACE }  
#   define __STD_RELOPS std  
# else  
#   define __STD  
#   define __STL_BEGIN_NAMESPACE  
#   define __STL_END_NAMESPACE  
#   undef  __STL_USE_NAMESPACE_FOR_RELOPS  
#   define __STL_BEGIN_RELOPS_NAMESPACE  
#   define __STL_END_RELOPS_NAMESPACE  
#   define __STD_RELOPS  
# endif  
  
# ifdef __STL_USE_EXCEPTIONS  
#   define __STL_TRY try  
#   define __STL_CATCH_ALL catch(...)  
#   define __STL_RETHROW throw  
#   define __STL_NOTHROW throw()  
#   define __STL_UNWIND(action) catch(...) { action; throw; }  
# else  
#   define __STL_TRY  
#   define __STL_CATCH_ALL if (false)  
#   define __STL_RETHROW  
#   define __STL_NOTHROW  
#   define __STL_UNWIND(action)  
# endif  
  
#ifdef __STL_ASSERTIONS  
# include <stdio.h>  
# define __stl_assert(expr) \  
    if (!(expr)) { fprintf(stderr, "%s:%d STL assertion failure: %s\n", \  
              __FILE__, __LINE__, # expr); abort(); }  
#else  
# define __stl_assert(expr)  
#endif  
  
#endif /* __STL_CONFIG_H */  
  
// Local Variables:  
// mode:C++  
// End: